sikios » プログラミング

ウィンドウメッセージ

rei — Thu, 08 Jul 2010 19:27:19 +0000

フォームアプリケーションでは使う機会は少ないけれども、用意しておくと便利かもしれない。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232

F# メモ XNA Framework

rei — Sat, 13 Mar 2010 13:08:00 +0000

F#でも XNA が使用できます。
ただし .NET Framework 4.0 ではビルドできませんでした。3.5 なら問題なくビルドできます。
おそらく、 XNA Game Studio 4.0 がリリースされれば .NET Framework 4.0 でもビルドできるようになると思われます。

BasicComponents.fs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

namespace Siki

open System
open System.Collections.Generic
open Microsoft.Xna.Framework

module BasicComponents =

/// 秒を表す単位
[<Measure>]
type sec =
static member Unit v = v * 1.0<sec>
static member Unit v = v * 1<sec>

/// フレームを表す単位
[<Measure>]
type frame =
/// 1フレームを表す
static member Unit v = v * 1.0<frame>
static member Unit v = v * 1<frame>

/// 1秒あたりの描画フレーム数を計算するコンポーネント
type FpsComponent(game, syncv, fixedStep, targetFps) =
inherit DrawableGameComponent(game)
// フィールド
let m_interval = 1.0<sec>
let mutable m_fps = 0.0<frame/sec>
let mutable m_sec = 0.0<sec>
let mutable m_framecount = 0.0<frame>
let mutable m_lastupdate = 0.0<sec>

// メインコンストラクタ
do
let graphics =
game.Services.GetService(typeof<IGraphicsDeviceManager>)
:?> GraphicsDeviceManager

graphics.SynchronizeWithVerticalRetrace <- syncv
game.IsFixedTimeStep <- fixedStep
game.TargetElapsedTime <- TimeSpan.FromSeconds(1.0 / targetFps)

/// カスタムコンストラクタ
new(game) =
new FpsComponent(game, false, false, 1.0 / game.TargetElapsedTime.TotalSeconds)

new(game, syncv) =
new FpsComponent(game, syncv, false, 1.0 / game.TargetElapsedTime.TotalSeconds)

new(game, targetFps) =
new FpsComponent(game, true, true, targetFps)

/// 現在のFPS値を取得する
member x.Fps
with get() = m_fps

/// 現在のFPSを整数に丸めた値を取得する
member x.RoundFps
with get() = x.Fps |> float |> Math.Round |> int

/// 初期化メソッド
override x.Initialize() =
base.Initialize()

/// 更新メソッド
override x.Update(gametime) =
base.Update(gametime)

/// 描画メソッド
override x.Draw(gametime) =
let elapsed = gametime.ElapsedGameTime.TotalSeconds |> sec.Unit
m_framecount <- m_framecount + 1.0<frame>
m_sec <- m_sec + elapsed
if m_sec > m_interval then
m_fps <- m_framecount / m_sec
x.Game.Window.Title <- sprintf "%d fps" x.RoundFps
m_framecount <- 0.0<frame> // カウンタリセット
m_sec <- m_sec - m_interval
base.Draw(gametime)

Program.fs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

namespace Siki

open System
open System.Collections.Generic
open Microsoft.Xna.Framework
open Microsoft.Xna.Framework.Graphics

open Siki.BasicComponents

module Main =
/// ゲームクラス
type Game1() as x =
inherit Game(IsMouseVisible=true,
IsFixedTimeStep=false)

// フィールド
let m_rand = new Random()
let m_graphics = new GraphicsDeviceManager(x)
let m_fpscomponent = new FpsComponent(x)
let mutable m_num = 0
let mutable m_bgc = new Color(80uy, 80uy, 80uy)
let mutable m_rd = -1
let mutable m_gd = -1
let mutable m_bd = -1
// メインコンストラクタ
do
x.Window.Title <- "FPSを表示します"
/// 初期化メソッド
override x.Initialize() =
x.Components.Add(m_fpscomponent)
base.Initialize()

/// 更新メソッド
override x.Update gametime =
m_num <- m_num + 1
base.Update gametime

