CS/JS – Mathクラスメソッドの実行速度

2016-07-30 / tau / コメントする

概要

2点間の距離を比較するときに、sqrtといった関数で距離を求める汎用メソッド／関数を使うのに対して、距離の2乗のままで比較して計算スピードを上げることが考えられる。

昔の大型計算機で大きな規模の方程式を解くときなどは、計算スピードを上げるために距離の2乗のままで比較をしていたりしたが、簡単なシミュレーションやアニメーションなどで、それがどれくらい効いてくるのかがよくわからなかった。

そこで、他の関数も含めて、Mathクラスのクラスメソッドとして定義されている浮動小数点系の関数群の実行時間を計ってみた。

結果概要

加減乗除算の間では実行時間にあまり差はなく、これらを1としたときの各関数の実行時間程度は以下のようになった。

+-*/	1
abs、sqrt、exp、log、random	1
sin、cos	2～3
tan、atan	4～5
atan2	5～6
asin、acos	6～7
pow(**)	7～8

一般的な方針

先の結果から、浮動小数点の計算を含むコードに関して、以下のようにまとめられる。

距離の計算などにsqrtを気軽に使ってもよい(足し算を一つ増やす程度)
exp、logも気軽に使ってよい
累乗計算はコストが高い
- 距離計算などで自乗項が出てくる場合、乗算に変更した方がよい
三角関数は、加減乗除の2～5倍のコスト
逆三角関数は、加減乗除の5～7倍のコスト

参考

実行環境1

mouse製ノートPC
Celeron-325U/1.70GHz
RAM 8GB
Windows 10 Home(64bit)

コンソールからテストコードを実行。

ここでa = 1.1、b = -2.2で、各関数の繰り返し回数は100万回。時間の単位はミリ秒。

a+b	17	17	17
a-b	26	26	28
a*b	20	18	20
a/b	16	17	18
a**b	156	157	157
abs(a)	29	27	30
abs(b)	30	29	30
sqrt(a)	29	30	31
sin(a)	71	71	71
cos(a)	59	61	61
tan(a)	83	84	84
asin(a)	125	128	128
acos(a)	124	127	125
atan(a)	85	84	87
atan2(a)	138	140	146
exp(a)	15	17	17
log(a)	15	17	18
random(a)	26	27	27

実行環境2

自作PC
Intel Core i5-4670/3.40GHz
RAM 4.00GB

a+b	9	10	9
a-b	12	11	12
a*b	7	9	7
a/b	7	7	7
a**b	72	71	72
abs(a)	11	12	17
abs(b)	12	17	12
sqrt(a)	13	13	13
sin(a)	27	25	23
cos(a)	24	25	25
tan(a)	43	43	42
asin(a)	53	53	54
acos(a)	53	50	51
atan(a)	41	41	41
atan2(a)	61	62	58
exp(a)	7	7	8
log(a)	6	7	7
random(a)	12	13	12

テストコード

a = 1.1
b = -2.2

sTime = new Date().valueOf()
for i in [1..1000000]
  x = a + b
eTime = new Date().valueOf()
console.log("+ #{eTime - sTime}ms")
sTime = eTime

for i in [1..1000000]
  x = a - b
eTime = new Date().valueOf()
console.log("- #{eTime - sTime}ms")
sTime = eTime

for i in [1..1000000]
  x = a * b
eTime = new Date().valueOf()
console.log("* #{eTime - sTime}ms")
sTime = eTime

for i in [1..1000000]
  x = a / b
eTime = new Date().valueOf()
console.log("/ #{eTime - sTime}ms")
sTime = eTime

for i in [1..1000000]
  x = a ** b
eTime = new Date().valueOf()
console.log("** #{eTime - sTime}ms")
sTime = eTime

for i in [1..1000000]
  x = Math.abs(a)
eTime = new Date().valueOf()
console.log("abs(+) #{eTime - sTime}ms")
sTime = eTime

for i in [1..1000000]
  x = Math.abs(b)
eTime = new Date().valueOf()
console.log("abs(-) #{eTime - sTime}ms")
sTime = eTime

for i in [1..1000000]
  x = Math.sqrt(a)
eTime = new Date().valueOf()
console.log("sqrt() #{eTime - sTime}ms")
sTime = eTime

for i in [1..1000000]
  x = Math.sin(a)
eTime = new Date().valueOf()
console.log("sin() #{eTime - sTime}ms")
sTime = eTime

for i in [1..1000000]
  x = Math.cos(a)
eTime = new Date().valueOf()
console.log("cos() #{eTime - sTime}ms")
sTime = eTime

for i in [1..1000000]
  x = Math.tan(a)
eTime = new Date().valueOf()
console.log("tan() #{eTime - sTime}ms")
sTime = eTime

for i in [1..1000000]
  x = Math.asin(a)
eTime = new Date().valueOf()
console.log("asin() #{eTime - sTime}ms")
sTime = eTime

for i in [1..1000000]
  x = Math.acos(a)
eTime = new Date().valueOf()
console.log("acos() #{eTime - sTime}ms")
sTime = eTime

for i in [1..1000000]
  x = Math.atan(a)
eTime = new Date().valueOf()
console.log("atan() #{eTime - sTime}ms")
sTime = eTime

for i in [1..1000000]
  x = Math.atan2(a)
eTime = new Date().valueOf()
console.log("atan2() #{eTime - sTime}ms")
sTime = eTime

for i in [1..1000000]
  x = Math.exp(a)
eTime = new Date().valueOf()
console.log("exp() #{eTime - sTime}ms")
sTime = eTime

for i in [1..1000000]
  x = Math.log(a)
eTime = new Date().valueOf()
console.log("log() #{eTime - sTime}ms")
sTime = eTime

for i in [1..1000000]
  x = Math.random()
eTime = new Date().valueOf()
console.log("random() #{eTime - sTime}ms")
sTime = eTime

100

101

102

103

104

105

106

107

108

109

110

111

a = 1.1

b = -2.2

sTime = new Date().valueOf()

for i in [1..1000000]

x = a + b

