Gimp2.6で使える関数
- 数値 -

 一覧にある関数はとりあえず、使えそうな関数です。
確認はGimp6.2.10で行っています。


 Schemeでのの扱いは、数学的概念に沿っています。
数は次の階層で表されます。

複素数(complex)⊃実数(real)⊃有理数(rational)⊃整数(integer)

 これらの階層は包含関係にあるわけです。

 他方、正確数(exact)と不正確数(inexact)という概念が導入されています。簡単に言えば、誤差を含むのが不正確数、誤差を含まないのは正確数です。正確数を演算した結果、誤差が入って不正確数になる。そんな雰囲気です。
 不正確数は、プログラム制御や、個数記述などで使用できないことがあります。
 また、正確数は桁数の制限をしてはいけないことになっているようです。

 Gimp2のSchemeはここまで大げさに処理する必要は無いので、簡略したインプリメントが行われているようです。実際には、内部整数(32bit)と浮動小数の二つで処理しているようです。
 現在のところ、複素数、有理数は実際には内部では扱っていないようです。

 定数の書き方は、C言語と同様に、数字だけの連なり(「10」、「123」など)は内部整数、小数点のついた表記は浮動小数を表します。指数形式(「1.6e+15」「2.0e-15」など)でも浮動小数を表記できます。

数値
number? ( number? expr )boolean
数値か?

expr が数値ならば #t、そうでなければ #fを返す。