/// 描画メソッド
override x.Draw gametime =
match m_rand.Next(0, 5) with
| 0 ->
m_bgc.R <- m_bgc.R + (m_rd |> byte)
if (m_bgc.R = 0x00uy || m_bgc.R = 0xffuy) then m_rd <- m_rd * -1
| 1|2 ->
m_bgc.G <- m_bgc.G + (m_gd |> byte)
if (m_bgc.G = 0x00uy || m_bgc.G = 0xffuy) then m_gd <- m_gd * -1
| 3|4|5 ->
m_bgc.B <- m_bgc.B + (m_bd |> byte)
if (m_bgc.B = 0x00uy || m_bgc.B = 0xffuy) then m_bd <- m_bd * -1
| _ -> ()
m_graphics.GraphicsDevice.Clear(
m_bgc
)
base.Draw gametime

/// プログラムのエントリポイント
[<EntryPoint>]
let main(args:string[]) =
use game = new Game1()
game.Run()
0

FPSを計算するだけの簡単なサンプルです。
Update()、Draw()が呼ばれていることを確認するために、少しずつ背景色を変えています。

F# メモ Option

rei — Thu, 04 Mar 2010 18:23:20 +0000

Option型

C#でいうNullable型のようなもので、値を持たないことも表せるようになる。

引数 x が自然数なら x を、負の数なら None (値を持たない) を返す。

> let natural x =
if x >= 0 then Some x
else None;;

val natural : int -> int option

Option.get
‘a option -> ‘a

Option型は Some (値を持っている) か None (値を持たない) のいずれかを表し、
Some の場合は値を取得できる。
None に対し Option.get を行うと例外が発生する。

> let a = natural 100
let b = natural -100
let c = Option.get a;;

val a : int option = Some 100
val b : int option = None
val c : int = 100

Option.isSome
‘a option -> bool

引数が Some なら true を、None なら false を返す。

Option.isNone
‘a option -> bool

引数が Some なら true を、None なら false を返す。

F# メモ List (2)

rei — Fri, 26 Feb 2010 13:16:49 +0000

リスト関数

関数関数の型	簡単な説明
List.length ‘a list -> int	要素の数を取得する
List.head ‘a list -> ‘a	先頭の要素を取得する
List.tail ‘a list -> ‘a list	先頭の要素を除いたリストを取得する
List.exists (‘a -> bool) -> ‘a list -> bool	条件に合う要素が存在するか調べる
List.rev ‘a list -> ‘a list	順番を逆にしたリストを取得する
List.tryFind (‘a -> bool) -> ‘a list -> ‘a option	条件に合う要素を取得する存在しない場合はNoneを返す
List.zip ‘a list -> ‘b list -> (‘a ‘b) list*	2つのリストの要素を組み合わせ、タプルのリストを作成する
List.filter (‘a -> bool) ‘a list -> ‘a list	条件に合う要素のみを含むリストを作成する
List.partition (‘a -> bool) -> ‘a list -> (‘a list ‘a list)*	条件に合う要素のみを含むリストとそれ以外のリストのタプルを作成する

他にも多数あります。msdn

集約関数 (Aggregate Operators)

リストなどのコレクションには個々の要素に対して何らかの操作を行う関数が多数用意されている。

List.map
(‘a -> ‘b) -> ‘a list -> ‘b list

‘a -> ‘b 変換関数をすべての要素に適用し、’b list を作成する。

例：整数のリストを基に、文字列のリストを作成する。

> let tostr x = sprintf "%d" x
let a = [1..10]
let b = List.map tostr a;;

val tostr : int -> string
val a : int list = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
val b : string list = ["1"; "2"; "3"; "4"; "5"; "6"; "7"; "8"; "9"; "10"]

List.reduce
(‘a -> ‘a -> ‘a) ->’a list -> ‘a

リストの要素を辿りながら ‘a 型のアキュムレータを構築していく関数。
(‘a -> ‘a -> ‘a) の部分は現在のアキュムレータとリストの要素を引数とし、新たなアキュムレータを作成する関数。