eTime = new Date().valueOf()

console.log("+ #{eTime - sTime}ms")

sTime = eTime

for i in [1..1000000]

x = a - b

eTime = new Date().valueOf()

console.log("- #{eTime - sTime}ms")

sTime = eTime

for i in [1..1000000]

x = a * b

eTime = new Date().valueOf()

console.log("* #{eTime - sTime}ms")

sTime = eTime

for i in [1..1000000]

x = a / b

eTime = new Date().valueOf()

console.log("/ #{eTime - sTime}ms")

sTime = eTime

for i in [1..1000000]

x = a ** b

eTime = new Date().valueOf()

console.log("** #{eTime - sTime}ms")

sTime = eTime

for i in [1..1000000]

x = Math.abs(a)

eTime = new Date().valueOf()

console.log("abs(+) #{eTime - sTime}ms")

sTime = eTime

for i in [1..1000000]

x = Math.abs(b)

eTime = new Date().valueOf()

console.log("abs(-) #{eTime - sTime}ms")

sTime = eTime

for i in [1..1000000]

x = Math.sqrt(a)

eTime = new Date().valueOf()

console.log("sqrt() #{eTime - sTime}ms")

sTime = eTime

for i in [1..1000000]

x = Math.sin(a)

eTime = new Date().valueOf()

console.log("sin() #{eTime - sTime}ms")

sTime = eTime

for i in [1..1000000]

x = Math.cos(a)

eTime = new Date().valueOf()

console.log("cos() #{eTime - sTime}ms")

sTime = eTime

for i in [1..1000000]

x = Math.tan(a)

eTime = new Date().valueOf()

console.log("tan() #{eTime - sTime}ms")

sTime = eTime

for i in [1..1000000]

x = Math.asin(a)

eTime = new Date().valueOf()

console.log("asin() #{eTime - sTime}ms")

sTime = eTime

for i in [1..1000000]

x = Math.acos(a)

eTime = new Date().valueOf()

console.log("acos() #{eTime - sTime}ms")

sTime = eTime

for i in [1..1000000]

x = Math.atan(a)

eTime = new Date().valueOf()

console.log("atan() #{eTime - sTime}ms")

sTime = eTime

for i in [1..1000000]

x = Math.atan2(a)

eTime = new Date().valueOf()

console.log("atan2() #{eTime - sTime}ms")

sTime = eTime

for i in [1..1000000]

x = Math.exp(a)

eTime = new Date().valueOf()

console.log("exp() #{eTime - sTime}ms")

sTime = eTime

for i in [1..1000000]

x = Math.log(a)

eTime = new Date().valueOf()

console.log("log() #{eTime - sTime}ms")

sTime = eTime

for i in [1..1000000]

x = Math.random()

eTime = new Date().valueOf()

console.log("random() #{eTime - sTime}ms")

sTime = eTime

CS/JS – Math.signが使えない話

2016-07-29 / tau / コメントする

CoffeeScriptで書いたコードが、ローカルでもネット上のWordPressでも動くことを確認したが、Android端末で動かないという事象が発生した。

sgn = Math.sign(val) # Javascript実行時にエラー

1	sgn = Math.sign(val) # Javascript実行時にエラー

同じ症状がWindowsマシンのExplorerでも起こったので、開発ツールで確認したところ、”Math.signはサポートされていない”とのこと。

調べてみると、JavaScript | MDN(Mozilla Developer Network)のMath.sign()のところでブラウザ実装状況を見ると、

デスクトップでは、Chrome38、FireFox(Gecko)25、Opera25はサポート、IEとSafariは未サポート
モバイルでは、Firefox Mobile(Gecko)25のみサポートで、あとは全滅

当分、この関数は利用できそうにないので、以下のように値を絶対値で割って取り出すのが手っ取り早い(可読性は悪くなるが)。

sgn = val / Math.abs(val)

1	sgn = val / Math.abs(val)

スクリプトへの引数渡し

2016-07-26 / tau / コメントする

たとえば以下のような場合。

CoffeeScript、Javascriptの外部スクリプトに引数を渡したい
外部スクリプトの定数定義を柔軟に変更可能なようにしたい

定数となる変数定義をスクリプト内に書くと、定数の値を変更したいときに再コンパイルやアップロードなどが必要になって煩雑。

以下の方法が考えられる。

HTMLの外部スクリプト呼び出しより前に、変数定義のscript要素を書く(変数のスコープはグローバルになる)
- その際、行の末尾にセミコロン(;)をつけること
外部スクリプト内で上で定義した変数を利用する

HTML

<script>
PARAM = 1;
CONST_PARAM = 10;
</script>

PARAM = 1;

CONST_PARAM = 10;

</script>

外部スクリプト

p = PARAMETER
c = CONST_PARAMETER

console.log(p) # 1
console.log(c) # 10

p = PARAMETER

c = CONST_PARAMETER

console.log(p) # 1

console.log(c) # 10

CoffeeScriptも実行時にはJSにコンパイルしたものを読み込むので、変数定義もJavascriptの文法で末尾にセミコロン(;)をつけなければならない。

上の例では、定数を意識して変数名を大文字のスネークケースとしたが、通常の変数名でも実行に問題はない。

CoffeeScript – geom2dパッケージ

2016-07-24 / tau / コメントする

パッケージ名

taustation_geom2d

クラス

taustation_geom2d.Vector: 2次元ベクトルを保持し、各種演算を行うメソッドを提供する。
taustation_geom2d.MovingAgent: 位置と速度を保持し、互いの位置関係を判定するメソッドを提供する。

コードの骨組み

# 2次元の幾何図形等のパッケージ
# ver1.0
# 20160724
# ver1.1
# 20160729
# Vector.distance()を追加
exports = this
exports.taustation_geom2d = {}

do ->
  # 2次元ベクトルのクラス
  class Vector

  # 位置と速度を保持するクラス
  class MovingAgent

  taustation_geom2d.Vector = Vector
  taustation_geom2d.MovingAgent = MovingAgent

# 2次元の幾何図形等のパッケージ

# ver1.0

# 20160724

