HSPTV!掲示板

例えば以下のスクリプトを実行するとcntが3と6のところで値がおかしくなります。
結果から想像するとpow(2,3)=8.000000と表示はされるが内部では7.999999～
なのではないでしょうか。これだと安心してpow関数を使えません。pow関数は
hspmath.asの中で
#define ctype pow(%1,%2) expf(logf(%1)*(%2)) ; x^y
と定義されているマクロですが定義の中で対処する方法はないでしょうか？

#include"hspmath.as"
repeat 8
a=pow(2,cnt)
mes a
a=int(a)
mes a
loop

浮動小数点だからじゃね？

取り合えず

a=int(a+0.00000000000001)

とでもしておけば、実質こまらないんじゃね？
根本的な解決とは言い難いけど。

そうでなければ、必要な回数掛け算を繰り返してくれるモジュールを書くとか？

hsp2年生さん、こんにちは。

私も必要な回数掛け算を繰り返すモジュールを自作するのが良いと思います。
また、この場合は四捨五入を利用、あるいはビットシフトで代用するのも有効です。

#include"hspmath.as"
	repeat 8
		mes round(pow(2, cnt)) // 結果が整数になるとわかっている場合のみ有効
		mes double(1 << cnt)   // 2のべき乗にのみ有効
	loop

>これだと安心してpow関数を使えません。pow関数は
>hspmath.asの中で
>#define ctype pow(%1,%2) expf(logf(%1)*(%2)) ; x^y

個人的にpowマクロはあまり使いません。

　X=e^y ⇔ y=logX

指数関数の逆を考えると直感的に上式の X が 0 以下に成ることはありえないと分かるので、
pow(a, b) (ただし a > 0 )
となってしまいます。

時と場合に左右されるなら f さん eller さんの言うとおり、モジュールを自作してみてはどうでしょうか。

一度、文字列にしてみるとかどうでしょうか。

#define ctype pow(%1,%2) double(str(expf(logf(%1)*(%2)))) ; x^y
repeat 8
a=pow(2,cnt)
mes a
a=int(a)
mes a
loop

皆さんありがとうございます。
結果が予想されることは対処できますが、あらゆる実数計算で有効な方法が思い当たりません。
実数計算にも桁数の限度があるので誤差があるのは理解できます。logやexpを使う限り誤差が
あって当然と思いますが、せっかくpow(2,3)=8.000000と表示されるのですからこれをそのまま
計算結果として使用したいのです。(7.999999ではなく)
この場合は
#define ctype pow(%1,%2) expf(logf(%1)*(%2))+0.00000000000001 ; x^y
で対処できますが他の場合に悪影響がでますよね。掛け算を繰り返す方法は効率が悪くないで
すか？　今のところ良い方法が見えません。他の言語ではどうなっているのでしょう？

これは以前HSP3 Beta BBSのほうで話題になったint(2.55*100)が254に
なってしまう現象と同じではないかと。あのときは、なたでさんの
おっしゃるように一度文字列にするのが一番のような結論になった
気がします。

>int(2.55*100)が254に
なるほど！　ということは問題はpowでなくintにあるということでしょうか？
もしそうだとすると重大な問題になることもあります。
今まで気が付かずにint関数を使ってきましたがプログラムを見直さなければいけなくなりますね。

数値専用にintnを定義して
#define intn(%1) int(str(%1))
でいいでしょうか？皆さんの意見をお待ちします。

四捨五入すればいいんじゃないでしょうか。
http://www005.upp.so-net.ne.jp/h-masuda/hsp30/kiso/hspk032.html

intn()関数も良いと思いますが、それ以前になぜこの現象が起こるのかを理解した上でスクリプトを書く必要があると私は思います。趣味の問題かも知れませんので、参考程度に聞き流していただければ幸いです。
なお、以下の記述は個人の検証の結果であり確実なものではないことをご理解ください。

さて、問題はpowでもintでもなくfさんや（過去ログの）Kryptonさんがご指摘されているように、浮動小数点……つまり実数演算の精度にあると思います。
詳しくはありませんが丸め誤差や打ち切り誤差が出ているのでしょう。