例：1から5までの整数の積を求める。(ついでに、アキュムレータの確認を行う)

> let multiple a b =
printfn "// %3d = %2d * %d" (a*b) a b
a * b
let b = List.reduce multiple [1..5];;
// 2 = 1 * 2
// 6 = 2 * 3
// 24 = 6 * 4
// 120 = 24 * 5

val multiple : int -> int -> int
val b : int = 120

上の例のように、リストの先頭要素がアキュムレータの初期値となる。

List.fold
(‘acc -> ‘b -> ‘acc) -> ‘acc -> ‘b list -> ‘acc

リストの要素を辿りながら任意の型のアキュムレータを構築していく関数。
List.reduceを汎用的にしたもの。
アキュムレータの初期値を与える必要がある。

例：リスト中の文字数の合計を取得する

> let Count acc (str:string) = acc + str.Length
let dow = [
"Sunday";
"Monday";
"Tuesday";
"Wednesday"
]
let total = List.fold Count 0 dow;;

val Count : int -> string -> int
val dow : string list = ["Sunday"; "Monday"; "Tuesday"; "Wednesday"]
val total : int = 28

List.iter
(‘a -> unit) -> ‘a list -> unit

指定された関数を、リストの各要素に対して順次実行する関数。

F# メモ List (1)

rei — Thu, 25 Feb 2010 16:57:46 +0000

基本

リストの作成。
[] で囲み、要素は ; で区切る。

> let odds = [1;3;5;7;9]
let evens = [2;4;6;8;10];;

val odds : int list = [1; 3; 5; 7; 9]
val evens : int list = [2; 4; 6; 8; 10]

リストの追加。
@ はリストの結合を行う。

> let appended = odds @ evens;;

val appended : int list = [1; 3; 5; 7; 9; 2; 4; 6; 8; 10]

要素の追加。
:: はリストの先頭に要素を追加する。

> 0 :: appended;;
val it : int list = [0; 1; 3; 5; 7; 9; 2; 4; 6; 8; 10]

範囲を指定する。
1から10までの整数のリストを作成する。

> let x = [1..10];;

val x : int list = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]

範囲と間隔を指定する。
1から10までの奇数のリストを作成する。

> let x = [1..2..10];;

val x : int list = [1; 3; 5; 7; 9]

要素を持たないリスト。

> let emptylist = [];;

val emptylist : 'a list

yield

リストの要素を何らかの手続きで決定させることができる。

> let near x =
[
yield x - 1
yield x
yield x + 1
]
let nearTen = near 10;;

val near : int -> int list
val nearTen : int list = [9; 10; 11]

引数の値とその前後の値を要素とするリストを返す関数 near を作成し、10を与えている。
上から順に評価されるので、10-1=9、10、10+1=11が要素となる。

[] の中には条件式やループ等も使用できる。
30以下の素数のリストを作成する例。

> let primes =
[
let factors n =
[
for i in 2..n-1 do
if n % i = 0 then
yield i
]

for i in 2..30 do
if List.length (factors i) = 0 then
yield i
];;

val primes : int list = [2; 3; 5; 7; 11; 13; 17; 19; 23; 29]

F# メモコメント

rei — Thu, 25 Feb 2010 10:37:58 +0000

行コメント

C++と同じで // から行末までがコメントとして扱われる。

ブロックコメント

(* と *) で囲まれた部分がコメントとなる。

このブロックコメントはネストすることができるので、

1
2
3
4
5
6

(*
outer comment
(*
inner comment
*)
*)

は正しい。しかし、

1
2
3
4
5
6