# ver1.1

# 20160729

# Vector.distance()を追加

exports = this

exports.taustation_geom2d = {}

do ->

# 2次元ベクトルのクラス

class Vector

# 位置と速度を保持するクラス

class MovingAgent

taustation_geom2d.Vector = Vector

taustation_geom2d.MovingAgent = MovingAgent

CoffeeScript – geom2d.Vectorクラス

2016-07-24 / tau / コメントする

パッケージ

taustation_geom2d

クラス名

taustation_geom2d.Vector

クラス仕様

概要

x、y二つの成分を持ち、絶対値の計算や加減乗算など2次元ベクトルの代数演算を行うメソッドを提供する。

クラス変数

なし

クラス・メソッド

distance(pos1, pos2): 2つのVectorオブジェクトpos1、pos2を点を表す位置ベクトルとして、2点間の距離を返す。

インスタンス・プロパティ

x: ベクトルのx成分
y: ベクトルのy成分

コンストラクタ

constructor(x, y): x成分とY成分を指定してVectorのインスタンスを生成する。

インスタンス・メソッド

基本メソッド

set(x, y): Vectorのx成分とy成分をセットする。
toString(): Vectorの文字列形式の表現を返す。
getClone(): 元のVectorオブジェクトと同じ内容のクローンを生成して返す。

演算

abs: Vectorの絶対値(長さ)を返す。
times(coeff): Vectorに定数coeffを乗じたベクトルを新たに生成して返す。
timesEq(coeff): Vectorに定数coeffを乗じて変更する。新しいオブジェクトは生成しない。
div(coeff): Vectorを定数coeffで除したベクトルを新たに生成して返す。
divEq(coeff): Vectorを定数coeffで除して変更する。新しいオブジェクトは生成しない。
plus(other): Vectorにotherベクトルを加えたベクトルを新たに生成して返す。
plusEq(other): Vectorにotherベクトルを加えて変更する。新しいオブジェクトは生成しない。
minus(other): Vectorからotherベクトルを減じたベクトルを新たに生成して返す。
minusEq(other): Vectorからotherベクトルを減じて変更する。新しいオブジェクトは生成しない。
inprod(other): Vectorとotherベクトルの内積値を返す。
ang(other): Vectorとotherのなす角を計算する(0～π)。

新たなVectorの生成

getUnit(): Vectorと同じ向きの単位ベクトル(長さが1)を新たに生成して返す。
getInverse(): Vectorと逆向きのベクトルを新たに生成して返す。
getOrthogonalR(): Vectorから右に90度回転したベクトルを新たに生成して返す。
getOrthogonalL(): Vectorから左に90度回転したベクトルを新たに生成して返す。
getUnitOrthogonalR(): Vectorから右に90度回転した単位ベクトルを新たに生成して返す。
getUnitOrthogonalL(): Vectorから左に90度回転した単位ベクトルを新たに生成して返す。

判定

isHeadingToRightOf(other): このVectorオブジェクトの進行方向が、引数のVectorオブジェクトotherの進行方向より右方を指しているときtrue、左方を指しているときfalseを返す。
isHeadingToLeftOf(other): isHeadingToRightOf()と左右逆の判定結果を返す
isInFrontOf(movingAgent): このVectorオブジェクトが位置ベクトルとして、その点が引数のMovingAgentオブジェクトの前方(左右180度より進行方向の側)にあるときtrue、後方にあるときfalseを返す。真横の時は前方と判定される。
isIntheRearOf(movingAgent): isInFrontOf()と前後逆の判定結果を返す。
isOnTheRightOf(movingAgent): このVectorオブジェクトが位置ベクトルとして、その点が引数のMovingAgentオブジェクトの右方にあるときtrue、左方にあるときfalseを返す。進行方向の延長線上にあるときは右方と判定される。
isOnTheLeftOf(movingAgent): isOnTheRightOf()と左右逆の判定結果を返す。

コード

  class Vector
    # 2つの位置ベクトルで表される点の間の距離を返す
    @distance: (pos1, pos2) ->
      Math.sqrt((pos1.x - pos2.x) * (pos1.x - pos2.x) +
                (pos1.y - pos2.y) * (pos1.y - pos2.y))

    constructor: (@x, @y) ->

    set: (x, y) -> @x = x; @y = y; return
    toString: -> "(#{@x}, #{@y})"

    # 自身と同じ内容のVectorオブジェクトを生成して返す
    getClone: -> new Vector(@x, @y)

    # ベクトルの絶対値(長さ)
    abs: -> Math.sqrt(@x * @x + @y * @y)

    # ベクトルとスカラーの乗除算
    # 以降のメソッド群でも、Eqがついていれば元のオブジェクトを変更し、
    # Eqがついていなければ新しいベクトルを生成して返す
    times: (a) -> new Vector(@x * a, @y * a)
    timesEq: (a) -> @x *= a; @y *= a; return
    div: (a) -> new Vector(@x / a, @y / a)
    divEq: (a) -> @x /= a; @y /= a; return

    # ベクトル同士の加減算
    plus: (other) -> new Vector(@x + other.x, @y + other.y)
    plusEq: (other) -> @x += other.x; @y += other.y; return
    minus: (other) -> new Vector(@x - other.x, @y - other.y)
    minusEq: (other) -> @x -= other.x; @y -= other.y; return

    # 2つのベクトルの内席となす角
    inprod: (other) -> @x * other.x + @y * other.y
    ang: (other) -> Math.acos(@inprod(other) / @.abs() / other.abs())

    # 単位ベクトル、逆ベクトル、直交ベクトルを返す
    getUnit: -> a = @abs(); new Vector(@x / a, @y / a)
    getInverse: -> new Vector(-@x, -@y)
    getOrthogonalR: -> new Vector(@y, -@x)
    getOrthogonalL: -> new Vector(-@y, @x)
    getUnitOrthogonalR: -> a = @abs(); new Vector(@y / a, -@x / a)
    getUnitOrthogonalL: -> a = @abs(); new Vector(-@y / a, @x / a)

    # このVectorが引数のVectorの向きに対してどちらに向いているか
    isHeadingToRightOf: (other) ->
      if @x * other.y - @y * other.x >=0 then true else false

    isHeadingToLeftOf: (other) -> return not @isHeadingToRightOf(other)

    # 以下、Vectorを位置ベクトルと考えたときのMovingAgentとの位置関係
    #
    # Vectorの位置がMovingAgentの前方か
    isInFrontOf: (movingAgent) ->
      inprod = movingAgent.v.x * (@x - movingAgent.pos.x) +
               movingAgent.v.y * (@y - movingAgent.pos.y)
      if inprod >= 0 then true else false

    # Vectorの位置がMovingAgentの後方か
    isInTheRearOf: (movingAgent) -> not @isInFrontOf(movingAgent)

    # Vectorの位置がMovingAgentの右方か
    isOnTheRightOf: (movingAgent) ->
      inprod = (@x - movingAgent.pos.x) * movingAgent.v.y -
               (@y - movingAgent.pos.y) * movingAgent.v.x
      if inprod >= 0 then true else false

    # Vectorの位置がMovingAgentの左方か
    isOnTheLeftOf: (movingAgent) -> not @isOnTheRightOf(movingAgent)