で、「なぜstr()関数を利用すると良いのか」については以下のスクリプトをご覧ください。

#include "hspmath.as"

	mes "str()とint()について"
	mes str(100.0000004)            // str()関数は小数第七位を四捨五入する
	mes str(100.0000005)
	mes int("100.9")                // int()関数は小数点以下を切り捨てる
	mes int(100.9)

	pos 200, 0
	mes "実数演算の精度について"
	mes 2.55 * 100                  // 2.55 * 100 を普通に出力すると 255 に見えるが...
	mes strf("%.20f", 2.55 * 100)   // 実際は 255未満 である
	                                // → だから int(2.55 * 100)は 255 にならない
	mes str(2.55 * 100)             // str関数は小数第七位を四捨五入するから、255.000000 になる
	mes ""
	mes int(str(2.55*100))          // よってこのスクリプトは、
	mes int(round((2.55 * 100) * 10000000) / 10000000)
	                                // このスクリプトと同じ

よって、str()関数を利用することは実質的に四捨五入することと同じです。が、小数第七位での四捨五入は色々と面倒なのでintn()を使った方が楽ですね、という話なのだと思います。
しかし結果が整数になることが保証されているならば、誤差が0.0000005を超えると利用できないintnよりは誤差が0.5を超えるまで利用できる小数第一位の四捨五入の方がより安心して使えるのは確かです。よって個人的にはGENKIさん同様、四捨五入の利用をオススメします。
以上です。長文失礼しました。

> よって個人的にはGENKIさん同様、四捨五入の利用をオススメします。

事例として255とstr()の件を上げましたが、私も四捨五入を使っています。

ただ、ファイルサイズを１バイトでも減らしたいという状況の場合、
str()のほうが有利かもしれません。

皆さん真剣に考えて下さいまして感謝します。

掛け算を繰り返す方法は pow(27,1.0/3) //３乗根　とかができません。
モジュールを作るのになるべく条件をつけたくないからhspmath.asの方法が一般的だと思います。

（まず確認したいのですが）
そうするとこの問題は浮動小数点演算を行っているかぎり避けられないから、
pow(2,3)=8.000000でも7.999999でも数値的にはどちらも同じと考えられ、実数計算をしている限り
最大限精度は保たれているがpow関数に限らずintを使う場合に限って注意が必要という認識で良いで
しょうか？
或いは他にも浮動小数点のことを頭において注意しておかなければいけないことはあるでしょうか？
（物理的な計算をする時このことが精度に大きく影響するので・・・）

strやmesが少数第7位で四捨五入するのは計算の最終結果として表示する場合の親切な行為と考えられ
そうですね。

四捨五入する場合は何桁目でするかが問題になりますが、intの直前で有効桁数の最下位で四捨五入
すれば安全ですか？

> pow(2,3)=8.000000でも7.999999でも数値的にはどちらも同じと考えられ、実数計算をしている限り
> 最大限精度は保たれているがpow関数に限らずintを使う場合に限って注意が必要という認識で良いで
> しょうか？

　精度(正確さ)を重視するなら、その認識ではだめです。

　そもそも 8.000000 と 7.999999 は明らかに異なる値であり、
2 の 3 乗を 8.000000 でなく 7.999999 と返すものを使った計算は
答えにどんな補正をかけようとも正確さとは無縁です。
他に適当な代替手段がないならやむを得ませんが、整数の整数乗の計算ならば
すでに書かれているように乗算の繰り返しで正確な答えを求めることができます。
(表現可能範囲の限界はあります。)


　参考までに以下はC言語で記述されたC言語での pow 関数の定義の一例を
HSPに移植したものです。

#module
#defcfunc pow2 double x, double y;, local r, local xx, local yy
	if ( x == 0.0 ) {
		//	error
		if ( y == 0.0 ) { return 1 } else { return 0 }
	}

	if ( y == double( int( y ) ) ) {
		//	指数が整数
		r = 1.0
		if ( y < 0.0 ) { xx = 1.0 / x } else { xx = x }
		yy = abs( y )
		repeat
			if ( yy & 1 ) { r *= xx }
			yy >>= 1
			if ( yy == 0 ) { break }
			xx *= xx
		loop
		return r
	}

	if ( x < 0.0 ) {
		//	error
		return 0
	}
	return expf( logf( x ) * y )