>(number? 10)
#t
>(number? 10.0)
#t
>(number? 1e16)
#t
>(number? #\a)
#f
complex? ( complex? expr )boolean
複素数か?

expr が複素数ならば #t、そうでなければ #fを返す。
Gimp2では、実際には複素数を扱っていないが、内部整数、浮動小数ともに、複素数に属するので、#tになる。

>(complex? 10)
#t
>(complex? 10.0)
#t
>(complex? 10.5)
#t
>(complex? #\a)
#f
real? ( real? expr )boolean
実数か?

expr が複素数ならば #t、そうでなければ #fを返す。
内部整数、浮動小数ともに、実数に属するので、#tになる。

>(real? 10)
#t
>(real? 10.0)
#t
>(real? 10.5)
#t
>(real? "abc")
#f
rational? ( rational? expr )boolean
有理数か?

expr が有理数ならば #t、そうでなければ #fを返す。
Gimp2では、実際には有理数を扱っていないが、内部整数、浮動小数ともに、有理数として、#tになる。

>(rational? 10)
#t
>(rational? 10.0)
#t
>(rational? 10.5)
#t
>(rational? (sqrt 2))
#t
>(rational? "abc")
#f
integer? ( integer? expr )boolean
整数か?

expr が整数ならば #t、そうでなければ #fを返す。
Gimp2では、内部整数は単純に整数、浮動小数は単純に整数ではないとしているようです。

>(integer? 10)
#t
>(integer? 10.0)
#f
>(integer? 10.5)
#f
>(integer? (floor 2))
#f
>(integer? "abc")
#f
zero? ( zero? numnumber )boolean
0か?

numの値が 0ならば #t、そうでなければ #f を返す。

>(zero? 0)
#t
>(zero? 1)
#f
>(zero? 0.0)
#t
>(zero? 10.5)
#f
>(zero? (floor 0.5))
#t
positive? ( positive? numnumber )boolean
正数か?

num が正ならば #t、それ以外ならば #f を返す。

>(positive? -1)
#f
>(positive? 0)
#f
>(positive? 1)
#t
>(positive? -1.0)
#f
>(positive? 0.0)
#f
>(positive? 1.0)
#t
negative? ( negative? numnumber )boolean
負数か?

num が負ならば #t、それ以外ならば #f を返す。

>(negative? -1)
#t
>(negative? 0)
#f
>(negative? 1)
#f
>(negative? -1.0)
#t
>(negative? 0.0)
#f
>(negative? 1.0)
#f
odd? ( odd? numinteger )boolean
奇数か

整数 num が奇数ならば #t、そうでなければ #f を返す。

>(odd? -1)
#t
>(odd? 5)
#t
>(odd? 2)
#f
exact? ( exact? expr )boolean
正確数か?

expr が正確数(exact)なら #t、そうでなければ #f を返す。
gimp2 では内部整数は常に正確数、浮動小数は常に不正確数として扱われているようです。

>(exact? 10)
#t
>(exact? 10.0)
#f
>(exact? 10.5)
#f
>(exact? (floor 10.5))
#f
>(exact? '(1 2 3))
#f
inexact? ( inexact? expr )boolean
不正確数か?

expr が不正確数(inexact)なら #t、そうでなければ #f を返す。
gimp2 では内部整数は常に正確数、浮動小数は常に不正確数として扱われているようです。

>(inexact? 10)
#f
>(inexact? 10.0)
#t
>(inexact? 10.5)
#t
>(inexact? (floor 10.5))
#t
>(inexact? '(1 2 3))
#f
inexact->exact ( inexact->exact numnumber )number
不正確数を正確数に変換

実際には浮動小数を内部整数に変換します。
num は、「1.0」「2.0」など(数学上の)整数でなければエラーになります。
数値の範囲は検査されず、そのときの値は保障されないようです。

>(inexact->exact 10.0)
10
>(inexact->exact 10.5)
    ↑エラーになる!
>(inexact->exact (floor 10.5))
10
>(inexact->exact (* 32768.0 32738.0 32768.0))
-2147483648  値がおかしい
exact->inexact ( exact->inexact numnumber )number
正確数を不正確数に変換する

実際には内部整数を浮動小数に変換します。

>(exact->inexact 1)
1
>(inexact? (exact->inexact 1))
#t
+ ( + [ numnumber ]* )number

num の和を返す。
numに不正確数が一つでも入っていれば、不正確数になる。

>(+ 1 2 3 4)
10
- ( - [ numnumber ]+ )number

最初の num から次々に引いた結果を返す。
num がひとつしかない場合は、0 - num の結果を返す。
numに不正確数が一つでも入っていれば、不正確数になる。

>(- 10 1 2)
7
>(- 5)
-5
* ( * [ numnumber ]*)number

num の積を返す。
numに不正確数が一つでも入っていれば、不正確数になる。

>(* 1 2 3 4)
24
>(*)
1
/ ( / [ numnumber ]+ )戻り値
除算

最初の num を、以降のnumで次々に除算した値を返す。
num がひとつしかない場合は 1 / num の結果を返す。
numに不正確数が一つでも入っていれば、不正確数になる。
正確数同士の除算のでは、結果が整数の場合は、正確数だが、それ以外は不正確数になる。

>(/ 2 3)
0.6666666667
>(/ 15 3 2)
2.5
>(/ 2)
0.5
>(exact? (/ 4 2))
#t
>(exact? (/ 4 3))
#f
quotient ( quotient [ numinteger ]+ )integer

整数除算を実。
最初の num を、以降の num で整数除算した結果の商を返す。
num がひとつだけの場合には (quotient 1 num)の結果を返す。

>(quotient 5 2)
2
>(quotient -5 2)
-2
>(quotient 5 -2)
-2
>(quotient -5 -2)
2
>(quotient 15 4 3)
1
>(quotient 7)
0
remainder ( remainder num1integer num2integer )integer

num1 を num2 で整数除算した結果を返す。

>(remainder 5 3)
2
>(remainder -5 3)
-2
>(remainder 5 -3)
2
>(remainder -5 -3)
-2
modulo ( modulo num1integer num2integer)integer
剰余

num1 を num2 で整数除算し、その剰余を返す。
剰余のと被除数の符号が一致するように計算される。

>(modulo 18 5)
3
>(modulo -5 5)
0
>(modulo -4 5)
1
>(modulo -3 5)
2
>(modulo -2 5)
3
>(modulo -1 5)
4
>(modulo  0 5)
0
>(modulo 18 -5)
-2
>(modulo -5 -5)
0
>(modulo -4 -5)
-4
>(modulo -3 -5)
-3
>(modulo -2 -5)
-2
>(modulo -1 -5)
-1
>(modulo 0 -5)
0
>(modulo 1 -5)
-4
>(modulo 2 -5)
-3
>(modulo 3 -5)
-2
>(modulo 4 -5)
-1
>(modulo 5 -5)
0
>(modulo 6 -5)
-4
abs ( abs num1number )number
絶対値

num の絶対値を返す。
num が正確数の場合は正確数を、不正確数の場合は不正確数を返します。

>(abs -15)
15
>(abs -15.5)
15.5
>(exact? (abs -15))
#t
>(inexact? (abs -15.5))
#t
max ( max [ numreal ]+ )real
最大値

numの中で最大のものを返す。
Gimp2では num がひとつだけのとき、num をそのまま返却しているらしいです。この結果、引数がひとつのときは数値以外でもエラーとならずに返却されるようになっています。

>(max 1 7 2.0)
7
>(max "abc")
"abc"	これは変だ
min ( min [ numreal ]+ )real
最小値

numの中で最小のものを返す。 Gimp2では num がひとつだけのとき、num をそのまま返却しているらしいです。この結果、引数がひとつのときは数値以外でもエラーとならずに返却されるようになっています。

>(min 1 7 2.0)
1
>(min "abc")
"abc"	これは変だ
gcd ( gcd [ numinteger ]+ )integer
最大公約数

num の最大公約数を返す。
本来は任意個数のnumに対して動作するべきだが、Gimp2では先頭の二つの num の最大公約数を返す。

>(gcd 45 30)
15
>(gcd 45 30 5)
15	これは変、5 が無視されている
lcm ( lcm [ numinteger ]+ )integer
最小公倍数

num の最小公倍数を返す。
本来は任意個数のnumに対して動作するべきだが、Gimp2では先頭の二つの num の最大公約数を返す。

>(lcm 45 30)
90
>(lcm 45 30 4)
90	これは変、4 が無視されている
round ( round numreal )integer
数値の丸め

四捨五入して整数を返す。

>(map round '(1.4 1.5 -1.4 -1.5))
(1 2 -1 -2)
floor ( floor numreal )integer
整数化

numを超えない最大の(数学的)整数を返す。

>(map floor '(1.4 1.5 -1.4 -1.5))
(1 1 -2 -2)
ceiling ( ceiling numreal )integer
切り上げ

>(map ceiling '(1.4 1.5 -1.4 -1.5 -2.5))
(2 2 -1 -1 -2)
truncate ( truncate numreal )integer
切捨て

>(map truncate '(1.4 1.5 -1.4 -1.5 -2.5))
(1 1 -1 -1 -2)
= ( = numnumber [ numnumber ]+ )boolean
等しいか

すべての num が等しければ #t、そうでなければ #f を返す。

>(= 1 1.0 1)
#t
>(= 4 4 5)
#f
< ( < numreal [ numreal ]+ )boolean
小さい

隣り合ったすべての num の組に対して、最初のnumが次の num より小さければ #t、そうでなければ #f を返す。

>(< 1 2 3 4 5)
#t
>(< 1 2 3 5 4)
#f
<= ( <= numreal [ numreal ]+ )戻り値
大きくない

隣り合ったすべての num の組に対して、最初のnumが次の num より小さいか、等しければ #t、そうでなければ #f を返す。

>(<= 1 2 3 3 4)
#t
>(<= 1 2 3 4 3)
#f
> ( > numreal [ numreal ]+ )戻り値
大きい

隣り合ったすべての num の組に対して、最初のnumが次の num より大きければ #t、そうでなければ #f を返す。

>(> 5 4 3 2 1)
#t
>(> 5 4 3 3 1)
#f
>= ( >= numreal [ numreal ]+ )戻り値
小さくない

隣り合ったすべての num の組に対して、最初のnumが次の num より大きいか、等しければ #t、そうでなければ #f を返す。

>(>= 5 4 3 3 1)
#t
>(>= 5 4 3 3 4)
#f
sqrt ( sqrt numnumber )number
平方根

num の平方根を返す。

>(sqrt 2)
1.414213562
>(sqrt -1)
-1.#IND
expt ( expt anumber bnumber )number
べき乗

a の b 乗(ab)を返す。

>(expt 2 3)
8
>(expt 4 0.5)
2
>(expt 15 0)
1
exp ( exp xnumber )number
指数関数

exを返す。

>(exp 1)
2.718281828
>(exp -1)
0.3678794412
log ( log xnumber )number
対数

自然対数を返す。

>(log 2)
0.6931471806
sin ( sin xnumber )number
sin

sin x を返す。

>(sin 3.14159)
2.653589793e-006
cos ( cos xnumber )number
cos

cos x を返す

>(cos 3.14159)
-1
tan ( tan xnumber )number
tan

tan x を返す

>(tan 0.7854)
1.000003673
asin ( asin xnumber )number
asin

asin x を返す。

>(asin 0.25)
0.2526802551
acos ( acos xnumber )number
acos

acos x を返す。

>(acos 0.25)
1.318116072
atan ( atan xnumber )number
atan

atan x を返す

(atan 0.5)
>0.463647609
atan ( atan ynumber xnumber )number
atan

座標組(x,y)に対応するatanを返す。

>(atan 2 1)
1.107148718
>(atan -2 -1)
-2.034443936
>(atan 1 0.001)
1.569796327
random ( random ninteger )integer
乱数

0<= result < n を満たす整数の乱数を返す。

(random 1000)
956
(random 1000)
476
rand ( rand ninteger )integer
乱数

0<= result < n を満たす整数の乱数を返す。

本来Schemeには無い関数。

srand ( srand ninteger )integer
乱数の種

乱数の種を与え、乱数列を初期化する。
本来Schemeには無い関数。

number->string ( number->string nnumber)string
数値を文字列に

数値を文字列に変換して返す

string->number ( string->number strstring)number
文字列を数値に

文字列を数値に解釈して返す。


アルゴ算法堂へ戻る