class Vector

# 2つの位置ベクトルで表される点の間の距離を返す

@distance: (pos1, pos2) ->

Math.sqrt((pos1.x - pos2.x) * (pos1.x - pos2.x) +

(pos1.y - pos2.y) * (pos1.y - pos2.y))

constructor: (@x, @y) ->

set: (x, y) -> @x = x; @y = y; return

toString: -> "(#{@x}, #{@y})"

# 自身と同じ内容のVectorオブジェクトを生成して返す

getClone: -> new Vector(@x, @y)

# ベクトルの絶対値(長さ)

abs: -> Math.sqrt(@x * @x + @y * @y)

# ベクトルとスカラーの乗除算

# 以降のメソッド群でも、Eqがついていれば元のオブジェクトを変更し、

# Eqがついていなければ新しいベクトルを生成して返す

times: (a) -> new Vector(@x * a, @y * a)

timesEq: (a) -> @x *= a; @y *= a; return

div: (a) -> new Vector(@x / a, @y / a)

divEq: (a) -> @x /= a; @y /= a; return

# ベクトル同士の加減算

plus: (other) -> new Vector(@x + other.x, @y + other.y)

plusEq: (other) -> @x += other.x; @y += other.y; return

minus: (other) -> new Vector(@x - other.x, @y - other.y)

minusEq: (other) -> @x -= other.x; @y -= other.y; return

# 2つのベクトルの内席となす角

inprod: (other) -> @x * other.x + @y * other.y

ang: (other) -> Math.acos(@inprod(other) / @.abs() / other.abs())

# 単位ベクトル、逆ベクトル、直交ベクトルを返す

getUnit: -> a = @abs(); new Vector(@x / a, @y / a)

getInverse: -> new Vector(-@x, -@y)

getOrthogonalR: -> new Vector(@y, -@x)

getOrthogonalL: -> new Vector(-@y, @x)

getUnitOrthogonalR: -> a = @abs(); new Vector(@y / a, -@x / a)

getUnitOrthogonalL: -> a = @abs(); new Vector(-@y / a, @x / a)

# このVectorが引数のVectorの向きに対してどちらに向いているか

isHeadingToRightOf: (other) ->

if @x * other.y - @y * other.x >=0 then true else false

isHeadingToLeftOf: (other) -> return not @isHeadingToRightOf(other)

# 以下、Vectorを位置ベクトルと考えたときのMovingAgentとの位置関係

# Vectorの位置がMovingAgentの前方か

isInFrontOf: (movingAgent) ->

inprod = movingAgent.v.x * (@x - movingAgent.pos.x) +

movingAgent.v.y * (@y - movingAgent.pos.y)

if inprod >= 0 then true else false

# Vectorの位置がMovingAgentの後方か

isInTheRearOf: (movingAgent) -> not @isInFrontOf(movingAgent)

# Vectorの位置がMovingAgentの右方か

isOnTheRightOf: (movingAgent) ->

inprod = (@x - movingAgent.pos.x) * movingAgent.v.y -

(@y - movingAgent.pos.y) * movingAgent.v.x

if inprod >= 0 then true else false

# Vectorの位置がMovingAgentの左方か

isOnTheLeftOf: (movingAgent) -> not @isOnTheRightOf(movingAgent)

CoffeeScript – グローバル変数

2016-07-24 / tau / コメントする

グローバルにならない

CoffeeScriptでグローバル変数を期待して以下のように書いたとする。

globalVar = 1 # グローバル変数のつもり

console.log(globalVar)

globalVar = 1 # グローバル変数のつもり

console.log(globalVar)

一見すると問題なく動いているように見えるが、これを別ファイルのパッケージにして動かそうとすると問題が顕在化する。以下のように”globalVarが存在しないよ”というエラーが出るのである。

>>> package1.coffeeファイル
globalVar = 1

>>> main.coffeeファイル
console.log(globalVar) # globalVar is not defined

>>> package1.coffeeファイル

globalVar = 1

>>> main.coffeeファイル

console.log(globalVar) # globalVar is not defined

これら2つのファイルをjsにコンパイルしてブラウザのscript要素で読み込んだ場合、そのイメージは以下のようになる。

(function() {
  globalVar a;
  globalVar = 1;
}).call(this);

(function() {
  console.log(globalVar);
}).call(this);

(function() {

globalVar a;

globalVar = 1;

}).call(this);

(function() {

console.log(globalVar);

}).call(this);

パッケージでグローバル定義したつもりだが、コンパイル時に無名関数でクロージングされるため、グローバルにならず、他のファイルから読み込むことができない。

解決策1

グローバル変数をwindowオブジェクトの要素にしてしまう。

>>> package1.coffeeファイル
window.globalVar = 1

>>> main.coffeeファイル
console.log(window.globalVar)

>>> package1.coffeeファイル

window.globalVar = 1

>>> main.coffeeファイル