#global

Dripです。

　hsp2年生さんのおっしゃる問題は、「丸め誤差」という、ごく一般的な現象による
トラブルです。ためしに次のスクリプトを実行してみて下さい。

mes "1.1+2.2="
if 3.3 = 1.1+2.2:mes "3.3である。":else:color 255:mes "3.3ではない"

不可解な点に気付くと思います。比較結果は明らかに等しく、
「3.3である」と表示されるべきなのに「3.3ではない」と表示されてしまいます。
これは丸め誤差によって小数の計算結果が微妙に変化してしまうために発現する現象ですが、
これはHSPに関係なく、CでもJavaでも避けようのない仕方の無い事です。

　ですがゲームやツール等を作っている最中、どうしても正確に演算しなければならないことも
出てきます。その場合、多くのプログラマーは整数型を利用して正確な小数の演算を実現しています。
これならば如何なる演算であっても丸め誤差は一切発生しません。

　ところで、スレッドを見た限りではhsp2年生さんが一体なぜ「いかなる場合も
正確に演算できるdouble型」が必要なのかわからないのですが、
それをご説明いただければ代価案等を提案できるかもしれませんね。

説明が足りなかったので補足しておきます。

最初はint(pow(2,3))=7がおかしいと提議しました。これは浮動小数点演算の影響と理解し
ました。他にもint(2.55*100)=254　など浮動小数点演算の影響を考えなければならない
ならばint()の前で四捨五入してこれを補正する。というのが一番手っ取り早いのではない
かと思ったのです。

論点は演算の答えを正確に求めるのか、演算の答の誤差を認めるかですが、
int(pow(2,3))=7の理由が分った今は演算の正確さよりも、私がこだわっているのはこの
浮動小数点のことを気にしないでint()を多用してきた過去のプログラムが心配なのです。

勿論、演算の答えを正確に求られるならばそれにこしたことはありません。
しかし浮動小数点演算ではこの問題は避けられないのでint()の時だけ気をつければ良いのか?
とお聞きしたのです。Dripさんご指摘のif文の比較でも気をつける必要がありそうですが
とりあえずint()を使ったときint(pow(2,3))=7やint(2.55*100)=254のようなことにならない
ようにしたいのです。

出来る風気取りか？
何を作ろうと為ているのかしらねぇが
HSPに限ったことじゃねぇし
そんだけ蘊蓄垂れるんなら自分で解決しろや？

で、とりあえずテメェの書いたソース晒してくんね？
話はそれからだな

テメェのレベルに合わせて答えてやるよ

これもネタふりなんだろ 餓鬼がww

浮動小数のフォーマットを調べてみれば，すぐわかることでしょう．
極基本的な話だと思いますが・・・
HSP2は整数しか扱えない仕様ですが，そのような仕様にした理由がわかる気がする．

> ならばint()の前で四捨五入してこれを補正する。というのが
> 一番手っ取り早いのではないかと思ったのです。

　プログラムには手っ取り早くこうするだけで関連する問題が
全て解決する、というような魔法の薬は存在しません。


> int()を使ったときint(pow(2,3))=7やint(2.55*100)=254
> のようなことにならないようにしたい

　実数値を最近整数値に丸める意図で int を使う場合は
少数第一位で四捨五入を行えば(0.5を足した値を型変換すれば)良いです。

　別の意図をもって int を使っているならこの限りではないので
機械的に int を使用している箇所を変更するようなことはしてはいけません。


> int(pow(2,3))

　整数の 0 か正の整数乗しか行わない条件ならば答えは本来整数値であり、
たまたま近似実数値が返されたのを最近整数値に丸めるという意図があるので
hspmath での定義を使った int(pow(x,y)+0.5) で問題ないでしょう。
　しかしそれ以外の条件なら当然これではだめです。


> int(2.55*100)

