Orz日記 by Akio Morita

_ [SAD]IEEE 754 binary floating pointと decimal表示の相互変換バグを修正完了

• decimalからbinary floating point変換(Revision 2804)
• binary floating pointからdecimal変換(Revision 2814)

実装には、ISO C89のstrtodとDavid M. Gayの dtoaを使っています。

ISO Cにstrtodが有るのに逆関数が存在しないのは片手落ちだと思う

昔の日記にある例だと

FFS;
l = {
  11.11111111111,
  11.111111111111,
  11.1111111111111,
  11.11111111111111,
  11.111111111111111,
  11.1111111111111111,
  11.11111111111111111,
  11.111111111111111111,
  11.1111111111111111111,
  11.11111111111111111111,
  11.111111111111111111111,
  11.1111111111111111111111,
  11.11111111111111111111111,
  11.111111111111111111111111,
  11.1111111111111111111111111,
  11.11111111111111111111111111,
  11.111111111111111111111111111,
  11.1111111111111111111111111111,
  11.11111111111111111111111111111,
  11.111111111111111111111111111111,
  11.1111111111111111111111111111111,
  11.11111111111111111111111111111111,
  Null[]};
Scan[With[{a = #}, Print[Map[SameQ[a, #]&, l]]]&, l]; Exit[];
{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
{0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
{0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}

String2RealConvTest[max_Real:40] := Module[{reference, min, loop, s, i},
  reference = 1 / 11;
  s = "0.";
  loop = "09";
  min = 1;

  Table[(s = s//loop[1 + Mod[i - 1, StringLength[loop]]];
    Print[StringFill[s, " ", max + 2], " - 1 / 9 -> ",
      ToExpression[s] - reference]), {i, min, max}]];

String2RealConvTest[]; Exit[];
0.0                                        - 1 / 9 -> -.09090909090909091
0.09                                       - 1 / 9 -> -.0009090909090909149
0.090                                      - 1 / 9 -> -.0009090909090909149
0.0909                                     - 1 / 9 -> -9.090909090916921e-06
0.09090                                    - 1 / 9 -> -9.090909090916921e-06
0.090909                                   - 1 / 9 -> -9.090909090792021e-08
0.0909090                                  - 1 / 9 -> -9.090909090792021e-08
0.09090909                                 - 1 / 9 -> -9.090909136588721e-10
0.090909090                                - 1 / 9 -> -9.090909136588721e-10
0.0909090909                               - 1 / 9 -> -9.090908581477208e-12
0.09090909090                              - 1 / 9 -> -9.090908581477208e-12
0.090909090909                             - 1 / 9 -> -9.09133879289925e-14
0.0909090909090                            - 1 / 9 -> -9.09133879289925e-14
0.09090909090909                           - 1 / 9 -> -9.159339953157541e-16
0.090909090909090                          - 1 / 9 -> -9.159339953157541e-16
0.0909090909090909                         - 1 / 9 -> -1.3877787807814457e-17
0.09090909090909090                        - 1 / 9 -> -1.3877787807814457e-17
0.090909090909090909                       - 1 / 9 -> 0
0.0909090909090909090                      - 1 / 9 -> 0
0.09090909090909090909                     - 1 / 9 -> 0
0.090909090909090909090                    - 1 / 9 -> 0
0.0909090909090909090909                   - 1 / 9 -> 0
0.09090909090909090909090                  - 1 / 9 -> 0
0.090909090909090909090909                 - 1 / 9 -> 0
0.0909090909090909090909090                - 1 / 9 -> 0
0.09090909090909090909090909               - 1 / 9 -> 0
0.090909090909090909090909090              - 1 / 9 -> 0
0.0909090909090909090909090909             - 1 / 9 -> 0
0.09090909090909090909090909090            - 1 / 9 -> 0
0.090909090909090909090909090909           - 1 / 9 -> 0
0.0909090909090909090909090909090          - 1 / 9 -> 0
0.09090909090909090909090909090909         - 1 / 9 -> 0
0.090909090909090909090909090909090        - 1 / 9 -> 0
0.0909090909090909090909090909090909       - 1 / 9 -> 0
0.09090909090909090909090909090909090      - 1 / 9 -> 0
0.090909090909090909090909090909090909     - 1 / 9 -> 0
0.0909090909090909090909090909090909090    - 1 / 9 -> 0
0.09090909090909090909090909090909090909   - 1 / 9 -> 0
0.090909090909090909090909090909090909090  - 1 / 9 -> 0
0.0909090909090909090909090909090909090909 - 1 / 9 -> 0

String2RealConvTest[max_Real:10] := Module[{x, s, i}, StandardForm[
  x = 1 - 1e-3;
  Table[(x = (1 + x) / 2;
    s = ToString[x];
    Print[("   "//ToString[i])[-3,-1],
      ": x=", x, " s=", s, " diff=", ToExpression[s] - x];
    ), {i, 1, max}];
  ]];
String2RealConvTest[45]; Exit[0];
  1: x=.9995 s=.9995 diff=0
  2: x=.99975 s=.99975 diff=0
  3: x=.9998750000000001 s=.9998750000000001 diff=0
  4: x=.9999375 s=.9999375 diff=0
  5: x=.9999687500000001 s=.9999687500000001 diff=0
  6: x=.999984375 s=.999984375 diff=0
  7: x=.9999921875 s=.9999921875 diff=0
  8: x=.99999609375 s=.99999609375 diff=0
  9: x=.999998046875 s=.999998046875 diff=0
 10: x=.9999990234375 s=.9999990234375 diff=0
 11: x=.99999951171875 s=.99999951171875 diff=0
 12: x=.999999755859375 s=.999999755859375 diff=0
 13: x=.9999998779296875 s=.9999998779296875 diff=0
 14: x=.9999999389648437 s=.9999999389648437 diff=0
 15: x=.9999999694824219 s=.9999999694824219 diff=0
 16: x=.9999999847412109 s=.9999999847412109 diff=0
 17: x=.9999999923706054 s=.9999999923706054 diff=0
 18: x=.9999999961853028 s=.9999999961853028 diff=0
 19: x=.9999999980926514 s=.9999999980926514 diff=0
 20: x=.9999999990463257 s=.9999999990463257 diff=0
 21: x=.9999999995231629 s=.9999999995231629 diff=0
 22: x=.9999999997615814 s=.9999999997615814 diff=0
 23: x=.9999999998807907 s=.9999999998807907 diff=0
 24: x=.9999999999403953 s=.9999999999403953 diff=0
 25: x=.9999999999701976 s=.9999999999701976 diff=0
 26: x=.9999999999850988 s=.9999999999850988 diff=0
 27: x=.9999999999925494 s=.9999999999925494 diff=0
 28: x=.9999999999962748 s=.9999999999962748 diff=0
 29: x=.9999999999981374 s=.9999999999981374 diff=0
 30: x=.9999999999990687 s=.9999999999990687 diff=0
 31: x=.9999999999995344 s=.9999999999995344 diff=0
 32: x=.9999999999997672 s=.9999999999997672 diff=0
 33: x=.9999999999998836 s=.9999999999998836 diff=0
 34: x=.9999999999999418 s=.9999999999999418 diff=0
 35: x=.9999999999999709 s=.9999999999999709 diff=0
 36: x=.9999999999999855 s=.9999999999999855 diff=0
 37: x=.9999999999999927 s=.9999999999999927 diff=0
 38: x=.9999999999999963 s=.9999999999999963 diff=0
 39: x=.9999999999999982 s=.9999999999999982 diff=0
 40: x=.9999999999999991 s=.9999999999999991 diff=0
 41: x=.9999999999999996 s=.9999999999999996 diff=0
 42: x=.9999999999999998 s=.9999999999999998 diff=0
 43: x=.9999999999999999 s=.9999999999999999 diff=0
 44: x=1 s=1 diff=0
 45: x=1 s=1 diff=0

_ [SAD]Ticket-16は根が深い

Holdした式が勝手に評価されるのは、構文解析器がtfestk()@src/tfeval.fで スタック上で式を組み立てる際に使うtfcomposefull()@src/tfeval.fの内部で tfcomposfun()とtfcomposeoper()で簡約しているためなので、 以下のパッチで抑制できる。

Index: src/tfeval.f
===================================================================
--- src/tfeval.f        (revision 2812)
+++ src/tfeval.f        (working copy)
@@ -820,6 +820,7 @@
      $     itx,irtc,ith,iah,isp0
       real*8 vx
       logical*4 tfconstq,tfheldq
+      go to 10
       if(isp .ne. isp1 .and. rlist(iaximmediate) .ne. 0.d0)then
         if(ith .eq. ntfoper)then
           if(iah .gt. mtfend)then

だが、ReleaseHoldとEvaluate絡みの動作はおかしいままである。

特に、EvaluateはPackages/init.nで定義されているが、 組み込み関数に対しても作用しなければならないので無理が有る。 (Holdは組み込み関数)

_ [SAD]ReleaseHold

SADScriptの実装とMathematicaのマニュアルを見る限り、 SAD/Tkinterマニュアルの以下の記述は間違いである。

• 引き数が上の様に頭部にHoldを持たない場合、ReleaseHold[式1] は式1を評価し、その結果を返します

Mathematicaのマニュアルによれば、「複数のレベルにわたりHold等が 適用されている場合でも、ReleaseHoldは1つのレベルからしか Hold等を除去しない。Hold等がネストしている個所は 無視される。」らしい。

In[]  := ReleaseHold[{2, Hold[1 + 1]}]
Out[] := {2, 2}

問題は、一つのレベルの解釈論で...

In[]  := ReleaseHold[{Hold[Sin[1]],Hold[Hold[Cos[1]]],{Hold[Sin[2]]}}]

はどのようにHoldを外すべきであろうか？ (注: 最後のHoldはリストの階層的に一段深い階層に存在している)

例えば、「一つのレベル」を式全体に通用する階数指定子だと考えるか、 ここの部分式を辿る際の階数指定子と考えるかで次のような解釈がありえる。

1. 式を上から深さ方向に辿るときに最初に出会うHoldをすべて解除する
2. 式を上から深さ方向に辿るときに最初に出会うHoldと同じ深さのHoldのみを解除する

SADScriptでのReleaseHoldは、現時点では(1)で実装されている。