console.log(window.globalVar)

解決策2

rootコンテキストで、以下のパターンを使う。

>>> package1.coffeeファイル
exports = this
exports.globalVar = 1

>>> main.coffeeファイル
console.log(globalVar)

>>> package1.coffeeファイル

exports = this

exports.globalVar = 1

>>> main.coffeeファイル

console.log(globalVar)

CoffeeScript – パッケージ管理

2016-07-11 / tau / コメントする

パッケージ化の方法について

簡単な方法～齟齬あり

クラス／オブジェクトのプロパティにする

クラスやオブジェクトをパッケージの名前とし、パッケージ内のクラスなどはそのプロパティとして定義する。

ただしこの方法は、最適とは言えない。

# Package 1
class Pack1

class MyClass
  constructor: -> @name = "P1-MyClass"

Pack1.MyClass = MyClass

#Package 2
Pack2 = {}

# not in package
class MyClass
  constructor: -> @name = "P2-MyClass"

Pack2.MyClass = MyClass

ins1 = new Pack1.MyClass()
ins2 = new Pack2.MyClass()
ins3 = new MyClass()

console.log(ins1.name) # P1-MyClass
console.log(ins2.name) # P2-MyClass
console.log(ins3.name) # P2-MyClass

# Package 1

class Pack1

class MyClass

constructor: -> @name = "P1-MyClass"

Pack1.MyClass = MyClass

#Package 2

Pack2 = {}

# not in package

class MyClass

constructor: -> @name = "P2-MyClass"

Pack2.MyClass = MyClass

ins1 = new Pack1.MyClass()

ins2 = new Pack2.MyClass()

ins3 = new MyClass()

console.log(ins1.name) # P1-MyClass

console.log(ins2.name) # P2-MyClass

console.log(ins3.name) # P2-MyClass

1行目で名前空間に用いるクラスを定義し、7行目でMyClassをPack1のプロパティとしている。

10行目で名前空間に用いるオブジェクトを定義し、16行目でMyClassPack2のプロパティとしている。

20行目でMyClass単独を用いた場合、直前に13行で定義されたMyClassが参照される。

パッケージ内での名前参照の祖語

パッケージ間で名前が重複する場合、下手をすると想定外のオブジェクトが使われてしまう。

次の例は、Pack1とPack2の2つのパッケージで同じクラス名を使い、各パッケージの中ではパッケージ名なしで使おうとしたもの。

class Pack1

class InnerClass
  constructor: -> @name = "P1-Inner"

class MyClass
  constructor: ->
    @name = "P1-MyClass"
    @inner = new InnerClass()

Pack1.MyClass = MyClass

Pack2 = {}

class InnerClass
  constructor: -> @name = "P2-Inner"

class MyClass
  constructor: ->
    @name = "P2-MyClass"
    @inner = new InnerClass()

Pack2.MyClass = MyClass

ins1 = new Pack1.MyClass()
ins2 = new Pack2.MyClass()

console.log(ins1.name)       # P1-MyClass
console.log(ins1.inner.name) # P2-Inner!!
console.log(ins2.name)       # P2-MyClass
console.log(ins2.inner.name) # P2-Inner

class Pack1

class InnerClass

constructor: -> @name = "P1-Inner"

class MyClass

constructor: ->

@name = "P1-MyClass"

@inner = new InnerClass()

Pack1.MyClass = MyClass

Pack2 = {}

class InnerClass

constructor: -> @name = "P2-Inner"

class MyClass

constructor: ->

@name = "P2-MyClass"

@inner = new InnerClass()

Pack2.MyClass = MyClass

ins1 = new Pack1.MyClass()

ins2 = new Pack2.MyClass()

console.log(ins1.name) # P1-MyClass

console.log(ins1.inner.name) # P2-Inner!!

console.log(ins2.name) # P2-MyClass

console.log(ins2.inner.name) # P2-Inner

ところが29行目で、Pack1のクラスのはずのところがInnerClassにはPack2のものが使われてしまっている。

これは、25行目以降の実行文の前にグローバル変数InnerClassの内容がPack1のものからPack2のものへと上書き定義されたため。

結局この方法だと、各パッケージの中でもクラス名の前にパッケージ名をつけないといけないようで、コーディング上は元のクラス名に識別子を組み込むのとあまり変わらない。

有効な方法～即時実行関数

先の方法は、すべてグローバル領域で行われていたため、パッケージ内でのみ参照するクラスも上書きされてしまった。

そこで、パッケージごとに即時実行される無名関数で括ってみる。

Package1 = {}

do ->
  class InnerClass
    constructor: -> @name = "P1-Inner"

  class MyClass
    constructor: ->
      @name = "P1-Class"
      @inner = new InnerClass()

  Package1.MyClass = MyClass

Package2 = {}

do ->
  class InnerClass
    constructor: -> @name = "P2-Inner"

  class MyClass
    constructor: ->
      @name = "P2-Class"
      @inner = new InnerClass()

  Package2.MyClass = MyClass

ins1 = new Package1.MyClass()
ins2 = new Package2.MyClass()

console.log(ins1.name)       # P1-Class
console.log(ins1.inner.name) # P1-Inner
console.log(ins2.name)       # P2-Class
console.log(ins2.inner.name) # P2-Inner

Package1 = {}

do ->

class InnerClass

constructor: -> @name = "P1-Inner"

class MyClass

constructor: ->

@name = "P1-Class"

@inner = new InnerClass()

Package1.MyClass = MyClass

Package2 = {}

do ->

class InnerClass

constructor: -> @name = "P2-Inner"

class MyClass

constructor: ->

@name = "P2-Class"

@inner = new InnerClass()

Package2.MyClass = MyClass

ins1 = new Package1.MyClass()

ins2 = new Package2.MyClass()

console.log(ins1.name) # P1-Class

console.log(ins1.inner.name) # P1-Inner

console.log(ins2.name) # P2-Class

console.log(ins2.inner.name) # P2-Inner

1行目のようにグローバル領域でパッケージ名に使うオブジェクト／クラスを定義し、パッケージごとに即時無名関数で括る。