　実数値 2.55*100 を 整数値 255 にする、ここまではわかります。
では 実数値 2.551*100 は整数値 255 ?、それとも 256 ?。
同様に 2.555*100 は?、2.559*100 は?
意図が明確でないものは処理を決定できません。
　小数点二桁までの値しか扱わない場合、あるいは最近整数値に丸める意図なら
int(2.55*100+0.5) で良いですが、小数点以下の切り捨てをする意図なら
実数値をそのまま実数型で扱う方法では適切な処理はありません。

皆さんありがとうございます。

naznyarkさんのおっしゃることは分かります。

数値のことだけで言えば、int()は忠実に小数点以下を切り捨てるという機能ですよね。
だから2.555*100=255.5→int(2.555*100)=255、2.559*100=255.9→int(2.559*100)=255となる
のが当然です。しかしint(2.55*100)=254となるのは明らかにおかしいです。

このようなことが予測できれば対処のしようがありますが実数計算をする中でこのようなこと
が予測できないのでint()を使う時に対処すれば良いのではないかと思うのです。

>最近整数値に丸める意図なら
最近整数値に丸める意図はありません。

だから
>intの直前で有効桁数の最下位で四捨五入すれば安全ですか？
とお聞きしたのです。
今は有効桁数の最下位に1を足した方が良いのではと思うのですがどうでしょう？
精度的にはは有効数字の小数点以下がオール9の時だけ影響しますが１違うより0.00...1
の方がまだまし？

これではだめですか？

 

#include"hspmath.as" 
#module 
#defcfunc intn double a 
	b=1 
	repeat 15-strlen(str(int (a))) 
		b=0.1*b 
	loop 
	return int(a+b) 
#global 
 
a=pow(2,3) 
mes "pow(2,3) " 
gosub *hyouji 
 
a=7.9999999999999 
mes "7.9999999999999" 
gosub *hyouji 
 
a=2.55*100 
mes "2.55*100" 
gosub *hyouji 
stop 
 
*hyouji 
mes strf("%.15f",a) 
mes "int()="+int(a) 
mes "intn()="+intn(a) 
mes "" 
return 

naznyarkさんが言うような「確かさ」を求めるなら、これどうでしょうか。

	#define Rounding(%1, %2) lpoke round@, 1, varptr(%2) : %1 = callfunc(res, varptr(round@), 0)

	round@ = $000000b8,$ddd48b00,$fc5adb00,$c3fc428b

	a = 2.55 * 100
	b = 0
	Rounding b, a
	mes b

丸め方は、JIS Z 8401規格と同じです。http://www.bsddiary.net/doc/jis-z8401.html
他にも切り上げ、切捨てが出来ますが、SSE3乗ってないと重いので割愛します。
2年生クンのやりたいことと、はずしてたらごめんチョ。

> これではだめですか？

　一般的に実用になると思いますか?
もちろん条件が限定されるならば使える局面はあります。

　例えば以下のような場合なら使えるでしょう。

#include "hspmath.as"
#module 
#defcfunc intn double a 
	b=1 
	repeat 15-strlen(str(int (a))) 
		b=0.1*b 
	loop 
	return int(a+b) 
#global 

	mes "２の n 乗( n = 整数 )を求める。\n"
	repeat 8
		x = pow( 2, cnt )
		mes " 2 の " + cnt + strf( " 乗 = %12d ", int( x ) ) + strf( "(%32.18f)", x )
		mes " 2 の " + cnt + strf( " 乗 = %12d ", intn( x ) ) + strf( "(%32.18f)", x )
		mes " 2 の " + cnt + strf( " 乗 = %12d ", int( x + 0.5 ) ) + strf( "(%32.18f)", x )
	loop

　しかし以下の場合では補正しきれていません。

#include "hspmath.as"
#module 
#defcfunc intn double a 
	b=1 
	repeat 15-strlen(str(int (a))) 
		b=0.1*b 
	loop 
	return int(a+b) 
#global 

	mes "１０００の n 乗( n = 整数 )を求める。\n"
	repeat 4
		x = pow( 1000, cnt )
		mes " 1000 の " + cnt + strf( " 乗 = %12d ", int( x ) ) + strf( "(%32.18f)", x )
		mes " 1000 の " + cnt + strf( " 乗 = %12d ", intn( x ) ) + strf( "(%32.18f)", x )
		mes " 1000 の " + cnt + strf( " 乗 = %12d ", int( x + 0.5 ) ) + strf( "(%32.18f)", x )
	loop