(*
outer comment
(*
inner comment

*)

はコンパイルエラーとなる。

F# メモタプル

rei — Wed, 24 Feb 2010 21:39:25 +0000

タプルは複数の値を一つの組として扱う機能。
int と string のタプルの型は int * string と表される。
コンマで区切ることでタプルの作成や要素の取得ができる。

> let t = (1234, "1234");;

val t : int * string = (1234, "1234")

> let d, s = t;;

val s : string = "1234"
val d : int = 1234

タプルを関数の引数にするには以下のように括弧で括る必要がある。

> let sum (a, b, c) = a + b + c

let x = sum (12, 23, 34);;

val sum : int * int * int -> int
val x : int = 69

F# メモ unit

rei — Wed, 24 Feb 2010 12:26:33 +0000

unit は値を持たないことを表す型で、CやC#でいう void のようなもの。
() は unit である。

> let x = ();;

val x : unit = ()

ignore は非 unit な式を unit に変換する関数。
つまり値を使わないことを明示する関数。

> ignore(2*2);;
val it : unit = ()

や

> 2*2 |> ignore;;
val it : unit = ()

のように使用できる。

F# メモ関数

rei — Mon, 22 Feb 2010 04:28:47 +0000

定義

2つの int を引数に取り、その和を返す関数 add は以下のように表す。

> let add a b = a + b;;

val add : int -> int -> int

実行してみる。

> add 1 2;;
val it : int = 3

関数の型

float -> int は「float を引数に取り、int を返す関数」と読む。
上の add の場合 int -> int -> int が関数の型で、「intを引数に取り、「intを引数に取り、intを返す関数」を返す関数」と読む。

型推論

上の add 関数のように引数の型が複数考えられるとき、最初に使用されたときの引数を基に関数の型が決まる。(ただし、対話モードでは一旦 ;; で終了した時点で確定する)

> add 1.0 2.0;;

add 1.0 2.0;;
----^^^

stdin(3,5): error FS0001: This expression was expected to have type
int
but here has type
float

のように float を引数とすることはできない。
これは関数 add が int -> int -> int と推論されているため。
float のみを渡せるようにするには、以下のように明示的に型を指定する。

> let addf (a:float) b = a + b;;

val addf : float -> float -> float

> addf 1.0 2.0;;
val it : float = 3.0

ジェネリック関数

‘a のように ‘ を付けた型を指定すると、どんな型でも引数に取ることができる関数を作ることができる。
‘a でも ‘b でも ‘asdfghjk でもいいらしい。

> let str (x:'a) = x.ToString();;

val str : 'a -> string

> str(10);;
val it : string = "10"

スコープ

F#のスコープはインデントで表される。
全くインデントされていないスコープがモジュールスコープ。

> let Pow2 x =
let value = x * x
value;;

val Pow2 : int -> int

> Pow2 10;;
val it : int = 100

関数スコープの最後に評価された値がその関数の戻り値となる。

F# メモ基本演算子

rei — Sun, 21 Feb 2010 11:36:35 +0000

算術演算子

説明不要ですね。

演算子	意味
+	加算
-	減算
*	乗算
/	除算
**	冪算
%	剰余

数学関数

演算子ではありませんが、基本的なものなので。

関数	意味
abs	絶対値を求める
ceil	整数に丸める(大きい方に)
exp	eの引数乗を求める
floor	整数に丸める(小さい方に)
sign	符号を求める(-1, 0 or 1)
log	自然対数を求める
log10	常用対数を求める
sqrt	平方根を求める
cos	コサインを求める
sin	サインを求める
tan	タンジェントを求める
pown	整数の累乗を求める

型変換

型名がそのまま変換関数のように機能する。

> int64 1234.5678;;

val it : int64 = 1234L

ビット演算子

ちょっと特殊。

演算子	意味
&&&	AND
\|\|\|	OR
^^^	XOR
<<<	左シフト
>>>	右シフト

要素へのアクセス

配列や文字列の要素にアクセスする場合は .[] を使用する。
慣れていないうちは . を忘れやすい。

> let str = "abc";;

val str : string = "abc"

> str.[1];;
val it : char = 'b'

論理演算

演算子	意味	例
&&	AND	true && false = false
\|\|	OR	true \|\| false = true
not	NOT	not false = true

比較演算

値同士の比較を行い、bool 値を返す。

演算子	意味
<	より小さいか
<=	以下か
>	より大きいか
>=	以上か
=	同じか
<>	異なるか

compare (関数？) は第一引数の方が小さいときは -1、大きいときは 1、同じなら 0 を返す。