パッケージ内ではパッケージなしでアクセスし、外からアクセスするときはパッケージ名を付してアクセス。

これで一応、パッケージ化とコーディングの簡易化を両立させることができる。

パッケージ名について

パッケージ名は、「世界規模での名前衝突を避ける」ように潔癖を極めるなら、Javaで行われているようなドメイン名管理が答となる。

com.taustation.game.MyClass

do ->
  class MyClass
    ...

com.taustation.game.MyClass

do ->

class MyClass

...

なお、Javaの場合はimport文で指定したパッケージはクラス名のみで使えるが、Javascriptではエイリアスを明示的に指定しなければならないらしい。

JavaScriptスタイルガイドでは、「長い型名をエイリアスし可読性を向上させる」ために以下のように示唆されている。

“ローカルのエイリアスを使うことで長い型名の可読性を向上できる場合はそうしてください. エイリアスの名前は型名の最後の部分にしてください.”

/**
 * @constructor
 */
some.long.namespace.MyClass = function() {
};

/**
 * @param {some.long.namespace.MyClass} a
 */
some.long.namespace.MyClass.staticHelper = function(a) {
  ...
};

myapp.main = function() {
  var MyClass = some.long.namespace.MyClass;
  var staticHelper = some.long.namespace.MyClass.staticHelper;
  staticHelper(new MyClass());
};