　加えて以下のような場合ではそもそも整数への補正の出番はありません。

#include "hspmath.as"
#module
#defcfunc pow2 double x, double y;, local r, local xx, local yy
	if ( x == 0.0 ) {
		//	error
		if ( y == 0.0 ) { return 1 } else { return 0 }
	}

	if ( y == double( int( y ) ) ) {
		//	指数が整数
		r = 1.0
		if ( y < 0.0 ) { xx = 1.0 / x } else { xx = x }
		yy = abs( y )
		repeat
			if ( yy & 1 ) { r *= xx }
			yy >>= 1
			if ( yy == 0 ) { break }
			xx *= xx
		loop
		return r
	}

	if ( x < 0.0 ) {
		//	error
		return 0
	}
	return expf( logf( x ) * y )
#global
#module 
#defcfunc intn double a 
	b=1 
	repeat 15-strlen(str(int (a))) 
		b=0.1*b 
	loop 
	return int(a+b) 
#global 

	mes "２の n 乗( n = 2.4, 2.6 , ... , 3.8 )を求める。\n"
	repeat 8
		y = 2.4 + 0.2 * cnt
		r = pow( 2, y )
		r2 = pow2( 2, y )
		mes strf( " 2 の %4.1f 乗 = ", y ) + strf( "%12d ", intn( r ) ) + strf( "(%32.18f)", r )
		mes strf( " 2 の %4.1f 乗 = ", y ) + strf( "%12d ", intn( r2 ) ) + strf( "(%32.18f)", r2 )
	loop

　ああ、ようやく何を言っているのかがわかったような気がします。
こういうことですか?


　次のような処理を行った場合の話です。

処理:
　まず数値を実数型で扱って演算を行ないその答えを取得し、
その後 int を使ってその答えの小数部を切り捨てて整数化します。

　演算の結果として予想される答えが整数値の場合に
上記の処理を行うと、整数化の結果得られた整数値と
予想される答えの整数値が異なるときがあります。

(例えば
d = 2.55 * 100 : i = int( d )
の場合は i の値は 254 となり予想される値 255 と異なります。)

(これは実数の変換や演算時に誤差が生じてしまい、実際の演算の
答えが予想される答えの整数値より小さい実数値として返される
場合におきる現象だということは理解しています。)

　この現象を回避し、実際の演算の答えを整数化した整数値と
予想される答えの整数値が等しくなるようにするための手法と
して以下のような処理は妥当なものでしょうか?

処理：
　整数化の際に実際の演算の答えに補正値を加え、
int でその補正後の値の小数部を切り捨てて整数化する。

(例えば
d = 2.55 * 100 : i = int( d + 0.1 )
とするようにすれば i の値は 255 となり予想される値と
一致するようになります。)

　また上記の処理が妥当ならばその際の補正値はどのような
大きさの値が適切でしょうか?

> 数値のことだけで言えば、int()は忠実に小数点以下を切り捨てるという機能ですよね。

「切捨て」というようななにやら数学的な表現よりは、
「機械的に整数部を返す」という表現の方が実情にあってるかもしれませんね。

> だから2.555*100=255.5→int(2.555*100)=255、2.559*100=255.9→int(2.559*100)=255となる
> のが当然です。
> しかしint(2.55*100)=254となるのは明らかにおかしいです。

この認識が間違ってるかな。明らかにおかしくはない。

浮動小数点は、数学で言う実数ではありません。
浮動小数点が実数を忠実に表現できるという期待があると、
プログラムに今回みたいなバグを持ち込むことになります。
(初心者がそういう期待を持ってしまうのは無理もないけどね)

浮動小数点は有限の桁数しか持たないソロバンみたいなものです。

有限の桁しか使わないで計算すれば、誤差が出るのはあたりまえで、
例えば小数点以下 3 桁で筆算すれば、
1/3 = 0.333
0.333 * 3 = 0.999
と言うぐあいに、1 を 3 で割った値に 3 を掛けても 1 にはなりません。
1/3 という実数は十進展開すると 0.333.... と無限に続きますが、
それを有限の桁で表すからこういうことになります。

