浮動小数

っていらないでしょ。

固定小数マンセー

終了

少しは懲りろ！　　　.／　＼ ＼　　／￣￣￣￣￣￣
　 　　　　　∧＿∧／　　　　￣ 　＜　また貴様か！
　　　　　　（；´Д｀）　　　　 i i i　　　 ＼＿＿＿＿＿＿
　　　　　 /　　　 ヽ ＿　　　i i i--､
　　　　 ./|　|　　 | |　　￣￣￣ |:::::|.
　　　　/　＼ヽ／| | 　　　　　　ﾉ__ﾉ..
　　　/　　　＼＼| |
　　 /　/⌒＼ し(メ　　　　.i i i　.　.
　／ ／　　　 >　）　＼　　ﾉﾉﾉ
/　/ 　　　　/ ／　 　 .＼＿　　ｻﾞｯｸｻﾞｯｸ
し'　　　　　（＿つ　　　/:::::/::...　　 /ヽ
　　　　　　　　　　； "ノ・ ./∴: ／ ）i　iヽ-､＿へ　　　　,ﾍ
　　　　　　　　　　'',, : ：―― /　/　i　i　i iヽ .￣ ﾞ― ノ　/
　 　　n_　　　　＿／；　　　 i　　.ノ / /ノ-'￣ ﾞ ― ､__ノ
　　_ノ　二二二､_（ _Д_　;）-ヽ＿ノ-'>>1
　　ﾞー ''~　　　 　　∨￣∨

いつも小数点の位置は固定だけど？

円周率は 0.314159265 E+1

０の次にしか小数点はこない。

intが64bitになれば、ますます固定小数点演算の需要は増えるね。

　　　　　　　　　　　　　　　　＼　│　／
　　　　　　　　　　　　　　　　　／￣＼　　 ／￣￣￣￣￣￣￣￣￣
　　　　　　　　　　　　　　　─（ ﾟ ∀ ﾟ ）＜　2/22(土) 16時と21時
　　　　　　　　　　　　　　　　　＼＿／　　 ＼＿＿＿＿＿＿＿＿＿ 　
　　　　　　　　　　　　　　　　／　│　＼
　　　　　　　　　　　　　　　　　　　 ∩ ∧　∧　　／￣￣￣￣￣￣￣￣￣￣
￣￣￣￣￣￣￣￣＼∩ ∧　∧　＼（ ﾟ∀ﾟ）＜　梅田マルビルの電光掲示板に…
　『ｷﾀ━（ﾟ∀ﾟ）━!!!!』 ＞（ ﾟ∀ﾟ ）/ ｜　　　　/　＼＿＿＿＿＿＿＿＿＿＿
＿＿＿＿＿＿＿＿／ ｜　　　 〈　｜　　　｜
　　　　　　　　　　　　　 /　／＼_」　/　／＼」
　　　　　　　　　　　　　 ￣　　　　 / ／
　　　　　　　　　　　　　　　　　　　￣
詳細はココ→　http://life2.2ch.net/test/read.cgi/offreg/1044221627/l50

「このまま一生彼女ができないのでは…」

　私は社会学を専攻している者です。社会学や周辺の学問を利用し、実践的な
恋愛理論を開発しております。机上の空論に終わらず、あくまで実践的。効果
は絶大です。この理論は私自身の苦悩から生まれました。モテないことに深く
悩んでいた私は社会学部に入り、恋愛をはじめとするコミュニケーションにつ
いて考察することを決意。開発期間およそ６年。やっと研究が実を結びました。
ルックスなんて恋愛に関係ないということを自ら証明したのです。今回はその
集大成を公開しようと、メールマガジン発行を決めました。すでに数回発行し
ておりますが、購読者にはバックナンバーが閲覧できますのでご安心を！

　今ならまだ間に合います。春、出会いの季節に幸せが訪れるかどうかは、あな
たの選択次第です。絶対に後悔はさせません。「９０日彼女ゲットプログラム」
もちろん購読は無料！　→　→　http://www.h5.dion.ne.jp/~psysys/index.html

http://sagatoku.fc2web.com/
あなたの探し物こちらで見つかります

なんか最近糞スレ多くねぇか？

固定小数なら0.00000000000000000000000000000000000000000000000000000000128とかどう（ｒｙ

>>5
long使わない理由は?

山の浮動小数点？？？
ってなんか北斗の拳におったな

>>5
それってC++のint?

>>12
intが64bit -> 64bit cpu
ってことでしょ。

浮動小数点って誤差あるのに用途あるの？

あらゆる計測機器は誤差があるけど用途もあります。

>>16
科学技術計算には使えるぞ。

>>16
誤差の無い測量がこのよにあるとでも思ったか?
誤差を確実にこの世から無くせた奴は神

>>15
古い31bitsマシンとの互換性はどうなる?

それを言うならlong longを使ったほうがいいと思うけど

いくら古くったって、wordサイズが素数のCPUとかってあったのか?

>>5の言いたいことがよく理解できない。
だれか解説できる?

sizeof(double) == sizeof(int)

>>16
あのなあ、固定小数点だろうと
その数が平方などによって得られたものなら
無理数になるものも丸めて無理やりむりやり有理数
した誤差を持った値なんだぞ。

金融では良く使うね>固定小数

>>26
お金の勘定では少数が出ても金にするときは端数切捨てか
なにかですからねぇ。
桁数も限られて
もう、ほとんど気にしなくていいというか。

物理の世界では考えられないことですね。

ちょっとひろいかもｗ（＾_＾；）

>>25
あの〜。勝手に誤差が出るのと人為的に端数処理するのでは全然違いますよ。

とりあえずCPU486以上つかっとけ

不動小数とは主に実数をコンピュータ上で表すための形式で
指数表記の小数点の位置が常に一定の場所であることからこう呼ばれています｡

俺はどちらかというと不動明神のほうが。

不動明はデビルマン

犬神明はウルフガイ

＞指数表記の小数点の位置が常に一定の場所であることからこう呼ばれています｡

そのような小数点を不動点と呼びます。

各寺に２人づつしかいませんってか？

>>29
あの〜。桁数の有限なコンピュータで無理数を表現する以上
端数処理は避けられませんよ。

>>37
どこに端数処理が避けられるって書いてあるって？
文章ちゃんと読めよ（藁

Floating Point Exception age!

小数を２進のコンピュータでやらすのは酷

>>39
　 ∧＿∧
　（　´∀｀）＜ふろぽ

浮動小数っていまいち分からないんだよな。
いや、基本的な構造くらいはもちろん押さえてるんだが。

これを読めば浮動小数の神になれるみたいな本はないのか。

仕様嫁

ｲﾁｵｳｼﾏﾂｼﾃｵｸｶ
　 （　・∀・）　　　|　|　ｶﾞｯ
　と　　　　）　 　 |　|
　　 Ｙ　/ノ　　　 人
　　　 /　）　 　 < 　>.__Λ∩
　 ＿/し'　／／. Ｖ｀Д´）/
　（＿フ彡　　　　　 　　/ 　←>>41

おまえら浮動少数が死滅寸前に追い込まれたときどうするよ？

ちゃんと対策とってるかよ
死滅対策をよ
死滅後の行動とってるかよ

浮動小数って死滅するの？

　浮動拳の使い手ですが、文句ある？

おまえら45が死滅寸前に追い込まれたときどうするよ？

ちゃんと対策とってるかよ
死滅対策をよ
死滅後の行動とってるかよ




別に放っておいてもいいか

>>46
コンピュータのスペックがさらに増大し
高精度の長桁計算の需要が高まれば
10進可変長固定少数が普及すれば死滅する。
マジで

>>49
1950年代から60年代に作られた初期の計算機は、ほとんどが10進でした。
二進など歯牙にもかけられないほどでした。
そのときにも、科学技術計算や一般の計算にも十進は必須だと思われ、
計算機の性能が上がれば、二進などは消えてなくなると言われていました。
しかし、70年代後半になり、計算機の性能が向上して消えたのは十進の方でした。
それから２０年以上も二進の時代が続いたわけですが、
じつはそろそろ三進数の時代になったりしちゃったりして。
そして大論争が勃発、規格戦争に発展、二進も三進もいかなくなるという・・・

>>50
三振方は電流の向きを解読できる方法を知らないことにはのう。

ま、コンピュータは二進でいい。ソフトウェアだけで10進演算を実現するのじゃ。
これからはソフトウェア10進の時代じゃ。

ところでニッチとサッチってニシンさんしんからきたの？

3Dゲームの世界ではまず単精度から倍精度にするのが先だろうな。

3Dゲームの世界じゃ固定小数が多いと思うぞ。

>>53
おいおい、ここは時代が５年ズレてるスレじゃないぞ。

MMX 世代なら固定小数だろうけど、SSE 世代なら浮動小数点を使うような。
DX9 で 16bit 浮動小数点が導入される辺りからしても固定小数点は下火になっているかと。

>DX9 で 16bit 浮動小数点が導入される

それはピクセルフォーマットの話ちゃうのん。
座標系は大昔から浮動小数であろう。

金融系で浮動小数点はご法度です。

整数論でも浮動小数点どころか固定小数点もご法度です。

固定小数点はすでに死語

浮動小数点は死滅

>>60
そういってるお前には制御系の仕事も
信号処理系の仕事も科学技術計算系の仕事も回って来まい

What Every Computer Scientist Should Know About Floating-Point Arithmetic
http://docs.sun.com/source/806-3568/ncg_goldberg.html

物理屋なら浮動小数点知っていなければおかしいだろ

double percomp,file_complete;
int totalfiles,numfiles,totalfiles;

percomp = ((double)(totalfiles - numfiles) + 1 - (1 - file_complete)) / (double)totalfiles;
〜
"ERROR: float invalid operations."

>>63
ということは物理の教科書とかにも載ってるんだ。大学でも習うの?教養課程以外で?

（＾＾）

　　 ∧＿∧
　　（　　＾＾ ）＜ ぬるぽ（＾＾）

>>65
当たり前だろ。
いまどきコンピュータ無しで測定結果を処理したがる時代かっちゅ〜の。
数値計算を教われば習って当然よ。
実験してる奴は殆ど使って当たり前だろ。

天文学者はもっと膨大な桁を扱う以上、浮動小数点は避けては通れなくて当然

　　　 　∧＿∧
ﾋﾟｭ.ｰ　(　　＾＾ ） ＜これからも僕を応援して下さいね（＾＾）。
　　＝〔~∪￣￣〕
　　＝ ◎――◎ 　　　　　　　　　　　　　　　　　　　　　山崎渉

浮動小数点って誤差あるのに用途あるの?

>>70
それは「計測器って測定誤差あるのに用途あるの?」という質問と同じだ。
誤差の評価も出来ない奴に科学技術計算のプログラムは書けん。てゆうか書くな。

>>70
> 浮動小数点って誤差あるのに用途あるの?
↑ｳﾞｧｶ発見

>>70
ケーキ切り分けた後で重さまで比べる香具師発見

合計１兆円なら１ﾏｿ円くらい誤差くらい許せよ　＞経理屋
経理屋は細かくていかんわなぁ。

>>74
おいおい、それはいかんだろ。
トラブルのもとだぞ。裁判になる。　

>>70は数値計算や物理をもう一回一から勉強しなおした方がいいね。
自然界に存在する誤差を知らないアホは。
自然界に存在するものをコンピュータで再現すりゃそりゃ誤差がでるだろが。

>>70は自然現象をなめとんのか。
神に逆らっているようなもんだぞ

>>76
計測誤差と浮動小数点の丸め誤差を一緒にするなよ

10進2進変換誤差と浮動小数点誤差を一緒にするなよ

ゴザとムシロを一緒にすんなよ

>>57
そうか？金銭型ってのは使わないの？

金融関係ではどんぶり型を使って計算します。

　__∧＿∧_
　|（　　＾＾ ）|　＜寝るぽ（＾＾）
　|＼⌒⌒⌒＼
　＼ |⌒⌒⌒~|　　　　　　　　　山崎渉
　　 ~￣￣￣￣

　__∧＿∧_
　|（　　＾＾ ）|　＜寝るぽ（＾＾）
　|＼⌒⌒⌒＼
　＼ |⌒⌒⌒~|　　　　　　　　　山崎渉
　　 ~￣￣￣￣

（＾＾）

>>80
多分10進型を使いこなしているCOBOLerだと思う。

何で2ヶ月前のレスに上げてレスするのか？

多分２ｃｈを使いこなしてないリア厨だと思う。

javaでbigdecimalクラスを使うのと
普通のintを使うのとで
一体何が違うのか教えてくれー。

>>87
ところでおまえさんよ、BigIntegerとdoubleはしっとるよな。

ドキュメント見ればああなるほどと一発でわかるのだが。
桁数が可変になってdouble型以上の高精度、多倍長計算ができる
程度の違いだよ。BigDecimalは内部で10進数で値を
保持しているようだから計算はdolubleより遅くなるがね。
しかも三角関数などの初頭関数が用意されていない。
自作するか誰かが作ったライブラリをとってきて使うしかない。
double型の制度内に収まる値なら一旦doubleに変換して計算が終わったら
BigDecimalに戻すという手法もあり。

単精度値全体を見渡すと、250個のうち1個はNaN値なんだよな。もったいない話だ。
せっかくだからNaN値の面白い使い方でも教えてくれや。

※ むかつくCGIにシグナリングNaNを入力してアボートさせるなんてのはナシよ。

整数型三角関数
http://www.gen-ta.net/underwater/

>>89
0÷0はNaNです。

文系出身のオレにはこの辺はチンプンカンプンだ。。。

理系出身のオレにもチンプンカンプンだ。。。

>>89
NaN==NaN はfalseです。

>>90
オレにも出来た。整数型三角関数。
int　intsin(int　x){
　return　(int)sin((double)x);
}

これでいいんじゃないか？
#define intsin( 0*(

-1〜1の範囲から出られない三角関数なんぞ俺の人生には不要だ。

>97
tan, cot,sec,cosec しか使わないということですか。

>>98
しか?

浮動小数点が扱えない（整数型のみ）システムで、
浮動小数点を計算したい場合はどうやるのでつか？

>100
浮動小数点演算ライブラリをリンクする。

昔はZ80用浮動小数点ライブラリなんてのもあったな。

>>89
なんじゃそりゃ。ぱっと見ただけではまったく意味がわからなかったぞ。
ちゃんと説明せいや。
32bits表現可能な値のうち250分の1
( 0x7f800001 〜 0x7fffffff, 0xff800001 〜 0xffffffff)はNaNで表現されるとい
解説をいれてくれや。

メモリもマシンパフォーマンスも向上した時代に
いまどきそんなもんを有効利用しようとしてどうする。

>>100
素人が考えた手法です。この手法は、0除算対策には対応していません。

数値を表すクラスを継承した分数クラスを定義する。
privateなフィールド(属性)には整数配列型分母フィールド、整数配列型分子フィールド
を定義する。

コンストラクタは、 分数(long 分子, long 分母)とし、
内部ではこの整数型の数値の一桁一桁の数字を
分割し桁数と同じ長さの整数型配列の中に入れる。

long型で返すget分母(), get分子()メソッドを定義する。

そのクラスに四則演算としてadd(), subtract(), multiply(), divide()メソッド(操作)を用意する。
それぞれのメソッドの戻り値の型は「分数クラス」のスーパークラスである「数値」クラス。
それぞれのメソッドの戻り値は、約分できる値ならできる限り約分された結果をかえす。

割り算など、divide()メソッド内では、
約分などの正規化で割り切れる値以外は実際には割らない。
内部ではあくまで分数で値を保持する。

たとえば、ある分数クラスの二つのオブジェクト(x, y)の中身が a/b、Y c/d　であるとき、

数値 x = new 分数(a, b); z = x.divide(y) と計算すると
Z.get分母()で得た値は b * c
Z.get分子()で得た値は a * d となる。

また、数値を文字列表現で返すtoString()メソッドを定義する。
このメソッド内で割り算のアルゴリズムが発動し、
小数点の文字列表現を返す。

>>100
浮動小数点の扱えるシステムを繋ぐ

どうしてスレタイに誰もつっこんでないんだよー。
浮動小数じゃなくて浮動小数点数だろー。

a = x/y + z / w

となる式でaを使った式を計算するとき、どうしても誤差を最小限にしたいとき

自動的に ( x * w + y * z ) y * w と通分してくれるフレームワークが欲しい。

b = x / y;
c = b * y;
という式があったとき、とんでもない誤差を減らすために自動的にyを消去し、
c = x と代入してくれるフレームワークが欲しい。

>>104
なるほどー。なかなかいいね。
加減算でも内部で乗除算が発生するところが少々アレだが。

>107
前者は、データ長を超えないためにわざとそう書く場合も有るから難しいね。
後者は、アルゴリズムを練る時点で解消されている事を祈る。

マジレスすると大きな数はどう表現する？
通分して足し算してると、あっという間に整数型で表現できなくなる。
BigNum使うと、Rationalライブラリになるけど。

>>107
そのくらいだったらコンパイラが対応してない？
……いや、根拠も何もないけどさ。

時計チェック

>>111
念のために言っておくと、そんなことする商用コンパイラは無いよ。
（世界の果てにはあるかもしれないけど。）
あえて切り捨て演算を行いたい場合もあるし。

>>108
あらかじめ通分しとけばいいんじゃない？
ある程度は減るんじゃないかと。

>>107
> b = x / y;
> c = b * y;
> という式があったとき、とんでもない誤差を減らすために自動的にyを消去し、
> c = x と代入してくれるフレームワークが欲しい。

x と y がどっちも 0.0 だったら、ｃ はどうあってほしい？
>>91
でも読んで考えてみてくれ。
y が無限大だった場合もワケワカメなことになりそうだ。

>>114
そうか。104と107にはそういう関連が有ったのか。納得。
速度はさておき。
内部では倍長で扱えば、破綻の無いシステムになりそう。

スマンが最も自分が得意とするJavaで差せてもらいますわい
これまた思いつきですわい

>>110
Javaの java.lang.BigInteger のように配列で値を保持するか.
文字列で値を保持するか...

BigIntegerは10進で最大20憶桁ほど扱えるらしい。
が、桁数が大きくなればなるほどとんでもない計算量になりそうだ。


>>115

そういうときはNaNが発生したとき(Double.isNaN(x)がtrueのとき)
その場で

throw new ArithmeticException(); .....
都合に合わせてtry-catchで料理。

>>104
>
> long型で返すget分母(), get分子()メソッドを定義する。
これもtoString()のようにString()で返すか
java.lang.BigIntegerで返すんだった。longは御法度。

>>117
分子／分母の形式で表現されたその数を10進数で表示／印刷するには
どうすればいいですか？

数式処理システム使えば？
mathematica, maple など

>>119
一番単純なのはこんなやつ。
とりあえず分子、分母の型はこう変更しておこう。
import java.math.BigInteger;も忘れずにつける。

　private BigInteger 分子;
　private BigInteger 分母;

　String show(){
　　return this.分子.toString() + " / " + this.分母.toString();
　}

ほんとうはtoString()の仕様をこうすべきかな。
で、以前に定義したtoString()の仕様はこれにし、
名前もtoBigDecimalに変更しよう。

　BigDecimal toBigDecimal(int scale, int roundingMode){
　　return new BigDecimal(分子).divide(new BigDecimal(分母), scale, roundingMode);　　
　}

>>119
よくみたら勘違いしていた。
上で定義したtoBigDecimal()を使って

数値 x = new 分数(BigInteger.valueOf(2), BigInteger.valueOf(3))

System.out.println(
　x.toBigDecimal(1000, BigDecimal.ROUND_HALF_EVEN).toString()
);

多分、0.666666666666666... (6が千個)
という文字列が返ってくるだろう。

こんなメソッドを定義してもいいが無理して作らなくていいかもしれない。
public String dividedValue(int scale, int roundingMode){
　return toBigDecimal(scale, roundingMode).toString();
}

このスレは有理数(分数)クラスを語るスレとなりました。
>100
からずいぶん遠いところまで来てしまったな。

ところでπや三角関数などの無理数はどうやってあらわす？
この勢いで無限級数クラスまで突き進んでくれ。

※ 物理屋がオブジェクト指向に出会うと、たいがい複素数クラスとか考えるよな。

>>123
> ところでπや三角関数などの無理数はどうやってあらわす？
> この勢いで無限級数クラスまで突き進んでくれ。
パイには多倍長型対応arctan()などを作るのだよ。

コンストラクタに桁数、機械epsilonなどの精度を指定するのだ。

> ※ 物理屋がオブジェクト指向に出会うと、たいがい複素数クラスとか考えるよな。

もちろん複素数クラス、行列クラス、数値積分クラス、数値微分クラスくらいは
すでに他の言語で存在してる。しかしオブジェクト指向に弱いライブラリの巣窟。

いまひとつ理解できてないんだけど、
無理数は有理数に近似するしか無いんじゃないの？

あ、無限級数クラスか・・・失礼しました。

無知ついでに言わせてもらうと、
他人の作ったクラスをソースを見ずに使う勇気はありますか？

私はドキュメントの付いた古風な関数の方が安心できるなあ。

無理数は近似でかまわんが、1/3を正確に記述出来るのはいいな。＜分数クラス

>>127
プログラムが多くの人によって実際に使われ、テストされれば
ソースを水に使う気になれる。

そうでなくともJUnitでテストプログラムを使ってテストされている
ものならまあ使う気にもなれる。

最初はまずどんなものはテストするものだが。

>>125
無理数は、平方根クラスや、指数クラスで代用できるかも。

public abstract class 無理数 extends 数値 {
}

public final class 平方根 extends 無理数 {
　private BigInteger value;
　/** この部分は private 数値 value; のほうが拡張性が高いかも。

　public 平方根(BigInteger valuie){
　　this.value = value;
　}

　public BigDecimal toBigDecimal(int scale, int roundingMode, BigDecimal eps){
　　return sqrt(scale, roundingMode, eps, new BigDecimal(value));
　}

　private BigDecimal sqrt(int scale, int roundingMode, BigDecimal eps, BigDecimal value){
　　//多倍長平方根のアルゴリズムここに実装
　　//奥村晴彦の「C言語による最新アルゴリズム辞典」
　　//「Javaによるアルゴリズム辞典」でなんとか作れるでしょ。
　}
}

無理数の定義(一部)はこれでどうよ

//分数クラスを再定義し有理数クラスを作成
public class 有理数 extends 数値 {}
public class 分数 extends 有理数 {}

public final class 指数関数 extends 無理数 {
　private 有理数 base; //基数部
　private 有理数 exponent; //指数部

　public 指数関数(有理数 base, 有理数 exponent){
　　this.value = value;
　}

　public BigDecimal toBigDecimal(int scale, int roundingMode, BigDecimal eps){
　　return sqrt(scale, roundingMode, eps,
　　　base.toBigDecimal(), exponent.toBigDecimal() );
　}

　private BigDecimal exp(int scale, int roundingMode, BigDecimal eps,
　　　BigDecimal base, BigDecimal exponent){
　　//多倍長指数関数のアルゴリズムここに実装
　}
}

車輪の再発明もいいけどさ。
ttp://boost.cppll.jp/HEAD/libs/rational/

http://boost.cppll.jp/HEAD/libs/rational/rational.html#Exceptions
>有理数クラスでは、分母がゼロとなることは決してない。（本ライブラリ
>では、NaN や無限大の表現形式としても、分母がゼロになることはない）
>そのため、分母の値が０となる場合には、boost::bad_rational 例外
>（これは、std::domain_error のサブクラスである）をスルーする。

スルーするって変じゃない？
スローじゃないの？
コールスロー

java で定番のRationalクラスってある？
ttp://www.google.com/search?hl=ja&ie=UTF-8&oe=UTF-8&q=java+%22class+Rational%22

>>134
そこからみてみたんだがオブジェクト指向としてはひどいものばかりだ。
アルゴリズムとしてはかなりのものだとは思うが。

http://www.math.technion.ac.il/~rl/java/kaleido/Rational.html
これはメソッドが全て無意味にpackage private担っているところが
痛すぎる。

http://www.daimi.au.dk/dSoegOpt/java/dSoegOpt/Real.html
これはオブジェクトのカプセル化がなされていなさ過ぎる。
インスタンスフィールドをpublicにするなんてひどすぎる。
privateをつけてgetterメソッドをつけるべきなのに、この仕様は
あまりにも危険すぎる。これは設計者がC言語で構造体を使いこ
なしていた名残なのか？

clone()メソッドもオーバーライドされていない。
Cloneableインターフェース、Comparableインターフェースが実装されていない。

greater()やless()なんというメソッドが用意されているのが気になる。
compareTo()メソッドがあれは必要性がないと思うだがちょっとした利便性の
ためにわざわざ作ったのか？

しかもRationalクラスに不変性が保たれていない。
クラスがfinal宣言されていない。setter機能が禁止されていない(フィールドがpublic)。

Java 使いが多そうなんで オブジェクト指向寄りの話題を振ってみるが、
有理数クラスの hashCode() はどう実装したもんでしょうかねぇ。
やはり戻り値は (分子).hashCode() ^ (分母).hashCode() なんてとこでしょうか。
でも 1/3 と 2/6 の hashCode() はどちらも同じ戻り値を返したい気もする。

>>136
オブジェクト指向とはいえこれはオブジェクト指向とは別の異なる知識が
必要そうだ。ソースコードを拝見してみたが不覚にも修行が足りず解読中。

Object
　public native int hashCode();

Boolean
　public int hashCode() {
　　return value ? 1231 : 1237;
　}

String
　public int hashCode() {
　　int h = hash;
　　if (h == 0) {
　　　int off = offset;
　　　char val[] = value;
　　　int len = count;

　　　for (int i = 0; i < len; i++) {
　　　　h = 31*h + val[off++];
　　　}
　　　hash = h;
　　}
　　return h;
　}

Character
　public int hashCode() {
　　return (int)value;
　}

Byte
　public int hashCode() {
　　return (int)value;
　}

Short
　public int hashCode() {
　　return (int)value;
　}

Integer
　public int hashCode() {
　　return value;
　}

Long
　public int hashCode() {
　　return (int)(value ^ (value >>> 32));
　}

Float
　public int hashCode() {
　　return floatToIntBits(value);
　}

Double
　public int hashCode() {
　　long bits = doubleToLongBits(value);
　　return (int)(bits ^ (bits >>> 32));
　}

BigInteger
　public int hashCode() {
　　int hashCode = 0;

　　for (int i=0; i<mag.length; i++)
　　　hashCode = (int)(31*hashCode + (mag[i] & LONG_MASK));

　　return hashCode * signum;
　}

BigDecimal
　public int hashCode() {
　　return 31*intVal.hashCode() + scale;
　}

//Object, Boolean, Character, String, Byte, Short, Integer,
//Long, Float, Double, BigInteger のhashcode()を見てみたがほとんどさっぱり。
BigDecimal

>>136
どうせ「既約にする」というメソッドが必要になるから
内部でそれを呼んで既約にした結果に対して
適当にごにょごにょすればいいんちゃうん

hashcode()はequals()メソッドやclone()メソッド、compareTo()メソッドの
オーバーライドで精一杯です。


http://www.gimlay.org/~javafaq/S038.html#S038-05
よんでhashcode()のことをしらべているけど20億種類もの範囲を超える
オブジェクトのパターンをhashcodeで表現するにはどうすればいい？

BigIntegerだけでも、10の20乗種類もの数値パターンを作れてしまうような。
ていうか、漏れがhashcode()の取り扱いに詳しくないだけ？

上のサイト見てると、hashcode()は検索を早くするためだけにあるような。

ん？　よく見たら
オブジェクト o と p について、o.equals(p) ならば、
o.hashCode() == p.hashCode() でなければなりません。

逆に、o.hashCode() == p.hashCode()
であっても、o.equals(p)とは限りません。

と書いてあった。String型#hashcode()を参考にして作れと？

>>141
HashはHashTableのためだけにあるんちゃうのか？

>>143
> >>141
> HashはHashTableのためだけにあるんちゃうのか？

そのサイトによると
>ハッシュコードはオブジェクトの検索を高速に行うために使われます。

ということらしいよ。

あまりこのハッシュを使った凝ったプログラミングに時間を費やすことは避けたい。

>>144
お前アホだろ。

>ハッシュコードはオブジェクトの検索を高速に行うために使われます。

に書いてある意味もわかってないようだし、

>オブジェクト o と p について、o.equals(p) ならば、
>o.hashCode() == p.hashCode() でなければなりません。
>
>逆に、o.hashCode() == p.hashCode()
>であっても、o.equals(p)とは限りません。

の意味もわかってないようだし。そもそも Hashtable, HashMap とは何かもわかってないみたいだし。

単純にhashcodeの時だけ約分すやいい話じゃないの？

hash値の一意性さえ保っておけばいいんだから、
方針次第では約分する必要もない。

equalにも影響あるのか
約分と通分の結果はキャッシュしとくとか。

>>136
> でも 1/3 と 2/6 の hashCode() はどちらも同じ戻り値を返したい気もする。
あらかじめ約分されてから代入されることを考慮するなら
2/6も1/3に変わってその問題もどうにか解決すると思われ。

そういや1より大きな数のとりあつかいについてぜんぜん考えてなかった。

約分すると整数になる場合はn/1
でいいんじゃん？

　　　 (⌒V⌒)
　　　│ ＾ ＾ │＜これからも僕を応援して下さいね（＾＾）。
　　⊂|　　　　|つ
　　　（＿）（＿）　　　　　　　　　　　　　　　　　　　　　　山崎パン

おｗａｒｉ？

いきなり初歩的な質問なんですが、IEEEの浮動小数点形式って、
「ゼロ」に符号があるみたいなんですけど、これって使い分けというか、
両方とも使う必要があるんでしょうか？

それとも、結果的に２つできてしまっただけで、通常は片方を使う
のでしょうか？

http://homepage.mac.com/maki170001/

あぼーん

1 / +0 => +∞
1 / -0 => -∞

>>145
いやわかってるとも。
それよりHashTableやHashMapはよくつかってるしServletでも使ってるし。
それよりもハッシュを理解してもハッシュ関数のことをよく理解していなかったことは確か。

ひとまず、コンストラクタを生成した時点で約分を開始し、
約分した値は全て最小絶対値となるようにし

hashcode()は分子、分母を割った結果のBigDecimal型のhashcodeをとるということで。

public int hashcode(){
　new BigDecimal(分子).divide(
　　new BigDecimal(分母),
　　　Integer.MAX_VALUE,
　　　BigDecimal.ROUND_HALF_EVEN
　　).hashcode();
}

しかしこれはInteger.MAX_VALUEが重たいな。

>>158
未だに効果的なハッシュ関数というものについては全然わかってないみたいだな。

>>157
おお、なるほど！　そういう特別な場合のための意味づけなんですか・・・

通常の数だけを扱う場合は、プラスゼロだけにまとめてしまっても大丈夫？

BigIntegerで最も大きな素数の組み合わせでできた分数をhashCode()に
変換する方法を考えないといけないぞう。約分できる分数は無視。

でかい数は約分するだけでも一苦労。
BigIntegerの最大値の素数の平方を求め、そこから約分できるかどうかを判定する。
とんでもない時間がかかりそうだわい。

約分できるかどうかなんて
当然ユークリッドの互除法を使ってやると思うけど。
そもそも、有理数を分子・分母の組で表す場合、
ユークリッドの互除法使って常に規約にしない?

すこしスレタイ寄りの話題に戻すか。
>>100
>浮動小数点が扱えない（整数型のみ）システムで、
>浮動小数点を計算したい場合はどうやるのでつか？

パフォーマンスを無視すれば、厨学生でもIEEE規格の加減乗除ぐらい
アセンブラの整数命令程度の道具で作れるでしょ。乗算が一番簡単だったりしてね。
MIDP でケータイアプリなんか作ってるとこはこの辺どうしてるのかねぇ。

この辺のライブラリを仕事で作ったことのあるプログラマはいる？
やはり十年前のバグ付きペンティアムみたいに、巨大なテーブル引いて
高速除算したりするのかしら。

残りの超越関数は ttp://www.ibiblio.org/pub/packages/development/libraries/ の
fdlibm のソースとか役に立つでしょう。JDK もこれ使ってるらしい。

>>162
しかし、巨大な素数がある場合、それが計算速度の弊害になるて。
巨大な素数を求めるだけでも時間がかかる。
あらかじめ素数リストをtable lookupしてしまえばいいのだが。

>>164
ユークリッドの互除法についてわかってないなら発言しない方がいいよ。

オブジェクト指向上、上のように「有理数」が「数値」を継承するって、どうよ？
いや、数学的に、集合的に、正論だってことは解るけどさ、
ただ Java で java.lang.Number をインプリメントしたいだけっていうんなら文句はないけどさ、
なんかね、「円」が「楕円」を継承しているような気味悪さがあるのよ。

※ 他にも「指数関数」が「無理数」を継承するとかあったけど、これは見なかったことにしよう。

>>165
ハゲ！　貴様がわかっていないのだろうが！

>>165
お前はユークリッドの互除法を使う前の段階の素数を短時間で求める方法を
わかってないみたいだからそれ以上発言しないほうがいいよ。

俺の知ってるユークリッドの互除法は素数を必要としないのだが、
お前の知っているユークリッドの互除法とは別物らしい。
説明してもらえないか。

>>169
生意気な。
素数を使わずに順次にインクリメントしてやっていられるかっての。
高速化を考えろっての

何だ釣りか。
黙ってろ、ちんかす。

>>169はループを21億回転させるつもりらしい。

hashCodeも考える必要なし

では二人にそれぞれの方法で分数
798 / 5005
を既約化することを命ず。
決着が付かなければ数学版でプリーズ。

>>170,172
http://www2.cc.niigata-u.ac.jp/~takeuchi/tbasic/BackGround/Euclid.html
釣られてみた

もしかして、ユークリッドの互除法と、エラトステネスのふるいを
混同している人がいたりするのではあるまいか？

>>172
知らないことがらについて、発言してはいかんよ。たぶん、あなたは激しく
間違っている。

ただ今スレ違いな方向に進行中

素数を使って高速化するユークリッドの互除法って、
いったいどういう方法なんだろう？

>>167,168,170
アホばっかりでワラタ

5005 ÷ 798 = 6 あまり 217
798 ÷ 217 = 3 あまり 147
217 ÷ 147 = 1 あまり 70
147 ÷ 70 = 2 あまり 7
70 ÷ 7 = 10 あまり 0

よって 798 / 5005 = 114 / 715

でてこい＞ちんかす

ねえねえ、素数を使うとどこが高速化されるの？

>>183
強いていえば、2つの数のうちどちらかが素数だったときに
割り算をいくらか省略できる可能性があるくらいかな。

やはり167,168,170,172は真性の...

>>184
実のところ、メモリ上に置かれた素数のテーブルを毎回検索する時間のほうが、
CPU内部で完結する整数の割り算より桁外れに時間がかかりそうな気がする。

で、エラトステネスのふるいと混同しているのかなと思ったけど、そもそも、
素数の表を作るのがエラトステネスのふるいの目的なので、現在作成中の
表を見れば、次のループの増分とすべき素数は見つかるから、たぶん
これと混同したわけでもなさそう・・・　はて？

結局、おそらくは、素因数分解をしようということなんだろうけど、約分は、
最大公約数を見つければいいのであって、素因数分解までする必要はない。

素因数分解は桁数が多いと確かに大仕事だけど、最大公約数を見つけるのは、
それに比べて極めて簡単だ、というのがユークリッドの互除法の「威力」
なんですけどね。　なんだかな。

>>185
御意。

というわけで話は>>162に戻ると。

有理数より先に、整数を極めるのが得策。

hashCode()は分子分母のGCMで決定

hashは
分子.gcm(分母) % (BigIntegerの最大素数)

>>166
これでどう
class 数
class 実数 extends 数
class 複素数 extends 数

class 有理数 extends 実数
class 無理数 extends 実数

>>190
数学的に考えると、実数は複素数を継承すべきかな？
でも複素数は実数の集約になるんだよな。C++でこんな循環宣言できる？

数学者に集合と継承の違いを説明できるプログラマ求む。

>>188,189
1/2 と 5/10 の hashCode が違う
5/10 と 5/15 の hashCode が同じ
だがそれでいいのか？

分子/gcm(分子, 分母) ^ 分母/gcm(分子, 分母) あたりだろ。

maximaのソースとか参考になるんじゃない？
hashは知らんけど。

>>192
> >>188,189
> 1/2 と 5/10 の hashCode が違う
に関してだけ一言。
有理数クラスに不変性を持たせる
(
　●setterメソッドといったコンストラクタ以外でオブジェクトを変更できる
　 メソッドを使用禁止にする。
　●クラス継承を禁止にする。
　●フィールドを全てprivateにする
)
ことを前提として、
5/10はコンストラクタで宣言できるが
実際には存在しない。コンストラクタを呼び出した時点で
約分が開始され約分された値が常にフィールドに入る。


ということで1/2と5/10との違いを意識する必要はなかれ

>>191
C++でもJavaでもオブジェクト指向言語であれば
デザインパターンを使ってどうにかなりそうな気がする。

Compositeパターンはどうだろう？

「FOMA4機種、電卓で再度のバグ」
ttp://headlines.yahoo.co.jp/hl?a=20030820-00000024-zdn-sci

どうすれば複数メーカーでこんな阿呆なバグを作りこめて、検査を通過できるのか、
誰か説明してくれよ。想像つかねーよ。
症状が妙に10進数に依存してるので、固定小数っぽい気もするが。
やっぱ固定小数はダメダメだな。

>>192
なんで排他的論理和をとる？

^だったらBigIntegerではxor()メソッドで
分子.divide(分子.gcm(分母)).xor(分母.divide(分子.gcm(分母)))

>>197
排他的論理和がいやなら

最大公約数 = gcm(分子, 分母)
分子' = 分子/最大公約数
分母' = 分母/最大公約数

のとき 分子'*適当な素数1 + 分母'*適当な素数2 なんかでもいいよ。
ただ素数の取り方によってはハッシュコードがばらけないので注意。

>>198
'を使っているプログラミング言語は？

ML

0.333333.....
とかを、1/3（近似値）に直す方法ある？

それだけだと仕様が曖昧すぎて何ともいえんが。

0.33333333333 は 1/3 に直すが 0.3333333331 は 3333333331/10000000000
になって構わないの？

いや、そう言われると、よくわからないです・・・

連分数展開を使って近似分数を求めればいい。細かい理論は省略。
どこまで細かいのを採用するかは近似精度を最初に与えてやればいい。

0.3333333331 = 1/(3+7/3333333331) = 1/(3+1/(476190475+1/(1+1/6)))
476190475 が十分大きいのでそれ以降を無視して 1/3。

コンストラクタがある少数文字列を循環小数として認識し
どの桁からどの桁までを循環部分にするかを指定して
有理数オブジェクトを生成しよう。

内容が浮動小数から離れているので
多少関係ある事を書くと、

浮動小数点数の基本的知識が要るなら、まず
パターソン&ヘネシー「コンピュータの構成と設計(上)」
の関係するところを読むのが良いと思う。

>>206
しかし数値計算が専門の人の中にも
この本に書いてあるレベルの知識(IEEEのフォーマットとか)
が全くない人が結構いる罠。

非正規数を使った計算をたくさんこなしたい私は、
いったいどんなCPUを買えばいいのでしょう。
Itanium って、正規数と同じぐらい非正規数も速い？

>>208
デノーマルを出しまくって悩んでいたやつがいたなぁ　計算は続行してくれるけど。

そもそも非正規化数をたくさん使うってどういうこと？

通分と約分って何？

確かに整数演算と組み合わせる場合に非正規数を使いたくなるんだよな

>>203
http://www.sci.toyama-u.ac.jp/~iwao/Scheme/r5rsj/html/r5rsj.html
にある rationalize という手続きの仕様を参考にすれば良いのでは

Java の標準数学クラス java.lang.Math の説明にある
「半単調」(semi-monotonic)ってなによ？

理論的に

f(x1) ＜ f(x2)

な関係にある関数 ｆ と x1, x2 があった場合、
相当する java.lang.Math メソッドの戻り値は必ず

Math.f(x1) ≦ Math.f(x2)

を満たすって理解でいい？

文系の漏れに固定小数と浮動小数のちがい、使いみち、メリット、デメリットを
出来るだけやさしく教えてくらさい

いやでしゅ

文系が免罪符だと思ったら大間違いだ！

文系の人はBCDを使って下さい。

>>214

固定小数
　-バカ
　-ごくつぶし
　-見たことしか理解できない
　-十本指の生き物しか相手にしてくれない

浮動小数
　-世間知らず
　-夢はでかいが、大したことしない
　-常識の通じない尼がたまにでしゃばる

> f(x1) ＜ f(x2)
は
f(x1)≦f(x2)
だよね。

>>219
イコールが増えたそのココロは？

　・f(x1) ＜ f(x2) ならば Math.f(x1) ≦ Math.f(x2) でなければならない

この辺までは解ります。
x1 と x2 が接近すれば、いつかそんな時もあるでしょう。

もしかして

　・f(x1) ＝ f(x2) ならば Math.f(x1) ＝ Math.f(x2) でなければならない

も必要？それとも

　・f(x1) ＝ f(x2) ならば Math.f(x1) ＜ Math.f(x2)

もアリ？

>>30
486-SXにはFPU無いが何か？

>>221
自分で387エミュレータ書け。

ていうか、x86系の32bit OSには大概FPUエミュレーションが付いてる様な気がする。

i486SXにもFPUはあるぞ
無効にされてるがな（笑

でもってi487がi486DXそのもので
挿すとメインCPU乗っ取るわけだ

文系は用済の時代

文系、理系とくだらん区別分けしてるのは日本だけ。出来る奴はそんな枠に囚われない。

>>225
胴衣

しかし「理系ですか?」という質問に
「いいえ文系です」と答える奴は逝ってよし。
そういう奴は具体的数字に触ろうとせず
非論理的なことを平気で行い
「私は文系ですから」を免罪符にして正当化する。

そもそも「理系ですか?」という質問する奴が逝ってよしだろ（ｗ

>>223
あたり！

ひどい売り方だった（笑）

セレロン商法は既に出来上がってたんだな・・・

>>214
文型でも経済学部だったら理系同等だろ？
経済学部の香具師は時系列の勉強もしていることからなぜか
信号処理までしっている香具師が多いぞ。

>>213
> 相当する java.lang.Math メソッドの戻り値は必ず
java.lang.Mathはメソッドではなくクラス。
> Math.f(x1) ≦ Math.f(x2)
Java Core APIに標準パッケージとして入っている
java.lang.Mathクラスにこんな f() というstaticメソッドは存在しない。

揚げ足はｶｴﾚ

揚げ足取り + age
？

ども。IntelのCPUとAMDのCPUで、浮動小数演算の結果って変わるん？

>>234
SSE2 と 3DNow! の拡張倍精度って、それぞれ何bitだったっけ？

>>223
イスラエル（中東）の商人らしいやり方だな
家畜の値段があわなければ足を切って売るとか

今でも、同じダイで生産してキャッシュ半分殺して安く売ったり

インテルなんてM$と同じで昔からせこいことやってきたんだから。

インサイド・インテルという本読んでみいよ。
元Intelの社員がインテルの悪徳商法を暴露した本だから
そういうのを知りたい香具師にはお勧めだよ。

>>237
そんなことには興味ないし

お前だけのために答えてやってんじゃねえよ

>>237
誰もそんなことは尋ねていない

我儘な餓鬼は黙れ

クロックもそうだな

Intel の内幕に詳しいのなら、スレタイに従って
IEEE754 制定時に Intel がさんざんゴネた経緯の裏事情をプリーズ。
後は浮動小数バグペンティアム騒動とか。

>>220
Therefore, methods with more than 0.5 ulp errors are required to be semi-monotonic:
whenever the mathematical function is non-decreasing, so is the floating-point
approximation, likewise, whenever the mathematical function is non-increasing,
so is the floating-point approximation.

だからイコールが必要。

>>244
おお、サンクス。なんか英語と日本語で微妙に中身が違うような気が。
で、f(x1) ＝ f(x2)は非増加かつ非減少なので、
Math.f(x1) と Math.f(x2) 間も同様に非増加かつ非減少を満たさねばならないため、
Math.f(x1) ＝ Math.f(x2)は常に満たされるということでいいのかな。

>>237
スレ違いで誰も聞いてないのに
自慢気に雑学披露してるあたりがネタですか？

>>245

おい、その
Math.f(x1) ＝ Math.f(x2)
という勘違い表現いい加減にやめろ。
Java記法の常識も数学記法の常識を知らないのか？

それとも、俺的Mathクラスを自作したのか。

package net.2ch.www.俺的パッケージ.俺的Mathライブラリ;
public class Math {

　//コンストラクタはアク禁にする。
　private Math(){}

　public static double f(doule x){
　　//関数の実装;
　}
}

別のパッケージからあれを呼ぶ。
package net.2ch.www.俺的パッケージ.俺的MathライブラリDemo;

import net.2ch.www.俺的パッケージ.俺的Mathライブラリ;

public class MathDemo {
　pulic static void main(String[] args){
　　if( Math.f(3.0d) == Math.f(3.0d)){
　　　System.out.println("同じ")
　　}

　　double x = 2,
　　　　　　 y;

　　//標準に存在するMathクラスを使用するときは重複しているMathクラスとの
　　//混同を避けるためわざわざjava.lang.Mathと記述する。
　　y = java.lang.Math.sin(java.lang.Math.PI * java.lang.Math.pow(x, 2));

　}
}

だが関数を自作するときはこうすべきだろ

public abtract class Function {
　public abstract double f(double x);

}

自作Functionクラスを使って適当に関数を作る

public 俺用Function extends Function {
　public double f(doube x){
　　return Math.cos(x) + Math.cos(2 * x) + Math.pow(x * x) * Math.tan(x);
　}
}

使用方法

public class FunctionDemo {
　public sitatic void main(String[] args){
　　int size = 2000000;
　　double[] a = new double[size];
　　Function function = new 俺用Function();
　　double d = -10.0d;
　　for(int i = 0; i < a.length; a++){
　　　d += 0.00001d;
　　　a[i] = function.f(d);
　　}
　}
}

とにかく、f(x)とかけばすむものをMath.f(x)とかくのは余計というかアフォくさいということ

>>251
実装毎の Math.hoge() の返す値についての話をしてるんだよ。
準単調関数についてはある実装で Math.f(x) < Math.f<y) ならば、
他の実装でも Math.f(x) <= Math.f<y) だよね、とか。
ついてこれないなら黙って他方がいいよ。

痛い>>251がいるスレはここですか？

>>1
PIC S9(5)V9(2)
なんてのが好きなのか？

>>229
8086と8088
などインテルの伝統。

>>237
モトローラはもっとえげつない。

>>247
>おい、その
>Math.f(x1) ＝ Math.f(x2)
>という勘違い表現いい加減にやめろ。

あー、すまんすまん。
Math.f(x1) の部分が Java の式で、
全角イコールは数学でいうところの等号だ。
f はイタリックと思って薄目で見てくれ。数学関数名を適当にあてはめればよし。
ところで全角イコールを何だと思ったのかな？C++なら代入もアリか.....

>>248
>>249

Javaの名前空間の話はスレ違い。
java.lang.StrictMath と比べた java.lang.Math の答えのひどさの性質に関する
お話でつ。ひどいなりに色々頑張ってるらしいのよ。

>>250

ぷっ。

>>252

「半単調」や「準単調」でググってもろくにヒットしないのですが、
どっち方面の用語なのでしょう。信号？

>>252 もよく分かってなさそうだよね。

>>256=251

>>257
各実装毎の相違など議論していないのだが、理解できないか？

ここで議論されてるのは、理論値と実装の話。
なので 252 も 251 同様のアホ。




って漏れが252なんだけどさ。

>>258=256=251

>>259=252

>>42
あります。

"Floating Point Computation"
Pat H. Sterbenz
Prentice-Hall, INC
1974

が、もう20年以上好評絶版中。

ちなみにKnuthのThe Art of Computer Programmingの
日本語版なら第4分冊準数値算法の浮動小数点算術演算の章に
浮動小数点算術演算アルゴリズムの基本的なことは大体書かれています。
実際に実装するとなると大事なことが幾つか抜けてますが。

あとユーザー的に知っておくべきことをまとめた文章としては

What Every Computer Scientist Should Know About Floating-Point Arithmetic
David Goldberg
ACM Computing Surveys, Vol.23, No.1, March, 1991

（有名なんだけど、どっかで日本語になってないのかな？これ。）

>>140
まぁ、演算が終わるごとに約分しとくのが無難かと。
BigIntegerのときに演算ごと正規化（互除法による約分）をサボっても
分子分母の整数の計算で桁数増えるから多分結局計算遅くなるしね。

あと面白い表現として有限精度の有理数による近似ってことでFloating Slash Numberってのもあるですよ。
11/256, 111/23ってな感じで有理数の分母と分子の桁数合計が一定になるように丸める奴。
分数の"/"が浮動するから浮動スラッシュ。

"Finite Precision Rational Arithmetic: Slash Number System"
David W. Matula and Peter Kornerup
IEEE Transactions on Computers Vol. C-34, No.1 Jan. 1985

>>163
BigIntegerを使った多重精度浮動小数点数なら作りました。
四則演算もさることながら基数変換が死にそうにシンドかったです。

研究集会で発表した際に例題のπの計算で途中の桁から先間違ってて
間違いを指摘されたのが恥ずかしかったことよ。
（たぶん丸めのバグ。）

>>191
AXIOMという数式処理システムの型の構造が参考になろうかと。
数だけじゃなくて抽象表現である群とか環とか体とかから導き出してあります。

型は単なる値の集合じゃなくて
演算による値の集合の要素間の対応関係もコミだから代数系と考えられます。
そのように型を代数系と思うと継承（包含）は部分代数系でなければならないといえます。

で、複素数は集約でテンプレートで作っておくのが実際的かと。
ポリモルフィズムは継承じゃなくて型変換と多重定義で実現しておくと。
（どうせ実装が継承できるわけではないし。）
まぁ、STLばりにアルゴリズムが対象の数学的性質から自動選択されるようにするなら
抽象的な群、環、体などから継承しとけばいいかと。
（親子じゃなくて兄弟にしとくわけね。）

>>264
正確に言うと

親の型に対応する代数系A、子の型に対応する代数系Bとして
BはAの部分代数系ということです。

代数系は台集合（まぁいわゆる値の集合）と
その上で閉じた演算の集合で表現されます。
「その上で閉じてる」というのは台集合上で演算した結果はが台集合に含まれるということです。
部分代数系の場合、部分代数系も台集合が親の台集合の部分集合で、
かつ「親」の演算がその部分代数系の台集合について閉じている必要があります。

実数rと複素数r+0.0*iという自然な対応がありますから
何らかのポリモルフィズムが期待されます。
実際複素数の集合に実数の集合は完全に含まれていて
実数の加減乗除といった基本演算は
複素数上で行っても実数の範囲で閉じてますから
確かに継承で表現できる可能性はあります。

ただ、実装の継承が開発効率上･実行効率上意味がないので
（まぁベクトル値からスカラー値を継承するようなもんだし）
ムリに継承でこのポリモルフィズムを実現するのはあまり実用的ではありません。
なので型変換と演算子、関数の多重定義で実現しておくのが無難であるわけです。
（Javaにはどっちもないのが残念ですが。）

>>250
C++のような（）演算子の多重定義があれば完璧な関数オブジェクトだったのに！ｗ
使うその場でnewするより関数ポインタの代わりに他所へ渡せるところが醍醐味。

関数オブジェクトといえば余談：

double samples[] = new double[N];
//....samples[]をサンプル値で初期化。
Function f = FFT(samples, N);
//...
y=f(x)//フーリエ級数による補間。

とかいうインターフェースができますねというのは十年前のMy修論ｗ。

16bit浮動少数点数クラスを作りたいんだけどよくわかんねぇ・・・

16bitって仮数何桁・・・

>>267
IEEE単精度や倍精度の指数部：仮数桁数の比が
[8:24] だったり [11:53] なのは何か根拠があるんだっけ？
16bitかあ。なんとなーくだけど[6:10]ぐらいじゃない？

※ フォーマット上、仮数桁の整数部が略せるのはいうまでもなし。

>>269
「仮数桁」って何？
お前の辞書にしか載ってない用語使われても誰も理解できんだろ

>>270
仮数部(小数部)の整数を表す桁と言いたかったんじゃないの？
小数部が0.1{1|0}*となるように正規化してあれば最上位の0は省略できるって話でわ？

>>265
> ただ、実装の継承が開発効率上･実行効率上意味がないので
> （まぁベクトル値からスカラー値を継承するようなもんだし）
> ムリに継承でこのポリモルフィズムを実現するのはあまり実用的ではありません。
> なので型変換と演算子、関数の多重定義で実現しておくのが無難であるわけです。
> （Javaにはどっちもないのが残念ですが。）
んなこたあない。メソッドのオーバーロード、オーバーライドがあるだろうが。
なに嘘を公表してるんだお前は。

>>255
> >>247
> >おい、その
> >Math.f(x1) ＝ Math.f(x2)
> >という勘違い表現いい加減にやめろ。
>
> あー、すまんすまん。
> Math.f(x1) の部分が Java の式で、
Javaの式だと？ JavaのMathクラスにhoge()なんてメソッドもf()というメソッドもないんだよタコ。
それとも>>248のように独自にMathクラスを定義したと仮定して話を進めているつもりか。
人に誤解を生むような糞表記はやめろ。
事前に説明しろ。おまえは Javaコード内でMath.f(x1)とかけばコンパイルが通ると勘違いしているみたいだからな。

> 全角イコールは数学でいうところの等号だ。
> f はイタリックと思って薄目で見てくれ。数学関数名を適当にあてはめればよし。
> ところで全角イコールを何だと思ったのかな？C++なら代入もアリか.....

おい、そうじゃない。話を飲み込めない馬鹿め。

Math.f(x1)というお前の表記はどこの仕様の表示法なのかきいとるんだよ。
それともお前の独自仕様の「オレ仕様表記法」か？

おまえ、頭悪いな。

>>272
数式書くのに関数の多重定義や演算子オーバーロードが無くて残念だよね、って話じゃないの。
暗示的な型変換（実数→複素数のような)もあると便利だよね、とか。

この板も強制ID制にして欲しいなあ。

>>275
> >>272
> 数式書くのに関数の多重定義や演算子オーバーロードが無くて残念だよね、って話じゃないの。
おまえ本当にJavaを知っているのかと。
メソッド(関数)のオーバーロード(多重定義)ならJavaにもあるんだが。

演算子のオーバーロードは独りよがりなコードが乱立しコードの可読性を下げスパゲティ化するから糞。

> 暗示的な型変換（実数→複素数のような)もあると便利だよね、とか。
甘いな。それではオブジェクト指向言語としての利点が失われる。
そんな馬鹿機能を使いたければPerlやMATLABでもつかっていろと。

せいぜいこれくらい程度にしておけ。
public Complex extends Number
これで複素数クラスとDoubleクラスはNumberクラスを共通のスーパークラスとして
楽に管理できる。

こっこれがJava厨と言うものか！

Smalltalk厨でも同じこというぞ

>>272
Ｊａｖａにユーザー定義型変換演算子と、ユーザによる演算子多重定義があるなら使ってみたいもんだ。

>>276
> 演算子のオーバーロードは独りよがりなコードが乱立しコードの可読性を下げスパゲティ化するから糞。

それはo1+o2やo1-o2をo1.add(o2)やo1.sub(o2)と書くにしたって同じこと。
例えば、メソッドの多重定義、オーバーライドしかないＪａｖａ世界でも
clone()とかprint()とかtoString()に妙な意味をつけるとかすれば
演算子の多重定義はないにも関わらず同様の問題は起こる。

つまり可読性の問題は他の慣習や名前の直感的意味と整合しない
妙な意味の演算子を定義することそのものが悪いんで、
演算子多重定義機能そのものが悪いんじゃないということ。

で、それとは別に、
演算子多重定義機能を取り入れた際の言語仕様・パーザーの肥大化・複雑化と
その機能の（Ｊａｖａの予想適用分野での）有用性を天秤にかけて
Ｊａｖａには入れないと判断した
Ｊａｖａの仕様策定者達の判断はそれはそれで一つの選択であるとは私もおもうが。

>>275
そういう意味です。

まぁ言えばオブジェクトやクラスのメソッドはあっても
そもそもトップレベルの「関数」だってＪａｖａにはないわけでｗ。
（「ない」ことが即ち「いけない」とは言ってないです。念のため。>>276）

>>276
> public Complex extends Number
> これで複素数クラスとDoubleクラスはNumberクラスを共通のスーパークラスとして
> 楽に管理できる。

実は実数は複素数の部分代数系になってますが、
逆は成り立たないので、兄弟のような対等の関係では有りません。
一応、暗黙の型変換や継承による直接の先祖･子孫関係なら
その辺の「方向付け」は表現できます。

中でも暗黙の型変換ならば実数の集約により複素数を表現するという
ポピュラーな実装戦略との相性も悪くありません。

一方、継承で表現しようとする場合は
子孫である実数クラスで実装される演算を利用して
先祖である複素数クラスを実装することになるか、
複素数クラスの中に複素数クラス特有のコードに加えて
実数クラスに必要なコードがすべて含まれるという少々ナニな構成になってしまいます。
こんな構成にするくらいなら無理に関連付けず
いっそ各々独立のクラスにして利用関係でだけ関連付けられているほうがマシでしょう。

というように両者には実装の共有があんまりないので、多相の機能的な本質は
演算子多重定義と型強制（暗黙の型変換）による
コード自動選択機能で片付いてしまうのです。

しかしJavaの場合は演算子多重定義も暗黙のユーザー定義型変換もないので、
どっちもメソッドでやることになるでしょう。
（a.add(b)とか(new Complex(d))とか言ったノリで。）
こうなってしまうと特に独立のクラスとして作成する以上に
何かできることはないわけで。
（無理に継承で表現しても上記の通りだし。継承兄弟にする意味もないし…。）

>>276
Javaの場合ComplexがＮｕｍｂｅｒを拡張してもイマイチな気がします。
Numberは別に「体」などの数学的構造を表現してるというわけでもなく
単に組み込みの数型のラッパー・クラスに共通な親クラスという以上の意味はないようです。
（どうせメソッドもintValue(),longValue(),floatValue(),doubleValue()くらいしかありませんし。）
例えば、無理に継承したところで、
複素数クラスのdoubleValue()とかナニ返したら役に立つん？実部？虚部？絶対値？
…という話もあるわけです。

さらに言うと、複素数を「実数」に基づいて表現するにしても
実数の表現手段（近似手段）には、

>>1にも上がっている固定小数点数、
　･･････整数演算ベースで高速だが、小数点の管理が面倒、
　　　　　事前に計算される数の範囲を把握しておかねばならない
ポピュラーな（単精度、倍精度）浮動小数点数、
　･･････固定小数点数より機構が複雑だが利用しやすく、
　　　　　近年では専用ハードが普及し、
　　　　　プロセッサによっては整数演算と競えるほど高速化している
数式処理世界ではポピュラーな任意多倍精度整数に基づく多倍精度有理数、
　･･････丸め誤差がないが、必要に応じて大きな記憶領域を食い、
　　　　　計算時間が定数とは看做せない。その上に遅い
任意多倍精度整数に基づく多倍精度浮動小数点数、
　･･････丸め誤差は必要なだけ小さくでき、計算時間が定数で抑えられるが、
　　　　　必要に応じて大きな記憶領域を食い、やっぱり遅い
有限精度有理数（floating slash）
　･･････（ゴメン性質まではまだ調べてません。）

などのバリエーションがあって状況に応じて使い分けたくなったりします。

こうなるとテンプレートによる総称化（C++の場合）か
抽象クラス・インターフェースによる制約つき総称化（Javaの場合）が
欲しくなって来ます。
どのみち単純なNumberの継承ではおっつかなくなってきます。

>>276
> 甘いな。それではオブジェクト指向言語としての利点が失われる。

「白い猫も黒い猫も鼠を取るのが良い猫だ。（by �ｹ小平）」
……つまりオブジェクト指向であろうがなかろうが役に立つのが良いパラダイムw。

さて、暗黙のユーザー定義型変換や演算子多重定義などの
ユーザー定義の「ad hocなポリモルフィズム」があると失われる
「オブジェクト指向言語としての利点（by >>276）」って一体何だろー？w

> そんな馬鹿機能を使いたければPerlやMATLABでもつかっていろと。

まぁ、C++ってのもあるわけだが。

加えて、ぶっちゃけて言えばユーザー定義こそできない限定的なものではあるが
暗黙の型変換と演算子多重定義の仕組み自身は
Javaでも備えてるわけなのであるがｗ。
（整数や浮動小数点数の混合演算における「昇格」とか
整数加算の＋と浮動小数点数加算の＋、そしてString連結の＋の多重定義とか。）

>>278
>Smalltalk厨でも同じこというぞ
Smalltalk って型変換オペレータなんてのは言語の性格上もちろんないけど、
operator + とかみたいな中置１項セレクタは普通にユーザが定義できなかったっけ？

>>1はCOBOLer

>>266
> >>250
> C++のような（）演算子の多重定義があれば完璧な関数オブジェクトだったのに！ｗ
> 使うその場でnewするより関数ポインタの代わりに他所へ渡せるところが醍醐味。
>
> Function f = FFT(samples, N);
> y=f(x)//フーリエ級数による補間。

こんな機能いらん。そんな使い方はオブジェクト指向の敵。
ソースコードを汚す行為は許されないことだ。
Function fft = new FFT();
y = fft.f(x);
に書き直せ

FFTクラスの実装例は実際にはこうだ。

//StrategyパターンでFFTのアルゴリズムを選定すること。

class FFT extends ComplexVectorFunction{
　private FFTAlgorithm　fftAlgorithm;
　public FFT(FFTAlgorithm algorithm){
　　this.fftAlgorithm = fftAlgorithm;
　}
　public ComplexVector f(ComplexVector vector){
　　//FFT実装
　}
}

関数をオブジェクトに出来ないJavaは糞

Class hoge = Class.forName("Hoge");
Method method = hoge.getMethod("createHoge",null); // ※1
Hoge createdHoge = method.invoke(hoge.newInstance(),null);

※1 関数オブジェクトありますよー

>>285

過ぎたるは及ばざるが如し

>>288
なんでオブジェクト指向の敵なのかちゃんと説明してけろ。
ソースコードを汚すって何スカ？

私の例はサンプル列で初期化される
1引数関数オブジェクトに過ぎんと思うのだがｗ。
（正確には関数オブジェクトとして利用可能なフーリエ級数オブジェクト）
C++では構築子を暗黙の変換にも使えるが、
この場合それでも意味には違和感はないように思う。
（構築子の処理が重いことの是非はともかく。）

ちなみに当時（約10年前）はまだパターンすら話題になってなかったんで
その例には入ってないが、
今作ってるヤツはテンプレート・メタ・プログラミングを使って
各種のFFTアルゴリズムを静的に展開できるようにもする予定。
でそれらについて一回コンパイルして自動プロファイリングもやって
環境と指定された要素数Nに合わせてアルゴリズムの組み合わせを選び、
最適なFFTルーチンの構成を作り出せるテンプレート群を生成する。
以降生成したテンプレートがデフォルトで利用されるので
結局トップレベルでは要素数指定だけで
一々アルゴリズム指定はしない使い方も可能になる予定ｗ。

なんとか今年中に動かしたいｗ。
何せその後でそれを多倍精度整数乗算に使う予定だから。

>>292
で、何が過ぎててどう及んでないと？
独りよがりなこと言ってないでちゃんと解説しる。

ま、Java設計者の選択は分からないこともないので>>290には同意しないが、
>>291のメソッド・オブジェクトはリフレクション的な意味合いの話なんで
ここまで話に出てきてる部品としての関数オブジェクトとは大分趣旨が違うような…。

>>293
> >>288
> なんでオブジェクト指向の敵なのかちゃんと説明してけろ。
> ソースコードを汚すって何スカ？

ちなみにオブジェクト指向云々じゃなくって

仕様・パーサーの肥大化・複雑化のコスト　vs.　機能の有用性の度合い

でトレードオフを考えた結果JavaとC++で異なる設計上の選択がなされた
という話なら私も納得できるんだが。

その結果として私もJavaとC++を必要に応じて使い分けてるわけだが。

JavaはC++よりコード量が多いからequals()を==にかえたほうがいいと
ほざく馬鹿はJakarta Velocityを使って目を覚ませ。

>>292
　つまりC++はJavaの如し
ということか

なんかキモイのが常厨してるよ

>>296
Javaは純粋なオブジェクト指向だからｲｲ（・∀・）!!とか
ほざくバカはSTLを使って開眼しろ。

IT業界にアージャイル開発とデザインパターンを広めよう！

C言語を使ってかなり苦労したので
その苦労を最小限におさえるために
アージャイル開発、デザインパターンを
多くのプログラマに使って欲しいと思うことがある。

一種の挨拶みたいなものだね。
「なるべく挨拶を心がけましょう。」
「なるべき綺麗な字で書きましょう。」
のように

デザインパターンを使うこと、アージャイル開発することが
プログラマの習慣、常識になってほしい。

なんとか、デザインパターン文化、アージャイル開発文化を押し広げられたら・・・。

IT業界の将来はオブジェクト指向とアージャイル開発が握っています！

>>300
コピペなん？

288君の回答ﾏﾀﾞｰ？（ＡＡ略

EclipseのCDTはﾏﾀﾞｰだよ

>>299
全然>>296と関係のないこといってるし。噛み合ってないね。
STLがどうしたって。

JavaがSmalltalkのような純粋なオブジェクト指向だと思ってないだろうし
STL利用可能だからC++でオブジェクト指向を理解しやすいとはおもってないだろうなあ。

C++に勝るJavaの利点は例外処理やエラー処理の厳しさに尽きる！
STLだけでは同等のことをやるにも限度がある！

Javaの話は専用スレでやってくれ。

IEEE754 を閲覧できるところ誰か知りません？
今は亡き富士通のコンピュータサロンみたいなとこ、もう無いのかなぁ。

>>306
規格書はもちろん有料 http://www.ieee.org/ から買える

ただし、良質のレクチャーノートが以下のURLにある
http://grouper.ieee.org/groups/754/

>>304メル欄見れ。　…というのはともかく。

代わりにJavaではGenerativeスタイルはできないからなｗ。

ま、どっちも究極や終着駅ではないのだから一長一短があるのさ。

マジレスすると、科学技術計算に浮動小数点は必須。

浮動小数点は誤差があるので学術的に使うことは有り得ない

普通はBCD

釣られクマー

BCDは理想的でも 実際には処理が遅いからあまり使わない

BCDが理想的って、どこ見ていってんの？

Re:>>310 もともと有効数字の少ないデータを扱う場合は、誤差は関係ないのでは？

×もともと有効数字の少ないデータを扱う場合は、誤差は関係ないのでは
○科学技術計算では必要な桁数だけ計算するもの

BCDだって3で割ったり平方根とったりすれば誤差が出る。
本質は10進表示かそうじゃないかってことだけだ。
10進表示された小数をかけ算する場合に桁落ちを発生させないための
ものであって、それ以上の演算で誤差がないなんて、誰も保証していない。
誰が10進表示された小数を使うかっていうのは、金利計算する金融屋だ。
科学屋が10進表示にこだわる理由はどこにもない。

>>310
科学技術計算ライブラリのメーカーをなめとるなワレ。

十進コンピュータ最強

>>316
BCDは、有効桁数の範囲なら誤差が出ないってことなんじゃない?

>>319
浮動小数点形式と比べて良いという理由になりますか？

>>320
なるだろ。
ベストじゃないがベター

通貨型ってやつ？

>>321
その根拠は？ x=x/3 して x=x*3 した場合にどちらが1に近いと予想しますか？

次に x=x/8 して x=x*8の場合は？

BCDと固定小数をごっちゃにしてないか？

BCDは固定少数表現の一種ですが何か？

>>323
両方誤差が出ます。1にはなりません。この点では同じです。

それではこのような例ではどうでしょうか？
> http://www.geocities.co.jp/SiliconValley/4334/unibon/javascript/decimalcalculate.html
> 0.01 + 0.05 = 0.060000000000000005
> 0.01 + 0.06 = 0.06999999999999999

この例では浮動少数では誤差が出ますが、
固定少数では誤差は出ません。

比較するときに同じようにだめな結果を持ってきても意味がありません。
違う点を見ましょう。その結果固定少数のほうがベターなのです。

>>326
残念ながらお答えは正しくありません。
一般的な浮動小数点方式では1/8 して8倍しても正しく元に戻ります。
もちろん1/10して10倍しても誤差が出ない表現方法もあります。

そして、 0.01 + 0.06　は、固定小数点でも、少数以下を10の倍数に取った時には
誤差なく表現出来ますが、一般の2進固定少数表現では誤差が出ます。

そして、一般の科学技術計算では、10の倍数に取ろうが、２の倍数だろうが、誤差に
ついては同じです。

足し算ごときで誤差が出るのか。
浮動少数は使えないなｗ

>>326
> 一般的な浮動小数点方式では1/8 して8倍しても正しく元に戻ります。
> もちろん1/10して10倍しても誤差が出ない表現方法もあります。
それはたまたま元に戻る場合があるってだけ。
この例が固定少数でどうなるかを考えると…同じく元に戻るんだな。

比較するときに同じ結果になるものを持ってきても無駄だってｗ
固定少数は完璧じゃないんだから問題あるし、
浮動少数は欠点けじゃないんだから問題ない場合もあるだろ。
違いを比べてみるとやっぱり固定少数のほうがベターなんだよ。

どうでもいいが、「固定小数点」ってのは小数点以下の有効桁数が
常に一定であるってことを言うのであって、
基数が10なのか2なのかってのとは全く別の話だと理解してくれよ。

なんとも何をおっしゃりたいのかよく判らん。　　それは普通は議論の対象になりません。

少数以下の有効桁数が固定なら、2乗して平方しただけで大きく誤差を増やしてしまう。

まあ、比較が好きならお好きになさい。

>>331
比較が嫌いなら最初っからこのスレに書き込まないことです。
貴方のためです。その方が傷つかずにすみますよ。

>>325
違うよ。>>330が正解。

＞浮動小数点は誤差があるので学術的に使うことは有り得ない
＞普通はBCD

＞BCDは理想的でも 実際には処理が遅いからあまり使わない

＞BCDは、有効桁数の範囲なら誤差が出ないってことなんじゃない?

バカというか、突っ込まれて、とち狂ってるとしか思えんが、いちおう言っとこう。

もっと勉強しる！

>>334
釣りか？

皆が言ってるように、どんな表現方法だろうがビット数以上の精度は出ない。
有効桁数の範囲なら誤差が出ないなんて事はありえない。

金利計算で誤差が出ないなんてのも迷信。
1%複利で100年 利子が幾らになるか誤差無く計算出来るのに何桁必要だと思うんだ？

表現可能な範囲内で表現可能な誤差に収まるというだけの事。

ここでひとつトリビア

x86のFPUは




BCDも浮動小数点で計算している。

分数で処理しる

>>338
有理数の間はうまくいくだろうがな

数式処理の話になりそうだ。

>>336
1%複利で100年後の利息は、「元本*1.01^100 - 元本」で計算できる。
1.01^100 の正確な値は、
　2.70481382942152609...9510001 (数字が201個並ぶ)
である。一方、1.01^100 を double で計算すると、
　2.704813829421529
であり、小数第14位まで一致している。つまり、30京円ぐらい
までなら、誤差なく計算するのに15桁必要である。

>>329
＞この例が固定少数でどうなるかを考えると…同じく元に戻るんだな。
戻らないよ。

10進型で考えると
固定少数
　少数以下3桁を覚えていて 現在 1.234 という数があるとする。
　1/10すれば 0.123 で 10倍すれば 1.230 で 0.004を失う。

浮動少数　
　4桁を覚えていて 1234E-3
　1/10すれば 1234E-4
　10倍すれば 1234E-3　情報は失わない。


科学技術計算は足し算だけじゃないんだよ。
そして科学技術計算では、精度をコントロールしなければならない。　
BCDでは殆ど無理。

だからBCDと固定小数は違うんだってば。

なんか BCD を勘違いしているみたい
BCD っていうのは

0.56
= 0000 . 0101 0110

のような表現
固定小数か浮動小数かは関係ない

BCDとpacked BCDは区別しなくてもいいのか？

このスレでは区別する必要はないように思うけど、何か問題ある？

>>344
それはつまり自分ひとりBCD浮動少数型の話をしていたという意味か？

xxxxxxxxx * 10^ aaaaa

>>347 >>344ではないけど
＞そして科学技術計算では、精度をコントロールしなければならない。　
＞BCDでは殆ど無理。
という結論他、固定小数型の特徴をBCDの特徴としてる香具師が多いという話。

>>348
つまり、俺は、浮動少数型BCDを発明したって言いたい訳だな？

>>349
別に俺は発明してないけど、存在はするし、使ったこともあるよ。

>>350
では質問。

　A * B^ C

という表現方法のどこをBCDにしたのですか？

>>351
BCD * 10 ^ C
じゃないの？

>>351
Aは確実。普通に考えればBは10で固定だから内部にはいらないよね。Cは記憶にない。
8bit機のBASICだったから内部表現までは覚えてない。すまんね。

>>352-353
それだと、BCDである事の意味がないんだよ。

B=10として Aが整数で C が整数であれば A,Cの表現がBCDだろうが整数だろうが数学的には意味がない。
技術的には、AがBCDであれば、　x10 1/10する処理が楽というだけ

>>354
長桁計算で最終的な結果を１０進数で出力する場合、出力が楽になるという利点がある

>>355
それは、数学的な意味じゃないし、そもそもの発端である 科学技術計算にBCDとも関係ない話

>>356
パフォーマンスも数学的には関係ないよね

人間が手計算をするときは10進で行う。
コンピュータで計算させるときも10進で行えば、誤差を含めて手計算と結果が一致する。
この辺が金融系でBCDが使われる理由なのかな。

誤差を無くしたいなら実数ライブラリ(浮動小数点数ではない)でも用意するしかないか

>>355
１０進変換の負荷が重要になるなんてのは、せいぜい加減算しかやってないからだろう。
掛け算が入ると、計算負荷はBCDがの方が何桁も大きくなる。
せめて100進、万進だな。

>>358
それもよくある誤解だね。

浮動小数点でも、あらかじめ1万倍して計算するとすれば、1/1万まで手計算したのと完全に一致する。

>>359
それも BCD だが…？

C言語でBCD計算ってどうやってするですか？

>>361
2進化100進　なら　Binary　Coded Centimal ？


　

>>362
10進数は効率悪いから 8bitで100進 16bitで万進を使う事が多いよ。

>>364
M 進数加算 A=B+C

int cy=0;
for(i=0;i<n;i++) {
　cy+=B[i]+C[i];
　A[i] = cy % M;
　cy/=M;
};

負数は表現方法が色々あるけど、M-1の補数が楽だよ。

で、トータルでは、8bitで100進数が掛け算が楽でいいよ。

Intel IA-32 には18桁のBCD演算命令があるけど使わないですか？

>>354
BCDの浮動小数表現について知ってることを書いただけだから数学的に
意味があるかどうかはこの際どうでもいいよ。まあ、当時は0.1を10回足すと
きっちり1になるというのが特徴だったけどね。

俺が言いたいのはBCDが固定小数に包含される概念ではないということを
わかってほしいだけ。

>>366
FPUの演算命令は浮動小数点と同一。
メモリ上のBCDデータはST(0)レジスタに読み込まれた時点で
自動的に80ビットの浮動小数点に変換される。

AX/ALレジスタの演算結果をBCDに補正する命令もあったけど
これの32bit拡張版は無かったんだっけ？

>>368
80bit 浮動小数点数って仮数部は何ビットあるの？

仮数部64、指数部15、符号1 ＞FPUレジスタ

暗算最強

BCD浮動小数点方式は処理速度と有効数字に難がある。

今俺はDSPのコードを書いている。
廉い固定小数点だ。

シフト、位置合わせて、またシフト。　ああ・・・・・・

>>373
タイガー手廻計算機を思い出すな・・・

えーと、実装経験者に質問なんですけど。IEEE754 に従って
正確な直近丸めモードで単精度演算を行った結果が
正規数の最大値(≒ 3.4028235e+38f)だったとします。
さて、丸める前の「真の値」が、この正規数の最大値より
大きい値だった可能性はあるでしょうか。

※　フツーの正規数なら、各々の値の相対誤差範囲内で
　　大きい場合も小さい場合もあるよね。

実装経験者なんているのか？
俺予想としては「ある」だけどな

IEEE754とだけ伝えるより、
仮数**bit・指数**bitと言った方が、
面白い答えがいっぱい返ってくると思われ

おそレスですまんが、
>>336
>皆が言ってるように、どんな表現方法だろうがビット数以上の精度は出ない。
たとえば、分数を扱う処置系で、{1,3}==1/3 だと、0.333333333333・・・
を「正確に」表現出来るわけだが、このへんはどうなの？

実数と有理数の違いぐらい覚えとけ

>>378
精度というのはそういう意味じゃないよ。

その処理系では sin(x) も求めないし、√x も求めないの？

一桁ずつ十進数で保持＆筆算法式で計算
しておけば何桁の計算だろうが誤差なんて出ないよ

はいはい
一生√2計算しといてくれ

【誤差】　真の値との差
【精度】　精密さの度合。誤差の大きさで表現する。

>>378
　8bit/8bitの分数で表現したとして 1/1024をどう表現出来ますか？
　分数でも、精度はそのビット数以上には出ないのです

>>381
　10進数かどうかに関係なく、無限ビットを扱うなら、誤差は出ませんね　

浮動小数とは、波間に漂うように小数の値が固定さず変動していることからついた名前だ。
つまりある意味乱数のようなものだな…。
乱数を発生させるには浮動小数は便利だが、科学技術計算には向かない。
値の信頼性がまったくないからね…

浮動少数表現は　対数表現と固定少数表現の良いとこ取り。

ダイナミックレンジが広く、掛け算が計算し易いのは対数表現並
整数の表現能力は固定少数表現並

>>384
無茶苦茶やな。

Re:>>384 ネタにしても酷すぎるぞ。

マジレスすると、科学技術計算の必要精度はせいぜい3〜4桁
ぐらいじゃないのか？通常の使用においては。

論文に書く時は精一杯精度を確保するだろうが。

>>388
君の国の「科学技術」というのは学校教育だけを指す言葉かな

結果に求められる精度が3〜4桁である場合、最低でもその2倍程度の精度が無いと。
例えば、自乗和を取る時など、簡単に桁落ちしてしまう。
統計では差の差を用いる事も多いしね。

>>390
誤差を最小にする演算は科学技術計算では既に確立している
わけだが。

>391
桁を落ち「にくく」するだけであって、3〜4桁の精度の計算で、
3〜4桁の精度の結果が得られるわけでは無いだろう？

>>390
>結果に求められる精度が3〜4桁である場合、最低でもその2倍程度の精度が無いと。

これ本気で言ってる？浮動小数点の演算方法知ってる？浮動小数点
における「有効桁数」というのは上位から何桁が正しいかを表している
のであって、演算時に必要な精度は元の数値の精度で十分。

例えば二乗が２倍の精度が必要なら、その論法で行くと３乗は３倍
の精度が必要なのか？平方根を取る時は半分の精度でいいのか？

あなたの言っている事は多分「精度」ではなく「丸め誤差」に関する
事だと思います。あまりにも大きさが異なる２数の加減算で問題に
なる事です。乗算、除算ではあまり問題となりません。

まあ、いいんだけどね。

>393
乗算でも計算結果の方が誤差範囲は広がるぞ。

例えば誤差範囲±5%の数字 a, b を掛けるとき、最悪の場合で
真の値より5%多い値が a, b に収まってるわけだけど
そのとき a * b の計算結果は真の値の 11.03% になる。

確率誤差範囲だとしても同様。

>394
真の値より 11.03% 大きい(ずれた)値になる。

>>394
まだ言ってるのか。
「有効桁数」と「誤差範囲」は全く意味する所が違うんだが。
数学の「信頼度」の事を言っているのか？統計という言葉が
たくさん出てくるのは。

http://pc2.2ch.net/test/read.cgi/tech/1076610073/

>>393
>390で、「自乗和」とか、「差の差」と言ってるのは無視か？

>393
精度・有効桁数と丸め誤差・桁落ちが関係無いと？
まるっきり無知では無いようだが、
コミュニケーション能力に問題有りか？

>>398>>399
無視してないだろ。加減算の際の丸め誤差や積み残しは
２数の大きさが違いすぎる時に問題になると>>393でちゃんと
書いてるだろ。君の目は節穴か？

IEEE754の規格書をしっかり読んだ事があるのか？英語が
読めない？じゃあJIS規格でも読んどけ。

それでは聞くが、4桁の精度が求められる場合、
自乗和の差を計算するには何桁の内部精度が必要かね？

２数の大きさが違いすぎる時は考慮しなくて良いが、
4桁の内で違うのは、「違いすぎる」とは呼ばない。
念のため。

「自乗和の差を計算する」って、いったい何を計算したいの？
式で出してみ

質問に質問で答えるのはよくないな。
まあいいか。
自乗和ってのは知ってるよな？分散とか標準偏差で使うあれだ。
つまり、上で言ってるのは、分散の比較だ。

つうか、IEEE754を知ってるなら、例えば64bitの数の演算には
64bit以上の精度が必要なのは知ってても良さそうなものだが。

>>401
必要な内部精度は5桁でしょう。最後の桁は丸めに使用する。
要するにn桁の精度が必要ならばn+1桁の内部精度があれば
よいのであって、最小桁にしか誤差が混入しないと数学では
考える。

それと機械イプシロンの問題は全く別だが。例えば1E100に1
を足しても16桁精度があったとして1は全く無視される。

>>403
ちなみに>>402さんは俺じゃないよ。

だんだん見えてきた。
>>393=400氏は、IEEE754に準拠したライブラリやFPUの「ユーザ」としての発言かな。
ブラックボックスとして使うのが普通で、内部処理を知る必要は無いな。
ビジネスソフト板ならいいんだが、プログラム技術板では叩かれるよ。

>>406
というかさ、単なる「浮動小数」では議論も何もできないでしょ。
今はIEEE754を例に取ったけど、全く別のフォーマットでも
話の本質は同じだと思う。

もしIEEE754が叩かれるなら、一般的な浮動小数点として話
を進めればいい。その代わりかなり話題は狭くなるよ。

例えばIBM方式では2進数ではなくて16進数で計算する。
その分処理速度は速くなるが、有効桁数がIEEEに比べて
4ビットほど短くなり、さらに倍精度の際の指数部が8ビット
で固定されているなど、問題もある。確かにオーバーフロー
は起こしにくいが。

なるほど。
指数・仮数の配分の好みは人それぞれだね。

精度を追求するなら>>1の言うように指数無し多倍長だし。

>>409
浮動小数点という表現形式は現実的なコンピュータのハードウェア
の制約の中で、数学的な有効桁数を保ちつつ計算ができるように
考えられた形式だからね。

常にデータ型の消費スペースが一定という性質が寄与するものは
大きい。浮動小数点型の配列が容易に作れる事の有り難みを知ら
ない人が意外と多い。

それはそれで置いといて、多倍長計算もこれまた面白いね。UBASIC
を触った人は結構いると思う。速度や効率は度外視して純粋に有効
桁数だけが必要な場合このような言語が非常に役立つ。

UBASIC32バージョンを作ってほしいなあ。今ならもっと高速で
多大な有効桁数を持つBASICなど容易に作れるはず。

今ではJavaやMathematicaがあるからその必要はないのかも
しれないが。

＞浮動小数点型の配列が容易に作れる事の有り難みを知らない人が意外と多い。


ジャグ配列なら各要素のデータ長など関係なし

メモリ消費量も関係なし

というより、関知せず　か。

イノセンスそれは…


猪木

猪センス

プロデューサが勝手につけたんだよな

分度器を見ろ。
同じ直角なのに、無理数(π/2)radでも、自然数(180°)でも、
表現できてるぞ！

浮動小数が、有理数や無理数や一部の十進数を
有限桁で表現できないなんて、別にど〜ってことない話なんだよ。
しょせんどこかで人間同士の都合やエゴがぶつかったまでの話。

このレスからは人間抜きで計算科学を語ろうぜ！
さらば人間！ようこそ計算機！

2を見ろ。
同じ2なのに、無理数(2^√2)でも、自然数(2)でも、
表現できてるぞ！

浮動小数が、有理数や無理数や一部の十進数を
有限桁で表現できないなんて、別にど〜ってことない話なんだよ。
しょせんどこかで人間同士の都合やエゴがぶつかったまでの話。

このレスからは人間抜きで計算科学を語ろうぜ！
さらば人間！ようこそ計算機！

> 同じ2なのに、無理数(2^√2)でも、自然数(2)でも、
すいません 2^√2 はどうみても 2 にならない気がするんですが。

√2^2だろ

それ以前に直角が180度って
誰かつっこんでやれよ...

>>420

√2^2 は無理数じゃないだろ

420 名前：デフォルトの名無しさん[sage] 投稿日：04/03/23(火) 22:57
√2^2だろ

421 名前：デフォルトの名無しさん[sage] 投稿日：04/03/24(水) 12:23
それ以前に直角が180度って
誰かつっこんでやれよ...


422 名前：デフォルトの名無しさん[sage] 投稿日：04/03/24(水) 12:36
>>420

√2^2 は無理数じゃないだろ

423 名前：デフォルトの名無しさん[sage] 投稿日：04/03/25(木) 13:42
引き算は怖いよな。




誤差が一気に増加する恐れがあるから。

424 名前：デフォルトの名無しさん[sage] 投稿日：04/03/25(木) 14:20
引き算で誤差は増えてないでしょ。　有効桁数が減る場合がある＝桁落ちでしょう。

425 名前：デフォルトの名無しさん[sage] 投稿日：04/03/25(木) 15:37
桁落ち=誤差の発生じゃないか？

426 名前：デフォルトの名無しさん[sage] 投稿日：04/03/25(木) 15:52
精度0.01 有効桁３桁の数の引き算 1.01 - 1.00 = 0.01

有効桁は 1桁
精度は0.01で変化していない。

427 名前：デフォルトの名無しさん 投稿日：2004/03/25(木) 19:33
変に64ビットとかで切るから誤差が出るんだろ
すべての桁を十進数で計算すれば問題なし


428 名前：デフォルトの名無しさん 投稿日：2004/03/25(木) 20:35
>>423
非正規数モードにしとけば、
とりあえず異なる数値の差が0になることはありえないよね。


429 名前：デフォルトの名無しさん 投稿日：2004/03/25(木) 20:45

じゃあ　掛け算で誤差はどうなるか判る？

1.01*1.01=1.0201 有効桁は5桁になった？ Yes /No


430 名前：デフォルトの名無しさん 投稿日：2004/03/25(木) 22:27
＞すべての桁を

永久に計算が終わりませーん！

431 名前：デフォルトの名無しさん 投稿日：2004/03/26(金) 09:26
>424
絶対誤差は2倍ですむが、相対誤差は1兆倍とかできるぞ。
で、数値計算の分野ではただ誤差といった場合原則として相対誤差。


432 名前：デフォルトの名無しさん 投稿日：2004/03/26(金) 09:58
言いたい事は
　相対誤差 a% の cos(x) から sin(x)を cos(x)から求めると、このsin(x)は相対誤差a%を確保出来ない
というような事例だろう。

sin(x)=√(1-cos(x)*cos(x))
sin(x)=cos(x-π/2)
でも　引き算が含まれているからね


433 名前：オブジェクト指向促進運動 投稿日：2004/03/26(金) 14:20
三角関数はtangentを連分数展開するのが一番高精度なんだよ
sin, cosもtanだけで計算してだ。



434 名前：デフォルトの名無しさん 投稿日：2004/03/26(金) 14:29
0 <= x <= π/2 で　f(x) = 1-cos(x) を 0.0001% 相対精度で計算しろと言われたら？

今月の日経サイエンスに出てた「クルタ計算機」、かっちょえ〜。
ttp://www.nikkei-bookdirect.com/science/page/magazine/0406/computer.html
これで掛け算もできるってことは、浮動小数なの？

>>426
美しいでつね。
モノツクリできる人は羨ましいな。

×浮動小数
×浮動小数点
○浮動小数点数

全部読んだけど、勝手に誤差がでるとか言ってる奴がいますね。1年前だけど。
なんでそんな誤解が広まってるんだろう。
ある浮動小数点演算と他の浮動小数点演算で結果が異なるのは当たり前とか
言う奴もいるし。結果が異なるのは実数演算と浮動小数点演算だろ!
(丸めモードが違うとかもあるけど)

そういう奴は一回FP演算器を設計すべきだと思います。エミュレータでもいいけど。

浮動小数点数は不動小数点を持つし、
固定小数点数は浮動小数点を持つ　ってワインバーグが嘆いてたな。

そして俺は山のフドウ

Sun 社製の C コンパイラには、浮動小数点演算中にコンテキストスイッチが発生すると丸めモードが変わるコードを吐くオプションがあったと思うが、これは一体何の役に立つんだ？

>429
ある浮動小数点演算と他の浮動小数点演算で結果が異なるのは当たり前
これは当たり前。Intel系は中で80bit演算してたりするから(オプションで制御できるがする奴は少ない)。

>>433
違う計算をして違う答えを出しているだけだろ。
浮動小数点の問題ではない。

できる奴が少ない=誤解が広まっている とも言えるな。

そんなに計算の仕方で結果が変わるのが嫌だったら浮動小数点を使うのを
一切諦めてＢＣＤ演算使え。

>434
違う計算になるのが問題なんだってば。
そりゃ、「同じ計算」したら答えは同じだろうな。「同じ計算」なんだから。ソケ4Pentiumはさらに例外だが。

同じ計算にするのがなかなか容易ではないから、C99とかJavaとか工夫しているわけで。
Fortran は知らない。

IEEE754の全機能をCで普通に扱えたらラクなんだけどな、ホント。
機種ごとにアセンブラで書き直したら「同じ計算」かの検証が大変だ。

>>435
議論の本質がわかってない。

>>436
広く使われている事実上の標準である所のプログラミング言語において、
注意深く使わないと間違うのはよろしくないという主張はひとつの考え方だとは思う。

しかし、このスレの先頭100レス位を読むと、そういうレベルでもないような
誤解があるように見えるが。

お前が読みすぎなだけ

だからBCDだけ使えば良いじゃん

>>440
だからバカが BCD 使うと、ますます結果が変わるんだって。
Java の BigDecimal クラス見てみぃ。丸めモードが８つもあるんだぞ。
こんなのバカ同士で使いこなせるのか？
バカの使う BCD よりはバカの使う IEEE754 の方が害が少ないだろうな。
最強なのは自覚の無いバカが使う BCD だが。

進化したコボラーなんだから、放置しろって

>>どっかのレス
>金利計算で誤差が出ないなんてのも迷信。
>1%複利で100年 利子が幾らになるか誤差無く計算出来るのに何桁必要だと思うんだ？

　BCD なら誤差はでない。なぜなら、およそ現代のほぼ全ての国において金利等の約款は
１０進数を用いて記されていて、BCDならその約款にあるとおりの計算を行うことができるから。
古代エジプトで計算機が発達していたら、60進数をベースにした演算ライブラリが必要だった
だろうけど。

>>136
> 有理数クラスの hashCode() はどう実装したもんでしょうかねぇ。
> やはり戻り値は (分子).hashCode() ^ (分母).hashCode() なんてとこでしょうか。
> でも 1/3 と 2/6 の hashCode() はどちらも同じ戻り値を返したい気もする。

おれだったら分数クラスのhashDode()はJakarta Commons Langを用いてこう実装するぜ。
org.apache.commons.lang.builder.HashCodeBuilder
http://www.jajakarta.org/commons/lang-2.0/ja/withoutPrimary/org/apache/commons/lang/builder/HashCodeBuilder.html

public int hashCode() {
　// you pick a hard-coded, randomly chosen, non-zero, odd number
　// ideally different for each class
　return new HashCodeBuilder(17, 37).
　　append(分母).
　　append(分子).
　　toHashCode();
　}

Jakarta Commons Langを使うんなら、俺だったらこうするな。

public int hashCode(){
　return Fraction.getFraction(分子, 分母).hashCode();
}

>>327
それはどうかな。
1(10)=1(2)とするのが問題で、最小単位を合わせないと、
0.01(10)=0.01(2)と取るのが普通で、1.00(10)=11001.00(2)

>>443
だから、2進でやろうが、10進でやろうが、
有限小数である限り、整数演算に帰着できるから、
加減乗算では、誤差は出ないの。
でも桁シフトで計算量増えるから、このワザは固定小数限定。
逆に言えば、除算や累乗根では、誤差が出るともいえる。
とすると、その部分だけ2進→10進変換して計算し、結果をまた2進に戻せば差はでない。

>>446
>0.01(10)=0.01(2)と取るのが普通で、1.00(10)=11001.00(2)
の意味が判らない。もう少し詳しく説明してくれないか？

>>446の後半

>とすると、その部分だけ2進→10進変換して計算し、結果をまた2進に戻せば差はでない。
それって BCD 演算のことでは・・・・
メモリやDBにまで BCD で入れておく必要はないって主張？

普通に全桁BCDで計算していけば誤差なんて出るはず無いじゃん

>>449
精度が問題なのであって基数の問題ではない。
既出だったはず。

誰かさ、BCD厨が一発で黙るようなテンプレ書いてくれない？
相手するのいいかげんくたびれた。

金融系の人>>449
科学技術計算の人>>450
分かってない人>>451

こんなのでいいか？テンプレ。 >451

Q1. BCDだと誤差出ないよね？
A1. ではBCDで１÷３を計算してみよ。

Q2. IEEE754 が １÷１０ を正確に表せないのはけしからん。
A2. １÷３ を有限桁で表せない10進数もけしからんよね。

Q.3 とにかく浮動小数は誤差が出るって聞いたんだい！
A.3 だからといってBCDに誤差が出ないわけではない。

Q.4 キー！でも浮動小数の誤差の出方はわかりづらいだろ！
A.4 BCDの誤差の出方よりわかりやすいという職業の人もいる。

Q.5 BCDをバカにするな！金融をバカにするかぁ技術者さんよぉ！
A.5 あなたの被害妄想。

続く…

金融では割り算しない限りBCDもちゃんと意味があるって書いておいたら？

金融証券保険等、計算のルール自体が10進数で
決められている場合にはBCD演算を使うのが
シンプルで分かりやすい、ってことだよね。

シンプルで分かりやすいじゃなくて、誤差がない(割り算除く)

IEEE754も誤差出ないよ（演算する場合を除く）

基礎知識

コンピュータの中では、小数値は以下のように表現されています。
　± A × B ^ C　(A,B,Cは整数)
Aは仮数、Bは基数、Cは指数と呼ばれます。

基数には普通 10 または 2 が使われ、数値型ごとに決まった値になっています。
「10進数の 0.1 を正確に表現できない」というのは
基数が 2 である場合に起こる現象です。

指数がある決まった値しかとれないものを「固定小数」、
それぞれ可変の値をとることができるものを「浮動小数」と言います。
ただし、指数が可変というだけでなく、基数が 2 であることも条件に入れて
「(狭義の)浮動小数」と言ったり、IEEE754の規格に沿った数値表現のみを
「(IEEE754)浮動小数」と言うこともあります。

BCDというのは仮数部分の表現方法の一つです。(一応、BCDを指数や基数の表現に
使うこともできるが、普通そういうことはしない。)
BCDの場合は基数には普通 10 が使われますが、BCDでなくても基数が 10 であれば
10進数の 0.1 などを正確に表現できるため、金融計算に用いることができます。

1.BCD は誤差が出ない
2.BCD は「ある規約で取り決められた値」との誤差がでない

この区別をきっちりつけてくれ。

Q6. バーカバーカ！誤差の許されない分野にBCDが使われてるよ！
A6. 本当なの？じゃあBCDを正しく理解できている優秀なSEに感謝しましょう。

Q7. でもでも誤差の許されない分野にBCDが使われてるよ！
A7. しつこいね。BCDを使うと誤差を許さなくなるわけではないよ。

Q8. オーゥワタシ、メソポタミアジンデース。ニポンジン10進スキネー。ナゼ？
A8. 祖先から伝えられてきた日本の美しい伝統だからです。

１÷３が表現できなければ基数を3にすればいいじゃない。

全桁をBCDで保持/演算すれば誤差なんて出るわけ無いじゃん

>>462
メモリ足りないし。計算終わらないし。ｗ

>>462
まずは円周率と自然対数の底を保持する仕組みを考えようかｗ

>>463
そこで遅延評価ですよ。

>>465
ならば 1 / 3 * 3 をメモリを食いつぶさずに遅延評価してくれ。

そこで分数ですよ。

円周率はおよそ3なので無問題です

>>466
何桁目が必要なのか言ってもらえれば書きます。

>>469
この怠け者め

>>469
1 / 3 * 3 の小数第1位は何ですか？

>>471
9

誰か十進数「０．１」を二進数、誤差無しで出して

>>471
0

ラジアン変換にならって、これから円周率πは整数180とすることにしよう。

>>475
2のべき乗分の1は2進表現の浮動小数表現でも指数部のビット数ある限り正確なんで、
円周率を介在させずに1/2π×ｆとしてｆで角度を表すという提案はある。これは360度で4.0になる。
記憶違いでなければその提案に準拠した三角関数がsinhp()などの名前で
IEEEの標準にも追加されたように思う。

実はC++でちょっと工夫すればそれを実現するラジアン型みたいなものが作れて
それを使えばインターフェースは従来どおりのまま
入力xに関するπ倍の誤差を排して周期性が保たれた三角関数が実現できる。

>>378
基数3の浮動小数点表現なら小数部はたったヒトケタで1/(3^n)もバッチリｗ。

ちなみに前にも書いたかもしれないけど浮動スラッシュなる有限精度有理数の体系も提案されてるよ。
分子と分母の桁数合計を一定に保つってやつ。
論文は何年も前から積読状態なので今ここで特徴とか書けないけど。
（実は昔、数式処理システムで有限精度数を扱うという課題に対して利用できるかもしれないと
論文をコピったはいいが結局多倍精度の浮動小数点数を実装することになって放置に…。）

ちょっと脱線だが、C++のテンプレート・メタ・プログラミングを利用して
コンパイル時にdoubleやfloatの計算ができるライブラリを作ってみた。

取り敢えずはコンパイル時計算によるFFTの最適化という自分の研究のために作ったので
今のところ四則演算と整数との変換とsinhp()の計算しかまだ実装してないし、
丸めは直近だけだしNaNとか非正規化数とか実装してないんだが…。
ちゃんと整備したら使う人いそうかな？

>>477
>コンパイル時にdoubleやfloatの計算ができるライブラリを作ってみた。

イメージが湧かねぇ・・・
概略を教えて。

C++のtemplate駆使するとフィボナッチ数列もコンパイル時に評価できるらしいが正直どうでもいいや。
そういや昔Perlでヘッダ出力するスクリプト作ったけどそんなんで十分だな。

>>477
公開キボン。ゲーム屋なんで使うこともあるかもしれん。

>>480
実際に公開するとなると整備しないといけないことはまだまだ多かったりしますが・・・。

・namespaceをちゃんと使う。
・名前の整理（わかりにくい命名を直す。）
・floatをちゃんとテストする（実はdoubleが必要だったのでfloatは雑にしかテストしてない。）
・sin()以外の初等関数の実装。
・丸めモードの実装
・NaNや非正規化数の実装
・g++×Windows×x86環境以外で動かすテストと修正（ポケット・マネーではつらい予感。特にx86以外のプロセッサ。）
・64bit整数型がない環境への対応（多分これがプログラミング作業的には一番面倒）

>>478
template<typename prec, int sign, int exp, typename fraction>
　　struct StaticReal{
　　static const int s = sign;
　　static const int e = exp;
　　typedef fraction f;
};

って感じです。

precは精度を指定するテンプレート・パラメータです。
（doubleとかfloatとかを指定します。）

小数部をあらわすfractionが基本型でなく
typedefになっているのはＩＥＥＥ準拠のdoubleの実装には
64bitを超える結果を返す正確な整数演算が必要だったため、
それもクラス・テンプレートで実装する必要があったからです。

具体的な各浮動小数点数値はこのテンプレートの特殊バージョンとして与えられます。

>>482の続き
計算はa,b,xが上記のように定義されたテンプレートの特殊バージョンを表すtypedef名だとすると。

AddStaticReal<a,b>::result

とか

SinhpStaticReal<x>::result

のように実行します。結果もテンプレートの特殊バージョンのtypedef名です。
なので「値」を変数に覚えておくには

typedef SinhpStaticReal<x>::result r;

のようにします。typedefなんで代入はなしで初期化のみ。

FromStaticReal<r>::get()

とやると対応するdouble型の値が得られます。

>>483
で静的メンバ関数get()を実行するまではどんな「浮動小数点演算」もコンパイラが計算しますから
実行時の立場から見れば単に整数定数だけを含むクラス定義の集まりということになります。
get()はその整数定数から実行時に浮動小数点型doubleやfloatの値を組み立てます。

ちなみにsinhp()は>>476で述べたような多少仕様にヒネリのあるsin()関数です。

cppll のアプロダでも使えば？

>>485
ｃｐｐｌｌって
http://www.freeml.com/ctrl/html/MLInfoForm/[email protected]
のことですか？

「アプロダ使えば？」というのは何の話ですか？

それであっちょるけど、それは cppll の "ML"(本家)。
↓このへんに逝きんしゃい。

[cppll あぷろだ]
ttp://www.cppll.jp/upload
[cppll BBS]
http://jbbs.shitaraba.com/computer/5651/cppll.html

うまくアップロードできんかったら BBS の雑談スレか障害状況スレで相談しなされ。

>>481でも書いたようにいろいろ不備があって辛うじて動くという状態なので
公開するのは恥ずかしいレベルですが：
　ttp://www.nerimadors.or.jp/~kando/FFTemplate/index.html
のRealTemplateが問題のソースです。

3.4e+30とかの大きな数を浮動小数点表現に変換する場合も内部では
2進数（多倍長整数とか）に変換してから仮数部に入るだけの上位桁 + 指数
を求めてるの？

>>489
ベストな答(0.5ulp以内)さえ求められれば必ずしも全桁をわざわざ求めないのが普通と思う。
平気で数ulpずれた答を返す処理系も結構多そうだが…（どっかのscanf()とか）
10進→2進変換の仕様もIEEE754で言及していたはず。

リテラルの二進変換の精度って、昔調べたことがあるけど
誤差0.5ulp以下なんてことは全然なかった
教科書に乗ってるような非常に適当な二進変換ロジックをつかってる模様
ごく最近の処理系は、調べたことないけど

jpgの実用化って、昔調べた事があるけど
展開が10秒未満ってことは全然なかった
展開が非常に重いアルゴリズムを使っている模様
ごく最近の事情は、調べた事が無いけど

>>466
1/3*3と入力すると自動的に通分して1を返すようにすればいい。
これにはオブジェクト指向が必須だ。
Apache Jakarta Connmons Math のFractionクラスのように

浮動小数だってさ(嘲笑激藁

> A1. ではBCDで１÷３を計算してみよ。

BCDで有理数クラスつくりゃ問題ないだろと思ったがｼﾗﾈ（ﾟ�听）

IEEE754の正規数モード時のゼロへのフラッシュって、
正規数の最小値を少しでも下回ったらゼロに丸められるのかな。
それとも正規数最小値の半分を下回ったときかな。

>>495
有理数ごときでBCDなんざ贅沢なんじゃヴォケェ
君程度の人間には整数二つで十分

>>497
boost::rationalもBCDじゃないしね。

hosyu

誰か「おれはこんな凄い計算してるんだぞ」てな自慢でもどうぞ。

float と double の値について標準入力から入力し、
その内部表現を
「符号, n * (2 ^ e)」
という形で表示するプログラムを作って下さい。

>>491
遅レスだけどSchemeやその他いくつかの言語では、
William D. Clinger "How to Read Floating Point Numbers Accurately"
のアルゴリズム(または同等の性能のもの)を使うことになっている。

この論文によると、
IEEE754では変換時の誤差が0.5 unit以下でなくても良い事になっているらしい。

遅レスさんくす
それって、どんな内容ですか？
さわりだけでもお願い

すまん。俺も読んでないのでくわしい事はわからない。
ひろい読みしてみた感じだと、

10進浮動小数点表記の数をそれに一番近い2進浮動小数点数に変換する事は
固定精度の演算だけでは行えない。
でもいつも多バイト整数演算を使って変換するのでは効率が悪いので、
多くの場合では多バイト整数演算を必要とせず
でも必ず最良の値に変換するアルゴリズムを示します。

みたいな内容だと思う。

ちなみに>>502で書いた「同等の性能のもの」というのは、
効率の話ではなく、最良近似値に正しく変換するって事ね。

多バイト整数演算
と
多倍長整数演算
はどうちがうのですか？

>>505
それぞれの定義を書いてくれたら教えてあげる。

>>505
多バイト整数 多倍長整数 bignum
どれもごっちゃに使ってて区別した事ないや。
違いってあるのか。

>>507
多倍長整数が普通じゃない？
多バイト整数って、int32 も多バイトやんか。

http://pc5.2ch.net/test/read.cgi/tech/1101931660/

まあ、数値の計算精度で悩みたくなければ、素直にFORTRANを使えってことでFA?

integer, parameter :: k = selected_real_kind(p=10,r=300)
real(kind=k) :: a

だから〜

BCDで全桁演算/保持すればいいだけでしょ

BCDはおそい&メモリの無駄

浮動少数点表現のパラメータ
仮数桁・基数・切捨ての有無を出力するプログラムって書ける？
もちろん実行環境によって結果が違うように。

浮動少数点表現には規格がある。
実行環境によって結果が違ったらこまるだろ。

float の　精度をはかるのに
float a=1;
float e=1;
while a<>a+e
e=e/2;
end while;

何語かわからん書き方だか
こんなやり方があった

昔の数値演算のライブラリは
このeを基にして、機械ごとの浮動小数点の
精度の差を考慮して書かれていた。

キーワードは　machine epsilon

>514

基数を求めるのは難儀だなぁ。
1 を 3 で割って 3 かけたらまた 1 になるなら、基数は 3 進数か?
でも 6 かもね。

16で割って16掛けたら戻るからといって、基数が2か16かわからんよなぁ

http://www.openexr.com/

16ビット浮動少数なんてのがあるぞー。

>>517-518
そりゃ素因数分解と同じで最小のものを出力すれば医院で内科医？

たとえば、2進と16進の違いを調べようとしたとしても
結局演算では、丸め誤差以外は違わないわけで
丸め誤差の違いで判断するしかない

可能ではあるが、難しい

質問ぬ
float m = -0.00001;
while(1){
printf("%f,0x%08x\n",m,m);
m*=0.01;
Sleep(1000);
}
実行すると
-0.000000と0.00000000 が存在するんだが
16進で見ても両方とも0x00000000 なんだが
どう見分けてるの？

あと、有名な水面演算で、少し触った後、放置してると
急激にCPU食う時があるよ。
浮動小数同士の演算って速度が重くなる演算ってあるの？
この場合の演算は、掛け算と 足し算しかやってません。

-0と+0はビットパターンが違うはずだけど。つーかfloatを%xで読むって
動作の保証があったっけ？

Denormal Numberが出てくると計算が遅くなると思う。物によってはソフト
エミュレーションになったりするし。
InfやNaNは遅くなるかなあ。(×と+ではNaNは出てこないか)

floatを引数にしたら、doubleに格上げされて、
たいがいは8byteになってしまうから、
0x%08xだとその半分しか見ていないことになる。

Infは、無限大
NaNは、ありえなーい (/0)
Denormal Numberって規格外数値？
規格外ってなんだよ
Denormal Numberでググっても54件しか出ないし

doubleに格上げされても
floatの実態は4Byteなんでそ。
謎だ。

(int)*((int*)(&m)) で調べてみたほうがいいのかしら
または、デバッガで目盛り見るの

denormalized number
0に非常に近い数字
精度を落として、指数を確保しているとおもいねえ

おいおい、doubleに格上げされたら、
printfには、どこからどう見てもdoubleにしか見えんのだよ。

とにかく、ビットパターンを見たければ
>>526のようにしろ

ちなみに、-0.0は0x80000000で、+0.0は0x00000000

異なる環境で結果の一意性を保証できない事を「誤差」と表現する人がいるのが混乱する原因か

だれがそう表現した？

保守

>>526

組み込み用のライブラリとかだと
double = float
のこともあるよ（取説に明記してあると思う）。

float型変数の値の容量は処理系依存だろうと推測してみる。
floatを使っているのにやたら精度が良かったりするという話はどれだけ知られているのだろう？

>>535

IEEE754があるから処理系依存にはならないかと思う。

全ての処理系がIEEE754に準拠しているとは限らない。
というかしていない。

1.0　は　3F 80 00 00　だ。

>>538
ＩＥＥＥ754準拠ならそのとおりだが、で？

誰も long double の存在には気づいていないようだな。

REAL(SELECTED_REAL_KIND(30)) の存在には気づいている。

他の板で質問したところ板違いと言われ、ここにたどり着きました。
ここの住人の方々ならとけると思い、質問させていただきます。

問
π = 3.141592･･･ をIEEE単精度表現すると出てくる 32bit のものを
16 進数で表現せよ。

この問題が解けなくて困っています。どなたか出来る方お願いします。

>>542
#include <stdio.h>
#include <math.h>
int main()
{
float a=atan(1)*4;
printf( "%08x\n", *(long*)&a);
return 0;
}

>>543のような手もあるけど、10進表現された小数をIEEE浮動小数点表現に変換する
一般的なアルゴリズムを書くのは結構大変だよ。

toIEEE round_mode sig_bitsize exp_bitsize n = ...?

浮動点小数と言ってしまうのは俺だけですか、そうですか・・

>>543
残念だが atan(1)*4 の時点で 3ulp ほど相対誤差が出るかもな。
Java なら java.lang.Float.floatToRawIntBits( java.lang.Math.PI ) で一発。

>>543
参考になるかしら。
http://kansai2channeler.hp.infoseek.co.jp/cgi-bin/joyful/img/799.c

ちゃんと見てないけどDoubleToFloatで
NaNや+0,-0,+∞,-∞は保存されているのだろうか。

>>546
よく考え直したが atan(1)*4 で精度低下は多分起こらないわ。IEEE ならね。

>>548
面倒だからWindows依存だけど対応してみたわ。
http://kansai2channeler.hp.infoseek.co.jp/cgi-bin/joyful/img/800.c

> x += pow( 0.5, 23 );// 丸め
これでround to nearest evenになってるの？

なってないので直してみたわ。チラシの裏でスマソね。
http://kansai2channeler.hp.infoseek.co.jp/cgi-bin/joyful/img/807.c

なってないから直してみたわ。チラシの裏でスマソね。
http://kansai2channeler.hp.infoseek.co.jp/cgi-bin/joyful/img/807.c

>544の言ってる意味がよくわかった。面倒なんだな。

ちょっと修正。これで電卓でもIEEEが求め(ry
〜/808.c

素晴らしい。ところで非正規化数の処理はok?

今対応したわ。なんか疲れたわ… 〜/809.c

たぶん最後。 〜/810.c

お疲れ〜。プログラム板で珍しい生産的なやりとりでしたね。

質問です
浮動小数点で余り（といって良いのか）を求める良い方法ってないですかね

例えば、2.4 ÷ 1.1 余り0.2

て感じです
いまは割った数を整数変換して元の数から引いてるんですが、
これですと、乗算と除算を使ってしまう上に型変換を2回も行なうので
コストが気になります
もっと他にいい方法がありそうなのですが・・・

ちなみにプログラムで書くとこんな感じ

double a = 2.4;
double b = 1.1;
int c;
double ans;

c = a / b;
ans = a - b * c;

fmodと比べてみて判断したら？

型変換が嫌なら丸めなり切捨てをすればいいんじゃないの？

で、2.4/1.1 = 2.1818181818181818 では？

これまでの浮動少数は間違っていました以下のように訂正してください。
浮→不
で、いいんじゃね？

型変換が嫌なら桁落ちさせれば？

563はワインバーグのネタですね。浮動小数点数は不動の小数点を持つし、
固定小数点数は浮動の小数点を持つ。　木村泉の名訳で知ったのですが、
たぶん英語でも面白いジョークに聞こえる表現なんでしょうね。

いや、つまんねえし

いや、そんな知識ねえし

あぼーん

２３６２３６＋P　真空浮動少数

不動小数

hoshu

むかしむかし、コンピュータは自然数しか扱えなかった。

そんなコンピューターでは引き算が出来ないから、
計算機屋が頑張って負の数も扱えるようにした。
こうして、ゲタ履き表現と2の補数表現が出来た。

ゲタ履き表現は足し算引き算のときにゲタを戻さなければいけないので少し面倒なので、
2の補数表現のほうがメジャーになった。

天文学者・物理学者がコンピュータを使いたくなった。

　天文学者：アンドロメダまでの距離はXXX kmで、星の数はYYY 個なんだよ！
　物理学者：世の中は全部クォークで出来てるんだ。クォークの電荷はXXX クーロンなんだぜ。

二人のニーズに対応するために、計算機屋はあれこれ考えた末、浮動小数点数というのをひねり出した。
数学の指数表現をコンピュータで表現仕様という試みだ。
これは苦労の末なんとか実現して、天文学者と物理学者は大喜び。

それを見ていた金融業者も同じようにコンピュータに金融計算をさせようと思った。

　金融業者：僕と同じように筆算して。

計算機屋は金融業者の計算を見て頭を抱えてしまった。
金融業者は10進数で計算をするため、誤差の丸めも当然10進数基準なのだ。
コンピュータは2進数しか分からない。電気のオンオフしかないから。
しょうがないから計算機屋はBCDを作った。苦肉の策だ。

金融業者は自分でやるのと同じ答えを導き出すコンピュータを得られて大満足で帰っていった。

オチ。




固定小数出すの忘れた。

　

　

金融計算も、浮動小数点で1000倍とか1万倍した値で計算させればいいんだよ

例えば1.3% の利子は 1.013だけど、千倍して 1013として浮動小数点で掛け算した後で 1/1000すればいい。

というか最近の言語で金銭型を扱うというのは、だいたいこの方式だ

複利で100年後の利息教えてください

ふと気になったのだが

double（64bit floating point）型が64bit integerのすべての値を正確に表現できる

ことはどうやって証明すればよい？帰納法？

残念だけど 2^62-1 とかの値は64bitの浮動小数点型では表現出来ないという結論になりそうだよ

ところで
2038年問題は結局どうやって対処したのかな　64bit浮動小数点で表現する事にしたんだっけ？

>>576最近の言語は
ほんまかよ。

ＯＬＥのCURRENCY型は64bit整数型を　10,000 倍した表現だね
　　　　　　　　　　　　　　　　　　　~~~~

つまり、>>570はデタラメですね

>>578
単純に仕組みを考えても、
＞double（64bit floating point）型が64bit integerのすべての値を正確に表現できる
できるわけがない。

んだんだ。
なんしろdoubleの仮数部は53bitしかねえもんな。
64bit intでの、54bit〜64bitの長さの奇数は全部反例。

もしかして偶数しか使わなければよくね？

2^62+2 もダメでしょ

1ビットのびるだけだろ、意味がない。

大体、64ビットの全パターンが整数値に対応してんだから。
浮動小数の、64ビット整数の値域に含まれる分のパターン数なんてたかが知れてるわな。

IEEE倍精度(64bit)の全ビットパターンの内、((2^52)-1)*2個もの値がNaNに割られているのはナンとかナンないかと思うぞ。

>>578
64bitでなく、

　double（64bit floating point）型が32bit integerのすべての値を正確に表現できるか？
　またその証明方法は？

だったら自明でない問題になるかも。

仮数部ビット数が遥かに長く、
指数ずらしなしで整数をそのまま表現出来る以上、
できるに決まってる。

Pentiumなんかは浮動小数点ユニットは80bitじゃないか

その事実が何を示すのか分からんな。
事実に対して何の推論も意見も持たないなら書き込む意味は無い。

>>591
FPUの方はね。

EM64Tは128bitのXMMレジスタが16本有るんだから
四倍精度も扱えるようにしてくれればいいのに。

>>593
誰が使うんだよ、そんな精度をｗ

>>594
FORTRANでは言語仕様の中にあるので、ハードウェアでサポートしていた
方が便利かもしれない。ま、科学技術計算をx87でやろうという酔狂も
少ないだろうが。

http://homepage2.nifty.com/tadakazu/opendoc/fpu_x87.html

HPC分野でXeon/Opteronでクラスタ組んで数値計算
というのなら需要は有る。

#Xeonで四倍精度をサポートしちゃうと Itanium 2の立場がないが

AMDのK8Lというやつが、サポートしないかなあ・・・

>>572
>>計算機屋は金融業者の計算を見て頭を抱えてしまった。
>>金融業者は10進数で計算をするため、誤差の丸めも当然10進数基準なのだ。
>>コンピュータは2進数しか分からない。電気のオンオフしかないから。
>>しょうがないから計算機屋はBCDを作った。苦肉の策だ。

ここが理解できないのですが。
どのみちこの時代は浮動小数が32ビットかもっと少ないでしょ。
とすると、当然多倍長にしないと足りないわけで、
いや精度が必要なところは64ビットが使えても多倍精度を使うのは常識だろう。
8倍の256ビットでやるとして、100ビット目がずれることはありうるのか(10^5-6回程度の演算で)。
カオス演算でもさせないかぎりずれないだろ。
金融演算がカオス的ならどのみち10進でやろうが意味ないしな。

金融じゃ浮動小数点つかわねえだろ

金利があるじゃん

為替レートも銭刻み

金融系で浮動小数点数での実装など見たことない。

固定小数点にきまってんだろ

というか10進演算。

>>598
現代のたいていの法律の条文や契約書では、
様々な計算を行う際に10進数で計算するように書かれている。
BCD にしないと、消費税の計算ですら法律通りの数字が出せない。

同じ理由で昔のエジプト人やメソポタミア人は60進法演算のできる
コンピュータを使っていた。

どんなコンピュータ？
そろばんみたいなやつとか？

>>605
>>BCD にしないと、消費税の計算ですら法律通りの数字が出せない。
すまないが、現在の法律の計算方法と、
正しい計算結果が出ない"反例"を挙げてくれないかな。

君ら暇だな('ー`)大好きだぜ。

2進表現で問題になるのが、ドル表記で、セントが無限小数になること。
それを嫌がった金融屋がBCDなんてボケなモノを作らせたんだろう。
つうかBCDのメリットは「0.1問題」が解決するだけ。他のメリットなんて+αだ、オマケだ。
それでIntelが何をトチ狂ったかBCDをハードウェアで実装しちまったんだよ。
ぶっちゃけソフトウェアで固定小数点数表現したほうが100倍もましなんだがな。
当時はCPUもそれほど早くなかったから仕方がないな。

目的に合わせてビット表現も変えるのがプロの計算機屋/プログラマ。
それに理解を示さないボケな古狸が金融業界には多い。それだけ。

悪いがつまり何が言いたいのかさっぱり分からん。

レス早いなー。
簡単に言ってみよう。

BCDは要らない子だったんだよ。

おじさんは BCD 便利だから使ってるよ。
表示する時楽だからね。
四則演算くらいアホの子みたいに書いても今なら問題ないし。
いちいち２進１０進変換するより、BCD のみのほうが楽なこともあるのよ。
おじさんゲーム屋なんだけどね。
若者は多倍長整数とか分数表現とか使えばいいんじゃないの？

で、２進固定小数点数で 0.1 を表現するの？
それとも、印字の時に小数点を打つって話？

0.1を表現する話は、小数点の固定、浮動にかかわらず0.1は近似表現しか出来ないという話です。
BCDなら誤差なく表現できますが、それ以外にメリットは無いだろうというのが私の主張です。
そこで、

・何故BCD以外だと表示が不便なんですか？ (BCDは便利、に対しての質問)

固定小数点なら0.1は近似じゃないだろ？

>>612
0 から 9 までのそれぞれの数字に、画像をマッピングしたら、
BCD ならば、それぞれの桁がまさしく画像へのインデクスだ。
非常に楽チン。
おじさんは１０桁以上になるものは BCD でやってる。楽だから。
表示の時に１０進変換するのが楽なら、それがいい。
多倍長から直接１０進出力するメソッドを定義するのが楽なら、
そうすればいい。
おじさんは頭固いから。

・10 点加算する時も 10h 加算するとするなら、全く変換の必要が無いよ

>>613
小数点位置は 2 進で表さないのか？ 固定なのに.。

>>612 　0.1だけなら浮動小数点でも10倍しておけば問題ないよ

>>613 ２進数固定小数点といってるのは　小数点位置をどこかに取るから近似になってしまうよ
　　　１０倍表現、１００倍表現なら問題ないよ

>>614　別のおじさんは桁数多いなら１００進数を良く使うといってし、別のオジサンは１万進数を使うといってた

>固定小数点なら0.1は近似じゃないだろ？

2進数って知ってるか?w

1==0.999･･･ が正しいなら　無限桁あれば表現出来るよ

>>614
なるほど、納得です
非常に限定された使い道ですが、それも有りかもしれませんね。
10という数によほどこだわらないとBCDは有用になりえないのは変わりませんね。

いやー、そもそも0.1が近似であろうがなかろうが、たとえば浮動小数でやって真の値0.1との誤差をeとしよう。
冪乗がすでに近似演算しか不可能だからどうしようもないのでは。
乗除算でも大きな打切り誤差が発生するだろ。
ここで真の値とオーダーeの誤差が発生すれば結局一緒ではないか。

>>619
BCD は誤差なく常に「真の値」で演算を行うので、
その考察は見当違いですよ。

ビジネスで行う演算は、たいていがどこで四捨五入するとか、
どこでどう切り下げるとかが契約や法律で定められていて、
常に正しい値が得られるようになってます。
（契約書や決算書に約3円とか書かないでソ、普通）

で、そういう計算の際の決まりは大抵10進数で記述されているので、
計算機内で n * 10 ^m （n, m は整数) が正しく表現できれば、
誤差なく実装することができる。

なんかもう堂々巡りだな……。

ＢＣＤといっても、無限に小数点以下を用意してるわけではないので
たとえば少数以下４桁とか固定サイズ持ってるわけだ。

だったら、浮動小数点でも固定小数点でも １万倍して持つという規則を作ってやれば全く同じ事。

演算子オーバロードが出来る言語なら、BCDを実装するよりも簡単で高速に実現出来る。

#浮動小数点でも固定小数点でも １万倍して持つという規則を作ってやれば全く同じ事。
個人の妄想

#BCDが使われている
揺ぎ無き現実

>>620
だから、あんたのほうこそ約じゃなくて誤差を定量的に測れと言っているんだ。
例えば、10/3=3.3333で四捨五入で計算すると法律で記述されているから真の値で計算されているとは言わないぞ。
本当にム板かここは、理論的に数値計算での誤差の上界を求めたり、
実際に計算機上で実験して、誤差の統計的分布はどうなっているとか調べずに、
(計算量のコストも考慮すべきだが)
確かめもせずにどこかに書いてあった知識を鵜呑みにして、
オウムみたいにBCDBCD言っているだけではだめだ。

数学的に正しい値 ≠ 法律的に正しい値

>>625を認められないｷﾓｦﾀ>>624ｶﾜｲｿｽ

つうか環境に用意されてる10進演算機能や型を利用するのが普通だろ。
わざわざ自分で実装しなけりゃならんことのほうが少なくないか？
と思ったがもともとビジネス用途じゃない言語では用意されてなかったりするか…
それでもライブラリとかはありそうな気がするが…

現実問題、FPU倍精度で2^53までの整数は厳密に扱えるのだし、
ソフトさえ整備されればFPUの方が速いだろう。たとえ100桁が厳密に必要でも。
あ、普通に整数レジスタ使うという手もあるな。
まあ、今のソフトでいいならBCD使ってもいいけどな。

mov al, 06h
mov bl, 09h
mul bl
aam

百桁も何も
1÷3で破綻するんですけど

>>624は人間社会に出ると存在価値が無くなる院生

>>630
判ったよ。　だったら10倍ではなく60倍して持つことにしよう

>>632
1÷7はどうしましょう？

>>627　ＢＣＤ型がある言語はCOBOL程度しかないのでは？

Currency型というのは、多くは10000倍された64bit固定小数点型の事だ
money型は100倍された固定小数点型
Decimal 型は　128bitの10のベキの浮動小数点

某8bit機のBASICはBCDだった・・・。

>>633
で、複素数型を改良してA/Bで表現する有理数型を作った後で

じゃ√２はどうしましょう？　と聞かれてギャフンと

BCDはコボラー専用。

ああ、だから環境に用意されてる10進演算用の型って言ってる。
BCD表現かもしれんし、別の表現かもしれん。
いずれにしても、自分で実装することは少ないんじゃない？って言ってる。

全部の桁使えばいいじゃん

不動小数、 なーんつって

>>639

[1][÷][3][=]っと

先生!永久に終わりませんorz

堂々巡りはもう飽きた。 他にネタはないのか？

>>641
それは 分母と分子の２つの数を覚えておけば解決するぞ

>>643
>>636 と、ついでに >>642

数式を覚えておく数式型を作ればいいじゃん

>>645
有限の数式の解にはならない数を超越数と呼ぶ。
πとか自然対数の底eとかな。
それはどうするのかね。

piはpi、eはeでよくね？

>>618
非常は言いすぎだろ。
おじさんはゲーム屋だから聞いただけだけど、
組み込み屋は今でも 7 セグ表示に 4bit マイコン
使ったりするらしいぞ。
一般消費者に１０進で提供するのが「よほどこだわる」
ことなのか？

今のプロセッサなら2進に変換してから演算し、また10進に直したほうがはるかに高速です。
確かに処理系が貧弱な組込系はそうする必要があるかもしれませんが、
それは非常に限定的な使い道には違いないでしょう。
ユーザーインターフェイスは10進で提供するのは当然ですが、
内部表現まで10進にするというのは何かこだわりが無い限りやらないと思います。

今のといっても、それは値段しだい。

結局除算がどれだけ高速かによるんだよ。

除算命令を持ってないＣＰＵなら10進や100進は内部形式として普通に使われる
その理由は2進10進変換のコストが非常に大きいからさ。

そして、パソコン以外のＣＰＵでは除算命令は持っていても、とても遅い。
たとえば、今月号のインターフェースにSH2のチップが付いているが
これは組込用としてはリッチな方の環境（同じ会社のM16やH8に比べて）
それでも除算は何サイクルもかかる。

まあSH2は掛け算が高速だから、
10進変換の場合の１０で割った余りは
掛け算2つと引き算で代用出来るとしても、それでも重いよ。
多桁となると100進数・万進数を採用した方が高速だ。

と
書けば、そんな少しの高速化より、開発効率云々という話をしたくなるだろうが
組込用、特に電池駆動のシステムでは
実行サイクルは電池を消費する故に、少しでも実行効率を上げる事の方が重要な事となる。

だからそういうニッチな環境は一般的でなく限定的な場合じゃないのかと。
まぁ非常にってつけたのはノリだったから謝る。

だから、一般的環境って何よ？

いっぱん‐てき【一般的】
　１．或る部類のものに共通であるさま。普遍的。
　２、或る部類のものの大部分に共通であるさま。

大多数の職業プログラマはWindowsプログラマだが
ソフトウエアを必要とする環境の殆どでは除算は遅いのが一般的だよ。

計測機器にもBCD信号出力が付いてるのが結構あるなからなぁ。

結局何が言いたいんだ？

BCDネタはもう秋田

>>645
いまそれ作ってるｗ

>>657
√(5 + 2√6) = √2+√3
とかの分解もがんばって実装しる。

計算しなければ誤差は発生しないという真理

実際ケーキを3人で分けるのに永久に割れませんとかコントやる馬鹿はいないわけよ
浮動小数点で80bitもあればそれでいいのよ

数とケーキは違うから。

場合によりけりですな。
小数点の9桁下の値が微妙にずれるだけで宇宙がひっくり返ってしまう人もいるわけで。
まったく気にしない人もいれば、誤差量がわかれば多少ずれてもいい人もいるわけで。

ぶっちゃけ全ての答えはたった二桁の整数なんだからそれで十分。

有効桁数の問題ではないのだよ。

常に42を返せばok

>>660
ケーキなんてのは水平にスライスするように切ればOK。



上側は嫁の分orz

それなんて４コママンガ？

嫁肥ゆる春

牛丼食いきれないから半分食え、とまわってきた丼はご飯しか残ってなかったりorz
うな丼もカレーも同様。

そんな君には俺のドーナツを半分上げるよ。
ただし俺が外周、お前は内側半分な。

肉食べないから牛丼の飯とつゆと糸こんにゃくだけとか好物

>>651
＞10進変換の場合の１０で割った余りは掛け算2つと引き算で代用出来る
ちょっと考えてみたけどわからんかった。
後学のために教えてくだちい。

俺は>>651じゃないが、ハッカーズデライトに以下のような内容がある。

例えば32bitのとき。X / 10を以下のように変形する。
　X/10
= X * (2^33 + 3)/10 / 2^32
= (X * 0x66666667) >> 34

これで掛け算1回＆シフト1回。
余りは上で求めた商から、掛け算1回＆引き算1回で出せる。
この方法はシフトが遅いCPUじゃ使えんけど。

そもそもシフト使わないって言うなら、俺には分からん。

しまった、間違えた。
× 2^32
○ 2^33

>>673
一般的に、掛算結果はレジスタ２つで返ってくるものがおおい。
だからレジスタサイズに合わせてやればアセンブラレベルではシフトの必要は無い

たとえば32bitなら　01999999ah と掛け算して上位ワードを採用するだけでいい

数値計算ガイド
http://docs.sun.com/app/docs?l=ja&q=&p=doc%2F806-4847

浮動小数点数で教えてほしい事があるのですがいいですか？

だめですぅ。

どうぞ

どっちやねん

思うんだけど浮動小数で1000倍してから計算して戻せば
BCDはいらないという主張の正当性がどこまで妥当なんだろう。

1000倍してもアンダーフローが起きるときはさらに1000倍、
それでも足りないときはさらに1000倍なんてことを繰り返す？
するとどこかで今度はオーバーフローを起こしてしまいそうなんだけど。
その辺りを、誤差を落とさずに自動でやってくれるよう機能しているの？


BCDのほうがまだまだ確実のように見える。

a=1*1000
b=3*1000
a/b

はい無意味

1/3*3という式が現れたら、
コンピュータが正規化処理を実行して
先に3を約分してから結果的に1になるように処理をすればいいじゃないか

自動通分だ

自動約分、自動展開、自動因数分解、自動二重根号除去、自動平方
などなどをオブジェクト指向で実装できれば。
分数クラス、有理数クラス、無理数クラス、複素数クラス、などで。

>>683
除算とか虚数とか、そのまんま扱えば幸せだお。
数値演算するから不幸なんだお。

>>683
(/ 1 (* 3 3))
1/9

こんな感じ？

if (1 + (1 / 100000000000000000000000000000000000) == 1) {

　　　　　　　　糸冬　　了

}

>>681
小数点以下４桁のBCDでも1万倍の固定小数点でも1万倍の浮動小数点でも
その有効範囲の計算結果は同じ。

1/3 というような場合に小数点以下4桁BCDや1万倍固定小数点は
0.3333までしか答えが得られない　が、1万倍浮動小数点なら　その有効桁だけ求まる。
が、だからといって意味があるわけではない
0.33334 と 0.33336で四捨五入の方法を変えたい場合に浮動小数点から有利かどうかも
それも実装によってしまう。

オーバーフローやアンダーフローの問題は、どの方法でも起きるのだし
結局は、どの方法が楽かという問題でしかない。

ただ浮動小数点ならsin/cosから指数対数まで既に用意された関数が使えるというメリットがある程度かもな

このスレで浮動小数点を否定しているのはネタだよな？
普通に考えてどの方法が楽かという問題でしかない。

だからBCDで全ての桁を扱えばすむ話と何度言えば

永遠に割っとけ

なんか定期的に話題がループしとるな。

うんこが生きてる間は出続けるのと一緒だろ。

>>691がウンコというわけか

式のまま扱えば良いじゃん♪

まさに循環小数

>>687
まったまった。
(1/3)*3 だろ。
だから結果は1になるべきということで。

　・
0.9

になるべき

おまいら、アフォだろ？

スレ違い
http://science4.2ch.net/test/read.cgi/math/1142173277/

0.111…＝1/9
0.222…＝2/9
0.333…＝3/9
：
：
0.999…＝9/9＝1

1/3*3 は1になるべきで
1/(3*3) = 1/9じゃない
といいたいんだろ。
(1/3)*3なんて書いたら優先順位を変えたと勘違いされる。

約分のアルゴリズムを導入しろということだろう

(* 3 1/3)
1

分数は分数のまま扱えば良いじゃん。

19レスで循環した

一応、約分してくれる言語っていくつかあるんだよね
MATLABとかでもなかったかな

式を微分したり積分したりできるやつ。

微分、積分してから値を代入するので、
数値微分や数値積分のような丸め誤差伝搬の心配がない。

ここがそんな高度なレベルの話で議論してるとは思えんがな。
議論ですらないか。

浮動少数って名前がそもそも

>>689
ということは
有効桁数さえ足りれば今後は、
doubleやlong doubleだけで十分だということ？ (もし足りなければ多倍長型JavaのBigDecimalなどを利用？)
けど、C/C++やJavaのdouble型は、内部でそういうことを
自動的に実行してくれる仕組みになっている？
Javaにはstrictfpという修飾子があるけど、これを使わないとだめとか？

>>700
分数の計算なら、Fractionクラスを作ってどうにかなる。
微分積分については、まず変数クラスを作らないと。

MATLABのように
sym(x)

x = sin(x) + x^2

とやったあとで

diff(x)

とすると

cos(x) + 2 * x

が返ってくるようできるものをクラスで定義しなくては。

ループしちゃいけないなんてローカルルールはないんだから
同じ話題が続いてると思ったら新しい話題を振るか、
それができないんなら黙って見てればいいんじゃないですか？
それとも住人の会話を邪魔して楽しむ新手の荒らしかなんかですか？

循環小数がループしてるという話をしてるのではなかったのですか？

>>711
じゃあ貴様のその書き込みの意図は何だ。
黙って見ているわけでもないし、
新しい話題を振っているようにも見えないが。

じゃあ新ネタ。
浮動少数点表現、固定少数点表現に変わる新たなビット表現を考えれ。

んな無茶なw

万能数値表現法　ＵＲＲ
http://homepage2.nifty.com/m_kamada/docsproc/asmurr.htm

>>715
おもすれえー。
ちょっとためしに実装してみよう。

プログラミングの為の数学と算数 vol.2
http://pc8.2ch.net/test/read.cgi/tech/1094368921/

こりゃいい。
っつうかもっと早くそのネタ振ってくれよｗ

絶対値が小さい程精度が高いって事かな
HWに実装するのはちょっとキツそう

C++やC#のクラスで作りたくなってきた

>>719
むしろHWでやらないと意味無いでソ

検索したら、HW実装してもIEEEのものより若干遅いってデータのPDFが見つかった。

それでも、IEEEじゃ満足できずにソフトウェアでハックすることの多いであろう
科学技術者にはHW実装のものも価値があるのかもしれないね。

おもしろいし、一瞬すばらしく思えたが
よく考えりゃ、指数が足りなくて困ってる人以外には
実用的には価値ないな

いま C++ のクラステンプレートで実装し始めてみたのだが、足し算からして実装がめんどくせぇ。(；´Д｀)

指数部の処理が厄介そうだよ
しかも有効数字可変という罠

>>724
最初、思いっきり間違えて実装しようとしてた。二重指数ってなんだよ、これ。
区間の比率が1:2を境に幾何平均か算術平均かをわける？
意味とかはもう正しく理解できたとは思うけど、この仕様、無茶苦茶だよ・・・

数値を表現できただけで満足してて、
それを使って実際に計算することを考えていないのでは？

複素数で対数化するのと、そう変らんように思うな。
昔 掛算が遅かった頃、FFTを実装するのにやった事があるが

どうせ1/3で破碇するんだろw

>>718
1/2 でも破綻してると思う

6進数なら破綻しないぞ

>氏は URR のことを過去の失敗作のようにおっしゃって多くを語っていただけなかったのが残念でした。

考案者もこう言ってるしなぁ。

>数値を表現できただけで満足してて、
>それを使って実際に計算することを考えていないのでは？

漏れもそう思う

>>728

10進数で全部の桁計算すればいいんでないの

進数についてはこの際もう関係ないから蒸し返すな。

2^32進数を使えば問題はすべて解決する。

それだ！

いや、何にも解決しないけどｗ

以下何進数をつかっても無限少数になる数字が存在するって証明↓

π進数というものがあるらしい

π進数で0.1を表してみてください。

π/(π+π+π+π+π+π+π+π+π+π)

つまらん。

>>739
radianのことか？

radianはスケーリングっしょ。
進法とスケーリングは違う概念だと思うさ。

そういえばHacker's Delightに 1+i 進数があったな。

まあその気になれば任意の実数進、複素数進の表記は可能なんだけどな。
数学板でそんなスレがあったような気がする。

あらゆる数値は12345679の倍数で表現可能

12345679 x 9 = 111111111
12345679 x 18 = 222222222
12345679 x 27 = 333333333

12345679*n=m を満たす実数nが全ての実数mについて存在することを証明せよ。

trivial. ■

次のネタまだー？

複素数を対数化すれば虚軸は2πで循環するけどね

嘘こけｗ

>>751 こけ？　こっこ？

ttp://www.ee.t-kougei.ac.jp/tuushin/lecture/math1/htdocs/complex/log/

ttp://ja.wikipedia.org/wiki/%E8%87%AA%E7%84%B6%E5%AF%BE%E6%95%B0

C++でURR実装してた人どうなった？

めんどいからやめたんじゃ。

とりあえずいまんとこ保留。また気が向いたら続きをやろうかとは思ってるけど、
四則演算はいったんBCDにでも変換してから計算し、またURRに戻すって形になりそう。
とにかくなんらかの形のものができたら報告＆公開することだけはお約束しておきます。

>>756
変換する必要はないでしょう。
1ビット目が符号ビットで、
1ビット目と2ビット目が異なれば絶対値1以上。
2ビット目からk個同じビットが連続しているならばそこまでが指数部で2^2^(k-2)。
2ビット目と3ビット目が異なるなら指数部は2^0。
残りが仮数部。あとは浮動小数点の演算を行えばよい。
加算なら指数部のビット差がkなら2^(k-2)ビット仮数部をシフトして足す。
絶対値が1以上と1未満の加算の場合は、
2^(k-2)+2^(l-2)ビット仮数部をシフト。
指数ビットずらすから差が大きいとすぐに一方がゼロになる。

>>757
仮数部が幾何平均と算術平均が組み合わさったものにになるからそれだけじゃうまくいかんとですよ。
...でも、確かに言われてみるとちょっと難しく考えすぎてたかも。

>>756
C++のかわりにJavaで実装してみればやりやすいんじゃない？
Javaのほうが型に厳しいからバグを見つけやすいという利点もあるし

>>759
型に厳しいって表現は誤解を招く。
型の処理系依存が少ないというべき。

アルゴリズム考える上では自分の脳内言語が一番いいよ。
そして紙とペン。

>>760
> 型の処理系依存が少ないというべき。
すげ。好意的エスパー。
理由も結論もでたらめだったのに。

>>762


>>759 は コンパイル通らない只のコーディングミスをバグと思ってるんだろうね

お客さんだったらみんなそう思うに決まってるよ。
どんなものでも自分が予想できないものはなんでも
バグ扱い。それが顧客の対応。

ルールを厳密にしてコンパイルではじくのは、バグの原因を減らすためでもあるし
コーディングミス≒バグと言えなくもない……かな？

修正する必要のある項目は全部バグでいいじゃない。

>>765
>ルールを厳密にしてコンパイルではじくのは、バグの原因を減らすためでもあるし

確かにそーゆー傾向はあるが、それはコンパイルエラーの本質じゃないだろ。

で結局JavaとC++とどっちがいいの？

その話題はそういうスレがあるような気がする、探してみれ。

>>768
宗教戦争になるのでそういうことは自分の脳内で結論を出してくれ

いまさらな話だけど、件のWebページではURRでも「指数部」「仮数部」という言葉を使ってるけど、
IEEEのそれとは完全に別物として考えなきゃいかんね。
例えばIEEEなら「指数部」がどうであれ「仮数部」がゼロならその値はゼロと評価されるけど、
URRだとその値がゼロと評価されるのは「指数部」と「仮数部」がともにゼロのときだけだし。

なかなか難しいでヤンスね。

>>771
IEEE754の単精度と倍精度では、denormalのときしか仮数を0に出来ないけど。

要するにデノーマル・無限・非数がない

つうかURRって、0や無限は指数が無限大だから
指数部に0や1が延々続いて、仮数部はないんでないか？

>>773
ごめん、IEEEについて勉強不足だった。
仮数部の先頭には暗黙の1がつくんだね。
このへんはIEEEもURRも一緒だね。

固定小数点演算
http://www2.muroran-it.ac.jp/circle/mpc/old/algorithm/cg/fixedpoint/fixedpoint.html

>>777
そこイマイチ分かり辛いんだよな。回りくど過ぎて。
こういう簡単な概念では毎度の事だけど、ソースを読むのが一番分かり易い。
それと、『固定小数点数演算』の方が俺的にしっくり来る。

同意
糞だよね、そこ

MMXの後に浮動小数点のSIMDが来ると予想しないところが、
時代を感じさせるな。

>>777
>Ver 1.00 : 1998/07/20(Mon) 18:00:00
K6-2が出たのは1998年3月28日。AltiVecが発表されたのが1998年5月。
Macに興味なかったとしてもこれはまずいっしょ。
AMDを舐めきってたか、Intelが対抗しないと予想してたんだろうか。

そりゃあ今になってなら何とでも言えるだろう。
固定小数点の話を苦労して書いた後ならこのくらいは普通だと思う。

　　　　　　　　　　　　＿＿＿＿
　　　　　　　　　__,,／　　_, ----｀ヽ　　：.
　　　　　：. 　／　_　　　　　___　　　､＼
　　　　　　 / ／　　　i　　　 　 ＼ 　 ＼＼　：.
　　 　 ：.　,'./ 　 　 　 i　　ヽ:.　 　ヽ:.:..　ヽ.ヽ
　　　　　 ,'/　　　 / .ハ ヽ　ヽ:.:.:.:.　ヽ::..　ヽヽ　：.
　 　 　：. |i .i　i　 .i /　 ヽ ﾄ ､ ＼､:.:.:. ',:.',:.:.lヽ}
　 　 　 　|i .i　l 　:Ｎ＿, -弋　＼弌弋ナ:}:.:}
　　　　：. |i∧ ',　:{　,ｨjモﾄ　＼　 ｲjミﾄｲｲＶ　：.　　な…
　　 　 　 .|　 :ﾒヽ.', `ozＺ} 　 　　 izN｡ﾊ::{　　　　　なんなんですか？
　 　 　 ：. |　 :ヾ_! ゝ　"ﾞﾞ　　　 ' 　｀ﾞ ハ.:',　：.　　　ここ、どこですか？
　　　　　　|　 :.:_ｲ .:.ヽ. 　　(二ﾌ　, ｲ :.:.:!:.ヽ　　　　　なんで壁にお尻付けると
　　　：.　 / rｨｲ |　:.:.ヽ: ＞r／｀＜ノ .:.::.}ヽ､＼：.　　　前屈出来なくなるんですか？
　　　 　 / ∧l;l　!　:.:.:.:/／{二￣ .} ..:..::ﾘ//ハ.:＼
　：.　 ／　.{. ',ヾ､ヽi .:.:.{ ／(^｀　　|.:.:.:./／: : :.}: . ヽ.：.
　　 /　/　 ） ヽ ヾ､ヽ:.ﾊ　ﾔ{　　 ∧／.-‐'": : |:.:.　i ',
　 ./ .,ｲ　.:..}　: :＼ヾレ'ﾊ　∧__ノﾉﾊヾ､　 : : : l:.:.: .ﾊ ',
　 { /｜ .:.:ﾊ　: : :i Ｙ {ヾ｀Ｙヽﾆン'ノ}: : } : : : :/:.:.:/　}:.}
　 Ｖ　| .:.:/:.:|_,ｨ'￣　 ヽ三{　｀ー-ノ : ｲ : : :/:.:i.:{　　リ
　　　 ヽ:.:{､.:.Ｖ　　　　 : : ﾍ　　　　 : : {: : :/:.::∧|
　　　　 ヽ! ）人　　　　: : :人　 　 　 : : : / ＼!　：.
　　　　　　"　 ヽ　: : : : :/イ{　　　　　:.ノ: : : :.＼　：.
　　　　　　　：.　 ＼__／//: :＼______／: : : : : : : ヽ
　　　　　　　　　　　/　//: : :|;|: : : : : : i: : : __: : : : ',
　　　　 　 ：. 　 　 / ､ {;{　　 |;|　　　. : i／. : : : : : :|
　　　　　　　 　 ／　｀Ｙ;{. . . .|;|. : : : ／i: : : : : : : : :l

>>635
お！カシオFP-1100のことか？ｗ
遅くてまいったぜ！


それにしても，最近は浮動小数点のフォーマットが統一されてきて助かるよな．
IBMの１６進浮動小数点のウンコフォーマットとかｗ

昔は収束判定のパラメータを機械ごとに変えるのがまんどくさかった．
それでFortran90で山のように数値精度に関する関数を導入したんだろうが遅すぎぜｗ
ほとんど使わないｗ

それにしてもFortranスレにまでBCDが科学演算にいいんだかいう連中があらわれたんだが，
どこでそんな伝説がながされているんだｗ

IBMの16進指数はやばかったらしいね。パタヘネに載ってた。
IEEEは偉大だー。

スレ違い？ここはアンチ浮動小数スレ？

だめもとできいてみるのですが、

浮動小数のフォーマットは理解したのですが、浮動小数同士の足し算や掛け算がどういう仕組みで
行われるのかが知りたいです。
フォーマットや比較についてはググぐと結構みるかるんだけど、演算がみつからなくって。

たとえば２．０ｆと３．０ｆの足し算と掛け算あたりを説明してもらえるとうれしいです。

小数の足し算が分からないって・・・小学校からやり直せ！

>>787
IEEEフォーマットを小学生が理解できるとは思えない。
>>786
説明はWEBで探せばあるかもしれない。
書籍をあたるならば、パターソン＆ヘネシーのコンピュータの構成と設計の上巻がオススメ。

一応簡単に説明すると、
足し算はケタをそろえて仮数部を足し算の後正規化。
掛算は仮数部を掛算、指数部を足し算してゲタ分除いて最後に正規化。
とかそんなところ。

ケタって指数のことですか？？

>>788
小学生でも理解できるって。
そりゃ、IEEEフォーマットについて解説してある多くの文章が
小学生向きに書かれてないから小学生が読むには読みにくいで
あろうことはわかるが。

>>789
YES
指数をそろえるという意味で使った。
分かりづらくてごめん。

>>790
小学生に実際に理解させようとしてみ。
興味がないことなんてこれっぽっちも聞いちゃくれない。
塾のバイトで心底そう思う。

話がずれてる気がするが…

MIPSの教科書のコプロセッサの項なんかも、実装面から非常に詳しく書いてあった覚えがある。

>>791
いや、だから自分で興味があったらちゃんと調べるよ。
俺の経験で言うと、小学生のころからプログラミングやってて
ちょっと踏み込んだ内容の書籍はどれも小学生向けに書かれて
なかったから苦労はしたけど、内容そのものはどれも小学生でも
理解できるものばかりだぞ。

有効桁数の概念は中学で習ったから、中学生ならいけるのでは。

つまり、>>786は中学生からやり直せ!

>>793
その前提で言えば全くその通りだね。
自分もマシン語に興味持って色々と本を読み漁った覚えがある。

>>794
概数なんかは小学校でやるけどなー、とか言ってみる。

というかまぁ、質問主は立ち消えか。
>>786は別の意味で小学生からやり直すべきかもしれんね。

>というかまぁ、質問主は立ち消えか。
>>>786は別の意味で小学生からやり直すべきかもしれんね。

そうだね。でも、知識や知恵の類と違ってこーゆーことは幼少時に
学ぶことを失敗したら幼稚園からやり直したところで再学習は困難を
極める・・・というかほぼ無意味。

もう救いが無いなｗ

単位系の基礎中の基礎である秒の定義は、セシウムなんちゃらの9,192,631,770倍らしい。
これってあらゆる種類の測定器や工作機械で有効精度10桁オーバーを目指しても無意味ってこと？
途中の演算過程でより多くの精度が必要になるのは解っているつもり。

9,192,631,770.00000000000000000000000000...倍
だと思えばいいんじゃ。

>>798
定義だから有効桁数という概念はないよ。1分を1秒の60倍と定義するのと同じ。

つ http://tricklib.com/cxx/ex/urr/

非常に遅くなってすまん。

カウンタと精度ってどうつながるんでしょうか？

繋がらないと思うが

>>802
そもそも何のこと？

確かに
なぜか時間だけは非常に精度良く計れるんで、
多くの測定器はその時間制度の良さを利用してる。
ＡＤＣでも精密なＡＤＣは積分型で、これは時間精度を利用してるわけだ
これは水晶の精度が非常に良いからだよね

回路で扱える量は、電流と電荷で、
時間に関して積分するからクロックの精度は重要ってことか。
って。

浮動小数点数表現による誤差と
測定誤差は全く別物だと思うが。

>>801
おう！とはいえ俺は知識経験ないために、レスができない。
何か感想とかありますか？

>>806
だいぶ文脈が飛んでるみたいだが、クロックの精度がどう重要なんだって？

カウンタクロックの精度がまちまちだと時間積分の微分量δtが変動して
正確な積分ができないんだろうなーと思ったんだけども･･･。
∫I(t)dt = Q(t)
だったよね。自信ないが。

そもそも805の真意がそういうことなのか良くわからんけど。
どのみち浮動小数点数と関係ない('･ω･`)

>>807
なんかいろんなところでURRの実装は面倒とか言われてるし、実際自分も最初は大変だと思った
けど、ちゃんと仕様を正確に理解した上でちゃんと設計すれば簡単に実装できますた。

でも、最初はアホな設計で無駄にエンディアンの縛りがあるコードになったりして２回ほど
作り直しに近い大幅な修正を行ってます。最終的にはかなりコードを簡略化できたし、
エンディアン依存もなくなりました。

Hacker's Delightにでてくるようなビット演算技は使ってないけど割り算を除けばちゃんと
高速に動作するハズです。とは言ってもネイティブの浮動小数点型には遠く及ばないでしょうが。

ネット上に公開したソースに対してライセンスがどーこー言って利用を縛るようなこと
(特にGPL)はナンセンスだと思ってるんで自分でも URR を実装してみようとか考えている
暇人がいたら安心して是非とも参考にしてください。

>>810
なるほど。意外とスマートに実装できるみたいですね。
速度を考えると既存プロセッサでの実行は意味がないでしょうが、
知名度が上がれば、今後のハード実装の可能性がありますかね。
まあ、実際には難しいと思うけど、夢見たい感じです。

> 速度を考えると既存プロセッサでの実行は意味がないでしょうが、
せめてURRの紹介ページを読んでからものを言え

>>812
読んであるけど、既存プロセッサでも意味があるのですか？

>>813
スケーラビリティや有効精度特性が IEEE754 とは全然違う。

それなら、別に指数部を持たせるなどの、
自前の工夫をした方がいいかと。
逆にソフト実装のURRが役に立つ処理があったら
知りたいですね。

URRが真に活きるのは CPU まわりでの実装よりも
各種デバイスとの I/O まわりでの利用だと思う。
固定ビット長での表現力が違うんだから。

つまり、計算するときに役立つのではなく、
保存形式として優れているのだな。

>>817
保存形式として優れているってことは
計算時においても精度の点では優れていることになる。
速度は落ちるんだろうけど。

>>818
それは計算時に優れているとは言わないような気がする。
精度がよければいいんなら、いくらでもデータを増やせばいいし。

>>819
同じだけデータを増やしたら保存形式として優れているほうがより精度が増すし、
最終的な出力の保存形式のせいで精度を保てなかったら計算途中の精度をあげても意味がない。

初めて話に参加する人間だけど

>最終的な出力の保存形式のせいで精度を保てなかったら計算途中の精度をあげても意味がない。

これは嘘だ。意味はある。
実際、変数に格納するときはdouble(64bit)でも、計算途中はlong double(80bit)で計算されている。

>>821
それは double(64bit) のままで計算したら有効精度が double(64bit) の表現力より落ちる為。
最終的な出力の保存形式の＊せいで＊精度を保てなかったら計算途中の精度をあげても意味がない。

>>821
32bit/64bit浮動小数点数でも演算は常に80bitで行われる
っていうのはx87FPUの仕様であってこの話とは直接関係ないだろ。

それに細かいこと言うとlong doubleは80bitとは限らないぞ。

IEEE754rの128bit浮動少数は、いつごろハード（FPU)で実装されそうですか？

>>822-823
ボケどもが。計算途中で精度を上げることに意味がなかったら、80bitで計算するかアホ。
知能が足りないんじゃない？

俺は、同じデータ量ではなく同じ精度での比較を言ったのだ。
同じ精度ならURRに比べてデータ量が増えるとしても、
演算が高速にできる方が、普通はいいでしょ。

>>822
> 最終的な出力の保存形式の＊せいで＊精度を保てなかったら計算途中の精度をあげても意味がない。

計算途中での誤差の蓄積を減らすという意味があるよ。

結局お前ら何が言いたいんだ？
文章の途中で主張が変わったり、論理が飛躍するからワケがわからん。
恐らく熱くなってるのは二人だけだろうから、そこを直せば決着がつくだろう。
もうちょっと主張をまとめてみれ。

IBM、次期プロセッサ「POWER6」で「5GHzに近い高速化」を実現--10進数にも対応
http://japan.cnet.com/news/ent/story/0,2000056022,20268747,00.htm
＞ハードウェア内で10進数の演算を実行すれば、
＞処理速度を2〜7倍にまで上げられるという。

素人のコード見たらlongで金の勘定してたり世にも恐ろしい

お小遣い帳ならその程度で十分じゃね？

整数型で金勘定は別におかしくないと思うが

利率計算は十進でやらんとおこられるんだってさ。

そろそろ契約書や法律、約款も2進数で書いてくれたらいいのにな。

定数じゃなくて方程式で書けばいいんじゃね。

方程式の貨幣が流通するならそれもアリだね。

「おじさん、このりんごいくら？」
「x^3-3x^2+5円だよ。」
「はい、2x^3。」
「おつりは……はいx^3+3x^2-5円だよ。まいどー。」
「ありがとー。」

舌噛むと思う。

GF(2)で考えろや

おいおい。

保守

□！！！これを見た貴方は３日以内に死にます！！！■
■死にたくなければ、このレスをコピーして他のスレに　□
□１０回貼り付けて下さい。１時間以内にです！もし無　■
■した場合は、今日寝ている間に富子さんがやってきて□
□貴方の首を絞めに来ます。富子さんは太平洋戦争の■
■時に16歳という若さで亡くなった女の子で、未だに成 □
□仏していないそうです。信じる信じないは貴方次第。　■
■今年になってからこのレスを無視した人で、“呪われ □
□て死亡した人”が続出しています。これは富子さんの ■
■呪い。呪われて死んでもいいのならこれを無視するこ□
□とでしょうね。　　　　　　　　　　　　　　　　　　　　　　　　■
■――貴方がこうしているうちに富子さんが後ろから見□
□ていますよ…。　　　　　　　　　　　　　　　　　　　　　　　■
■□■□■□■□■□■□■□■□■□■□■□■□

+0.0 と -0.0 をビットパターンを見ずにC言語で識別する方法はありませんでしょうか？

一応 x を +0.0 もしくは -0.0 としたとき atan( x, -1.0 ) の符号で識別できますけれど，
もっと良い方法はありますかね？

1÷(+0)は正の無限大で
1÷(-0)は負の無限大だな。
状況によってはトラップになるかもしれない。

あ，すいません．重要な要求書き忘れてました．
signal や浮動少数例外を発生させない well-defined な演算でやりたいんです．

if(x < 0) とかではダメなの？

>>845
いや，それは +0.0 も -0.0 も偽を返すんじゃなかったでしたっけ？

どっちにしろローレベルではビットパターンを比較するしかないでしょ。
定数+0.0とXORをとって0かそうでないかで分岐する。
インラインアセンブラで書くと、
movやらxorやらjzなどはどれも高速に実行できるので効率的でしょう。
atanだと相当クロック数かかりそう。

>>842
<float.h>かどこかにそれ用のマクロかなにかあるんじゃないの？
その中でビットパターンを見てるんだとしても、
自分で書いたコードじゃないから許せるだろ。

>>817-823
おまいら、話の焦点どこいった。

途中の計算精度を上げる意味が無いって言うのは、
例えば結果として32bitの計算精度がほしい場合に、内部で64bitあれば十分だとする。
すると、わざわざ内部で128bitとかで演算するのは意味が無いっていう話では？

必要な計算精度と、内部の計算精度を混同しているだろ、>>819>>821

>>842
>+0.0 と -0.0 をビットパターンを見ずにC言語で識別する方法はありませんでしょうか？

if (hoge == +0.0)

or

if (hoge == -0.0)

じゃダメなんだっけ？

そういう、誰でも思いつく方法は、
ダメなんだろうなと、想像がつくと思うが・・・

そういう、誰でも思いつく上に試すのが簡単な例なら、
せめて自分で試してみて
うまくいってから、書きこんでくれ

(´・ω・｀) -0.0と+0.0が等しいのはなんでだろん。

IEEE754の定義を見るか、x86使ってるのならCPUマニュアルを
見ればいいな。

>852
だってどっちも0じゃん
てかatan( x, -1.0 )の意味わかんね、なんで引数２つ
-Infにして判定するのが-0.0存在理由からして正しいきがす
これだった十分にwell-definedとおもお

>>855
日本語でおｋ

>>855
英語でもおk

あのー、IA-32限定でつかぬことをお伺いしますが、
割り込みハンドラやタスクスイッチって、
FPUやらMMXやらSSEやらのレジスタ全部退避しないといけないんですか？
みんなやってるんですか？

当然

>>858
やらないで済むような特殊なシステムならやらないのかもね。

古いPentiumの人はどうすればいいのでしょう。
タスクスイッチ入る度にSSEの有無を判定しているのかなぁ。
それとも起動時に一度だけ判定して全てのタスクスイッチのコードを差し替えるとか…

Linuxとか、浮動小数演算アリのスレッドとナシのスレッドとかちゃんと区別してるのかなぁ。

RTLinuxだとタスクスイッチのコストを下げるために
デフォルトでFPU使用不可にしてFPUレジスタの退避をしないはず。
パッチ見て確かみてみろ！