/**

* @constructor

some.long.namespace.MyClass = function() {

};

/**

* @param {some.long.namespace.MyClass} a

some.long.namespace.MyClass.staticHelper = function(a) {

...

};

myapp.main = function() {

var MyClass = some.long.namespace.MyClass;

var staticHelper = some.long.namespace.MyClass.staticHelper;

staticHelper(new MyClass());

};

なお、npmのサイトでいろいろなパッケージを見てみると、区切りにはアンダースコア(_)ではなくマイナス(-)を使っている。

CoffeeScript – タイマ

2016-07-10 / tau / コメントする

setInterval

setInterval()関数の引数に、アニメーションフレームを描画する関数と時間間隔を指定する。時間間隔はミリ秒単位。

描画の開始／停止をコントロールするには、setInterval()関数の戻り値を変数に保存しておき、停止するときにclearInterval()関数の引数でその変数を指定する。

timer = setInterval(drawFunction(), intervalInMilliSeconds)

clearInterval(timer)

timer = setInterval(drawFunction(), intervalInMilliSeconds)

clearInterval(timer)

一時停止／再開の機能は特に実装されていないが、描画関数を工夫することで可能。

描画関数を、以下のように無名関数で書くこともできる。

timer = setInterval ->
  複数行の処理
  return
, interval

timer = setInterval ->

複数行の処理

return

, interval

この処理を他のオブジェクトのメソッドの中に書いて、オブジェクトのプロパティを利用する場合は、1行目のアローをファットアロー(=>)にする。

CoffeeScript – クラスのメソッド

2016-07-03 / tau / コメントする

アクセス可能性

以下のコードで、クラスの関数へのアクセス可能性を確認する。

class Person
  method1: -> console.log("method1")
  @method2: -> console.log("method2")
  method3 = -> console.log("method3")
  @method4 = -> console.log("method4")

  method: ->
    # method1() # Error, is not defined
    # method2() # Error, is not defined
    method3()   # method3
    # method4() # Error, is not defined

  method_a: ->
    @method1()   # method1
    # @method2() # Error, is not a function
    # @method3() # Error, is not a function
    # @method4() # Error, is not a function

# Person.method1() # Error, is not a function
Person.method2()   # method2
# Person.method3() # Error, is not a function
Person.method4()   # method4

console.log()
john = new Person()
john.method1()   # method1
# john.method2() # Error, is not a function
# john.method3() # Error, is not a function
# john.method4() # Error, is not a function

console.log()
john.method()

console.log()
john.method_a()

class Person

method1: -> console.log("method1")

@method2: -> console.log("method2")

method3 = -> console.log("method3")

@method4 = -> console.log("method4")

method: ->

# method1() # Error, is not defined

# method2() # Error, is not defined

method3() # method3

# method4() # Error, is not defined

method_a: ->

@method1() # method1

# @method2() # Error, is not a function

# @method3() # Error, is not a function

# @method4() # Error, is not a function

# Person.method1() # Error, is not a function

Person.method2() # method2

# Person.method3() # Error, is not a function

Person.method4() # method4

console.log()

john = new Person()

john.method1() # method1

# john.method2() # Error, is not a function

# john.method3() # Error, is not a function

# john.method4() # Error, is not a function

console.log()

john.method()

console.log()

john.method_a()

各関数へのアクセス可能性は以下の通り。

定義＼引用	クラス	インスタンス	メソッド内 (@なし)	メソッド内 (@つき)
`fnc: ->`	TypeError	○	ReffError	○
`@fnc: ->`	○	TypeError	ReffError	TypeError
`fnc = ->`	TypeError	TypeError	○	TypeError
`@fnc = ->`	○	TypeError	ReffError	TypeError

なお、上記コードの定義部分のJavaScriptコンパイル結果は以下の通り。

(function() {
  var Person, john;

  Person = (function() {
    var method3;

    function Person() {}

    Person.prototype.method1 = function() {
      return console.log("method1");
    };

    Person.method2 = function() {
      return console.log("method2");
    };

    method3 = function() {
      return console.log("method3");
    };

    Person.method4 = function() {
      return console.log("method4");
    };

(function() {

var Person, john;

Person = (function() {

var method3;

function Person() {}

Person.prototype.method1 = function() {

return console.log("method1");

};

Person.method2 = function() {

return console.log("method2");

};

method3 = function() {

return console.log("method3");

};

Person.method4 = function() {

return console.log("method4");

};

クラス・メソッド

クラス内で@つきでメソッドを定義すると、クラスメソッドになる。

class MyClass
  @method1: -> console.log("method1")
  @method2 = -> console.log("method2")

class MyClass

@method1: -> console.log("method1")

@method2 = -> console.log("method2")

上記のいずれもJavaScriptへのコンパイル結果は同じになる。

  Person = (function() {

    function Person() {}

    Person.method1 = function() {
      return console.log("method1");
    };

    Person.method2 = function() {
      return console.log("method2");
    };

Person = (function() {

function Person() {}

Person.method1 = function() {

return console.log("method1");

};

Person.method2 = function() {

return console.log("method2");

};

クラスメソッドは、クラス内で呼び出すときでもクラス名をつける。

class MyClass
  @classMethod: -> console.log("Public Static")
  instanceMethod: ->
    console.log("Instance Method calling...")
    MyClass.classMethod()

MyClass.classMethod()
myObj = new MyClass()
myObj.instanceMethod()

# 実行結果
# Public Static
# Instance Method calling...
# Public Static

class MyClass

@classMethod: -> console.log("Public Static")

instanceMethod: ->

console.log("Instance Method calling...")

MyClass.classMethod()

myObj = new MyClass()

myObj.instanceMethod()

# 実行結果

# Public Static

# Instance Method calling...

# Public Static

publicなインスタンス・メソッド

最も多く用いる形で、クラス内でコロン(:)によって関数を定義すると、インスタンス・メソッドになる。

class MyClass
  method: -> console.log("method")

1 2	class MyClass method: -> console.log("method")

JavaScriptへのコンパイル結果では、prototype宣言されている。

(function() {
  var MyClass;

  MyClass = (function() {

    function MyClass() {}

    MyClass.prototype.method = function() {
      return console.log("method");
    };

(function() {

var MyClass;

MyClass = (function() {

function MyClass() {}

MyClass.prototype.method = function() {

return console.log("method");

};

同じクラスのメソッド内で呼び出すときは、@つきで。

class MyClass
  method1: -> console.log("metod1")
  method2: ->
    console.log("method2 calling...")
    @method1()

myObj = new MyClass()
myObj.method2()

# 実行結果
# method2 calling...
# metod1

class MyClass

method1: -> console.log("metod1")

method2: ->

console.log("method2 calling...")

@method1()

myObj = new MyClass()

myObj.method2()

# 実行結果

# method2 calling...

# metod1

privateなクラス・メソッド

クラス内でfnc = ->のように定義すると、クラスの外からは見えないprivateなメソッドになる。

class MyClass
  publicMethod: ->
    console.log("Public Method calling...")
    privateMethod()

  privateMethod = ->
    console.log("Private Method")

myObj = new MyClass()
myObj.publicMethod()
# myObj.privateMethod() # Type Error: is not a function

# 実行結果
# Public Method calling...
# Private Method

class MyClass

publicMethod: ->

console.log("Public Method calling...")

privateMethod()

privateMethod = ->

console.log("Private Method")

myObj = new MyClass()

myObj.publicMethod()

# myObj.privateMethod() # Type Error: is not a function

# 実行結果

# Public Method calling...

# Private Method

JavaScriptコードでは、クラス内のスコープで宣言されており、外からは見えない。

  MyClass = (function() {
    var privateMethod;

    function MyClass() {}

    MyClass.prototype.publicMethod = function() {
      console.log("Public Method calling...");
      return privateMethod();
    };

    privateMethod = function() {
      return console.log("Private Method");
    };

    return MyClass;

  })();

MyClass = (function() {

var privateMethod;

function MyClass() {}

MyClass.prototype.publicMethod = function() {

console.log("Public Method calling...");

return privateMethod();

};

privateMethod = function() {

return console.log("Private Method");

};

return MyClass;

})();

CoffeeScript – クラスのプロパティ

2016-07-03 / tau / コメントする

アクセス可能性

以下のコードで、クラスに関する変数へのアクセス可能性を確認する。

class Person
  member1 = 1
  @meber2 = 2
  member3: 3
  @member4: 4

  constructor: ->
    member5 = 5
    @member6 = 6

  dispMember1: ->
    console.log(member1) # 1
    # console.log(member2) # Error, not defined
    # console.log(member3) # Error, not defined
    # console.log(member4) # Error, not defined
    # console.log(member5) # Error, not defined
    # console.log(member6) # Error, not defined
    console.log("-----")

  dispMember2: ->
    console.log(@member1) # undefined
    console.log(@member2) # undefined
    console.log(@member3) # 3
    console.log(@member4) # undefined
    console.log(@member5) # undefined
    console.log(@member6) # 6
    console.log("-----")

john = new Person()

console.log(Person.member1) # undefined
console.log(Person.member2) # undefined
console.log(Person.member3) # undefined
console.log(Person.member4) # 4
console.log(Person.member5) # undefined
console.log(Person.member6) # undefined
console.log("-----")

console.log(john.member1) # undefined
console.log(john.member2) # undefined
console.log(john.member3) # 3
console.log(john.member4) # undefined
console.log(john.member5) # undefined
console.log(john.member6) # 6
console.log("-----")

john.dispMember1()

john.dispMember2()

class Person

member1 = 1

@meber2 = 2

member3: 3

@member4: 4

constructor: ->

member5 = 5

@member6 = 6

dispMember1: ->

console.log(member1) # 1

# console.log(member2) # Error, not defined

# console.log(member3) # Error, not defined

# console.log(member4) # Error, not defined

# console.log(member5) # Error, not defined

# console.log(member6) # Error, not defined

console.log("-----")

dispMember2: ->

console.log(@member1) # undefined

console.log(@member2) # undefined

console.log(@member3) # 3

console.log(@member4) # undefined

console.log(@member5) # undefined

console.log(@member6) # 6

console.log("-----")

john = new Person()

console.log(Person.member1) # undefined

console.log(Person.member2) # undefined

console.log(Person.member3) # undefined

console.log(Person.member4) # 4

console.log(Person.member5) # undefined

console.log(Person.member6) # undefined

console.log("-----")

console.log(john.member1) # undefined

console.log(john.member2) # undefined

console.log(john.member3) # 3

console.log(john.member4) # undefined

console.log(john.member5) # undefined

console.log(john.member6) # 6

console.log("-----")

john.dispMember1()

john.dispMember2()

各変数へのアクセス可能性は以下の通り。

定義＼引用		クラス	インスタンス	メソッド内 (@なし)	メソッド内 (@つき)
クラス直下	`v=val`	undef	undef	○	undef
	`@v=val`	undef	undef	RefError	undef
	`v:val`	undef	○	RefError	○
	`@v:val`	○	undef	RefError	undef
コンストラクタ	`v=val`	undef	undef	RefError	undef
コンストラクタ	`@v=val`	undef	○	RefError	○

この表から、以下のように整理できる。特にpublicなインスタンス・プロパティとstaticなクラス・プロパティを使っていくことになる。

クラス直下で`@v:val`定義	staticなクラス・プロパティ
クラス直下で`v:val`	publicなインスタンス・プロパティ
コンストラクタで`@v=val`	publicなインスタンス・プロパティ
クラス直下で`v=va`l	privateなクラス・プロパティ

なお、定義部分のJavaScriptへのコンパイル結果は以下の通り。

// Generated by CoffeeScript 1.10.0
(function() {
  var Person;

  Person = (function() {
    var member1;

    member1 = 1;

    Person.meber2 = 2;

    Person.prototype.member3 = 3;

    Person.member4 = 4;

    function Person() {
      var member5;
      member5 = 5;
      this.member6 = 6;
    }

    return Person;

  })();

}).call(this);

// Generated by CoffeeScript 1.10.0

(function() {

var Person;

Person = (function() {

var member1;

member1 = 1;

Person.meber2 = 2;

Person.prototype.member3 = 3;

Person.member4 = 4;

function Person() {

var member5;

member5 = 5;

this.member6 = 6;

}

return Person;

})();

}).call(this);

クラス・プロパティ

クラス直下で@v:valでプロパティを定義する場合、プロパティはクラスに一つの共有のものとして扱われる。コンパイルされたJavaScriptコードでは正に”[クラス名].[プロパティ名]“となっている

インスタンスの中から参照する場合も、[クラス名].[プロパティ名]で参照する。

class Person
  @member: 1

  dispMember: ->
    console.log(Person.member)

john = new Person()

console.log(Person.member) # 1
john.dispMember()          # 1
Person.member++
console.log(Person.member) # 2
john.dispMember()          # 2

class Person

@member: 1

dispMember: ->

console.log(Person.member)

john = new Person()

console.log(Person.member) # 1

john.dispMember() # 1

Person.member++

console.log(Person.member) # 2

john.dispMember() # 2

publicなインスタンス・プロパティ

クラス直下でv:valと定義した場合とコンストラクタで@v=valと定義した場合は、いずれもインスタンス・プロパティとして扱われる。

class Person
  member1: 1

  constructor: ->
    @member2 = 2

  dispMember: ->
    console.log(@member1)
    console.log(@member2)

john = new Person()
luice = new Person()

console.log("--John--")
console.log(john.member1) # 1
console.log(john.member2) # 2
console.log("--Luice--")
console.log(john.member1) # 1
console.log(john.member2) # 2

john.member1 *= 10
john.member2 *= 10

console.log("--John--")
john.dispMember()
# 10
# 20
console.log("--Luice--")
luice.dispMember()
# 1
# 2

class Person

member1: 1

constructor: ->

@member2 = 2

dispMember: ->

console.log(@member1)

console.log(@member2)

john = new Person()

luice = new Person()

console.log("--John--")

console.log(john.member1) # 1

console.log(john.member2) # 2

console.log("--Luice--")

console.log(john.member1) # 1

console.log(john.member2) # 2

john.member1 *= 10

john.member2 *= 10

console.log("--John--")

john.dispMember()

# 10

# 20

console.log("--Luice--")

luice.dispMember()

# 1

# 2

挙動としては同じなのでどちらでもよさそうだが、インスタンス・プロパティとしてはコンストラクタで定義する形式の方がよいと考えた。

以下のように、それぞれの定義方法でJavaScriptのコードが異なるが、メソッドのようにクラス内で共通化したい場合はprototypeがよいが、そもそもインスタンスごとに異なる値をとることを想定しているプロパティの場合は、thisによる定義の方が意味に即している。

class Person
  member1: 1
　# JavaSceiptでは、Personクラスの定義の冒頭で
  # "Person.prototype.member1 = 1"と定義される。

  constructor: ->
    @member2 = 2
    # JavaScriptでは、Person()コンストラクタの中で
    # "this.member2 = 2"と定義される。

class Person

member1: 1

　# JavaSceiptでは、Personクラスの定義の冒頭で

# "Person.prototype.member1 = 1"と定義される。

constructor: ->

@member2 = 2

# JavaScriptでは、Person()コンストラクタの中で

# "this.member2 = 2"と定義される。

privateなクラス・プロパティ

クラス直下でv=valと定義すると、そのクラスの各インスタンスで共有されたprivateなプロパティになる。

class Person
  _member = 1

  getMember: ->
    return _member

  setMember: (m) ->
    _member = m

john = new Person()
luice = new Person()

console.log("--John--")
console.log(john._member)      # undefined
console.log(john.getMember())  # 1
console.log("--Luice--")
console.log(luice._member)     # undefined
console.log(luice.getMember()) # 1

console.log()
john.setMember(5)
console.log(john.getMember())  # 5
console.log(luice.getMember()) # 5

class Person

_member = 1

getMember: ->

return _member

setMember: (m) ->

_member = m

john = new Person()

luice = new Person()

console.log("--John--")

console.log(john._member) # undefined

console.log(john.getMember()) # 1

console.log("--Luice--")

console.log(luice._member) # undefined

console.log(luice.getMember()) # 1

console.log()

john.setMember(5)

console.log(john.getMember()) # 5

console.log(luice.getMember()) # 5

JavaScriptコードを見るとクラス宣言の最初でvar宣言されているため、クラス内スコープで外からは見えない変数となる。

  Person = (function() {
    var _member;

    function Person() {}

    _member = 1;

Person = (function() {

var _member;

function Person() {}

_member = 1;