浮動小数点で表現しようとすると、たとえば 0.1 という実数が、無限に続く表記となります。
実際はそれをまるめちゃうから、1/10 は 0.1 よりちょい少ない値になる。
だから 1/10 を 10 倍しても 1 にはならない(0.99999999999999998 とかになる)。
(なお、それをプリントしたり文字列に変換したりすると "1.0" とかになるのは、
変換するところで丸めてるから)
よって 1/10 を 10 倍した結果の整数部は 0 になる。

これは浮動小数点を使うどんな言語でも起こる問題で、
多少の経験のあるプログラマにとっては常識です。

これは int の問題ではないので、
int をいじっても万能の解決法はありません。

なぜそこで int を使ったのか、その目的に合わせて
それぞれ適切な対応が求められます。

がんばってね

あ、そんで今回の 2 の n 乗 (n は正の整数) に関しては、
2^n が整数で収まる範囲なら、素直にループしたほうがいいんじゃないかな。
もしシフト演算が可能なら、もちろんシフトを使うわね。
ループが遅くて嫌なら、もし配列使えるんであれば、配列に入れとくと早いよ。
n が 負なるとか、32 以上になるとかなら、そのとき初めて指数関数の出番かな。

>しかし以下の場合では補正しきれていません。
確かにそうですね。

>(例えば
>d = 2.55 * 100 : i = int( d + 0.1 )
>とするようにすれば i の値は 255 となり予想される値と
>一致するようになります。)
>　また上記の処理が妥当ならばその際の補正値はどのような
>大きさの値が適切でしょうか?
そういうことです。

一番最初の質問のPow(2,3)はnaznyarkさんのpow2で解決できることはわかりました。
今はintを無意識の内に使用して計算の中でint(2.55 * 100 )のようなことが起こっているかも
しれないから何か対処の方法はないかと思ったのです。（説明不足ですみません）

>　参考までに以下はC言語で記述されたC言語での pow 関数の定義の一例を
>HSPに移植したものです。
さらに移植してみました。

	#define pow2(%1,%2,%3) _prm_ = varptr(%2), varptr(%3), varptr(%1) : _prm_ = callfunc(_prm_, varptr(_pow@), 3)

	_pow(0) = $83ec8b55,$5653ecc4,$105d8b57,$8b08758b,$eed90c7d,$dcf855dd,$e0df9b16,$dc1e759e,$e0df9b1f,$d90b759e
	_pow(10) = $5f1bdde8,$c2c95b5e,$eed9000c,$5e5f1bdd,$0cc2c95b,$d907dd00,$9b1fdcfc,$759ee0df,$dc07dd56,$df9bf85d
	_pow(20) = $09739ee0,$36dce8d9,$ebf05ddd,$dd06dd05,$07ddf05d,$5ddbe1d9,$dde8d9ec,$4d8bf85d,$01c1f7ec,$74000000
	_pow(30) = $f845dd09,$ddf04ddc,$e9d1f85d,$0b74c90b,$dcf045dd,$5dddf04d,$dddeebf0,$1bddf845,$c95b5e5f,$8a000cc2
	_pow(40) = $c4f60766,$d90b7480,$5f1bddee,$c2c95b5e,$07dd000c,$f1d906dd,$d9f855dd,$f845ddfc,$5ddde1d8,$d9e8d9f8
	_pow(50) = $dd1bddfd,$ddf7d9c0,$f0d9f845,$c1d8e8d9,$1bdd0bdc,$f7d9c0dd,$c95b5e5f,$000000c2

	a = 0.0
	p1 = 3.0
	p2 = 0.5
	pow2 a, p1, p2
	mes "" + p1 + " の " + p2 + " 乗は " + a + " です"
	#include "hspmath.as"
	mes "hspmath → " + pow(p1, p2)

皆さん長いスレッドお付き合い頂きましてありがとうございました。

これからはint()を使う時は丸めて良いもの良くないものの区別を慎重に
対応していきたいと思います。

解決した訳ではではないですが浮動小数点と実数の違いも分かりましたので一応解決にして
おきます。

勉強になりました。