1: //========================================================================================
     2: //  EFPBox.java
     3: //    en:Floating-point number box -- Floating-point calculation and floating-point registers
     4: //    ja:浮動小数点数箱 -- 浮動小数点演算と浮動小数点レジスタ
     5: //  Copyright (C) 2003-2025 Makoto Kamada
     6: //
     7: //  This file is part of the XEiJ (X68000 Emulator in Java).
     8: //  You can use, modify and redistribute the XEiJ if the conditions are met.
     9: //  Read the XEiJ License for more details.
    10: //  https://stdkmd.net/xeij/
    11: //========================================================================================
    12: 
    13: package xeij;
    14: 
    15: import java.lang.*;  //Boolean,Character,Class,Comparable,Double,Exception,Float,IllegalArgumentException,Integer,Long,Math,Number,Object,Runnable,SecurityException,String,StringBuilder,System
    16: import java.util.*;  //ArrayList,Arrays,Calendar,GregorianCalendar,HashMap,Map,Map.Entry,Timer,TimerTask,TreeMap
    17: 
    18: public class EFPBox {
    19: 
    20:   //浮動小数点拡張命令
    21:   //  実験のみ。常用しないこと
    22:   //  $xx70: FLGAMMA *m,FPn
    23:   //  $xx71: FTGAMMA *m,FPn
    24:   //  三角関数
    25:   //    sin    正弦 sine サイン
    26:   //    cos    余弦 cosine コサイン
    27:   //    tan    正接 tangent タンジェント
    28:   //    cot    余接 cotangent コタンジェント
    29:   //    sec    正割 secant セカント
    30:   //    csc    余割 cosecant コセカント
    31:   //  逆三角関数
    32:   //    asin   逆正弦 inverse sine インバースサイン
    33:   //    acos   逆余弦 inverse cosine インバースコサイン
    34:   //    atan   逆正接 inverse tangent インバースタンジェント
    35:   //    acot   逆余接 inverse cotangent インバースコタンジェント
    36:   //    asec   逆正割 inverse secant インバースセカント
    37:   //    acsc   逆余割 inverse cosecant インバースコセカント
    38:   //  双曲線関数
    39:   //    sinh   双曲線正弦 hyperbolic sine ハイパボリックサイン
    40:   //    cosh   双曲線余弦 hyperbolic cosine ハイパボリックコサイン
    41:   //    tanh   双曲線正接 hyperbolic tangent ハイパボリックタンジェント
    42:   //    coth   双曲線余接 hyperbolic cotangent ハイパボリックコタンジェント
    43:   //    sech   双曲線正割 hyperbolic secant ハイパボリックセカント
    44:   //    csch   双曲線余割 hyperbolic cosecant ハイパボリックコセカント
    45:   //  逆双曲線関数
    46:   //    asinh  逆双曲線正弦 inverse hyperbolic sine インバースハイパボリックサイン
    47:   //    acosh  逆双曲線余弦 inverse hyperbolic cosine インバースハイパボリックコサイン
    48:   //    atanh  逆双曲線正接 inverse hyperbolic tangent インバースハイパボリックタンジェント
    49:   //    acoth  逆双曲線余接 inverse hyperbolic cotangent インバースハイパボリックコタンジェント
    50:   //    asech  逆双曲線正割 inverse hyperbolic secant インバースハイパボリックセカント
    51:   //    acsch  逆双曲線余割 inverse hyperbolic cosecant インバースハイパボリックコセカント
    52:   //  その他
    53:   //    lgamma  ログガンマ関数
    54:   //    tgamma  ガンマ関数
    55:   public static final boolean EPB_EXTRA_OPERATION = true;  //true=浮動小数点拡張命令を追加する
    56: 
    57:   //------------------------------------------------------------------------
    58:   //モード
    59:   public static final int EPB_MODE_MC68881  = 1 << 1;  //MC68881
    60:   public static final int EPB_MODE_MC68882  = 1 << 2;  //MC68882
    61:   public static final int EPB_MODE_MC68060  = 1 << 6;  //MC68060
    62:   public static final int EPB_MODE_FULLSPEC = EPB_MODE_MC68881 | EPB_MODE_MC68882 | EPB_MODE_MC68060;
    63:   public static final int EPB_MODE_EXTENDED = 1 << 8;  //拡張精度
    64:   public static final int EPB_MODE_TRIPLE   = 1 << 9;  //三倍精度
    65:   public int epbMode;
    66: 
    67:   //------------------------------------------------------------------------
    68:   //フラグ flg
    69:   public static final int P = 0 << 31;  //+
    70:   public static final int M = 1 << 31;  //-
    71:   public static final int Z = 1 << 30;  //±0
    72:   public static final int I = 1 << 29;  //±Inf
    73:   public static final int N = 1 << 28;  //±NaN
    74: 
    75:   //------------------------------------------------------------------------
    76:   //FPCR
    77:   //  exception enable byte
    78:   public static final int EPB_FPCR_BS = 1 << 15;  //BSUN   branch/set on unordered
    79:   public static final int EPB_FPCR_SN = 1 << 14;  //SNAN   signaling not a number
    80:   public static final int EPB_FPCR_OE = 1 << 13;  //OPERR  operand error
    81:   public static final int EPB_FPCR_OF = 1 << 12;  //OVFL   overflow
    82:   public static final int EPB_FPCR_UF = 1 << 11;  //UNFL   underflow
    83:   public static final int EPB_FPCR_DZ = 1 << 10;  //DZ     divide by zero
    84:   public static final int EPB_FPCR_X2 = 1 <<  9;  //INEX2  inexact operation
    85:   public static final int EPB_FPCR_X1 = 1 <<  8;  //INEX1  inexact decimal input
    86:   //  rounding precision
    87:   public static final int EPB_FPCR_PX = 0 << 6;  //extended
    88:   public static final int EPB_FPCR_PS = 1 << 6;  //single
    89:   public static final int EPB_FPCR_PD = 2 << 6;  //double
    90:   //                                    3 << 6;  //double
    91:   //  rounding mode
    92:   public static final int EPB_FPCR_RN = 0 << 4;  //to nearest
    93:   public static final int EPB_FPCR_RZ = 1 << 4;  //toward zero
    94:   public static final int EPB_FPCR_RM = 2 << 4;  //toward minus infinity
    95:   public static final int EPB_FPCR_RP = 3 << 4;  //toward plus infinity
    96:   public static final int EPB_FPCR_ALL = 0x0000fff0;
    97:   public int epbFpcr;
    98: 
    99:   //------------------------------------------------------------------------
   100:   //FPSR
   101:   //  FPSRのEXCとAEXCを同時にセットする方法はAEXC_UNFL|=EXC_UNFL&EXC_INEX2の&を処理しにくいので、
   102:   //  命令実行後にテーブルを使ってEXCをAEXCに反映させる方法に変更した
   103:   //  condition code byte
   104:   public static final int EPB_FPSR_M = 1 << 27;  //N    negative
   105:   public static final int EPB_FPSR_Z = 1 << 26;  //Z    zero
   106:   public static final int EPB_FPSR_I = 1 << 25;  //INF  infinity
   107:   public static final int EPB_FPSR_N = 1 << 24;  //NAN  not a number or unordered
   108:   //  quotient byte
   109:   public static final int EPB_FPSR_S = 1 << 23;  //sign of quotient
   110:   public static final int EPB_FPSR_Q = 127 << 16;  //quotient
   111:   //  exception status byte
   112:   public static final int EPB_FPSR_BS = 1 << 15;  //BSUN   branch/set on unordered
   113:   public static final int EPB_FPSR_SN = 1 << 14;  //SNAN   signaling not a number
   114:   public static final int EPB_FPSR_OE = 1 << 13;  //OPERR  operand error
   115:   public static final int EPB_FPSR_OF = 1 << 12;  //OVFL   overflow
   116:   public static final int EPB_FPSR_UF = 1 << 11;  //UNFL   underflow
   117:   public static final int EPB_FPSR_DZ = 1 << 10;  //DZ     divide by zero
   118:   public static final int EPB_FPSR_X2 = 1 <<  9;  //INEX2  inexact operation
   119:   public static final int EPB_FPSR_X1 = 1 <<  8;  //INEX1  inexact decimal input
   120:   //  accrued exception byte
   121:   public static final int EPB_FPSR_AV = 1 << 7;  //IOP   invalid operation  AV|=BS|SN|OE
   122:   public static final int EPB_FPSR_AO = 1 << 6;  //OVFL  overflow           AO|=OF
   123:   public static final int EPB_FPSR_AU = 1 << 5;  //UNFL  underflow          AU|=UF&X2
   124:   public static final int EPB_FPSR_AZ = 1 << 4;  //DZ    divide by zero     AZ|=DZ
   125:   public static final int EPB_FPSR_AX = 1 << 3;  //INEX  inexact            AX|=OF|X2|X1
   126:   public static final int EPB_FPSR_ALL = 0x0ffffff8;
   127:   public int epbFpsr;
   128: 
   129:   //------------------------------------------------------------------------
   130:   //FPIAR instruction address register
   131:   public int epbFpiar;
   132: 
   133:   //------------------------------------------------------------------------
   134:   //商
   135:   public int epbQuotient;  //remの商の下位32bit
   136: 
   137:   //------------------------------------------------------------------------
   138:   //丸め桁数
   139:   public static final int EPB_PREC_EXD  = 0;  //extended
   140:   public static final int EPB_PREC_SGL  = 1;  //single
   141:   public static final int EPB_PREC_DBL  = 2;  //double
   142:   public static final int EPB_PREC_DBL3 = 3;  //double
   143:   //
   144:   public static final int EPB_PREC_TPL  = 4;  //triple
   145:   public static final int EPB_PREC_XSG  = 5;  //xsingle
   146:   public static final int EPB_PREC_EFP  = 6;  //efp
   147:   public int epbRoundingPrec;  //丸め桁数
   148: 
   149:   //------------------------------------------------------------------------
   150:   //丸めモード
   151:   public static final int EPB_MODE_RN = 0;  //To nearest
   152:   public static final int EPB_MODE_RZ = 1;  //Toward zero
   153:   public static final int EPB_MODE_RM = 2;  //Toward minus infinity
   154:   public static final int EPB_MODE_RP = 3;  //Toward plus infinity
   155:   public int epbRoundingMode;  //丸めモード
   156: 
   157:   //------------------------------------------------------------------------
   158:   //例外オペランド
   159:   //  例外発生時のオペランド
   160:   //  MC68060のステートフレームに書き込まれる
   161:   //  MC68060UM 6.7 FLOATING-POINT STATE FRAMESを参照
   162:   //  BSUN
   163:   //    不定
   164:   //  SNAN/OPERR/DZ
   165:   //    ソースオペランド
   166:   //  OVFL
   167:   //    中間結果。ただし指数部のバイアスが$3FFFではなくて$3FFF-$6000になる。それでも収まらなければ$0
   168:   //  UNFL
   169:   //    中間結果。ただし指数部のバイアスが$3FFFではなくて$3FFF+$6000になる。それでも収まらなければ$0
   170:   //  INEX
   171:   //    INEX単独では不定。他の例外もあればそれに従う
   172:   public int epbExceptionOperandExponent;  //extendedの指数部<<16
   173:   public long epbExceptionOperandMantissa;  //extendedの仮数部
   174:   public int epbExceptionStatusWord;  //MC68060の浮動小数点ステートフレームのステータスワード
   175: 
   176:   //------------------------------------------------------------------------
   177:   //内部丸め
   178:   //  関数が内部で他の関数を複数回呼び出すとき、途中の計算を最大精度で行うため一時的に丸め桁数と丸めモードを変更する
   179:   //  同じEFPBoxのインスタンスを複数のスレッドで同時に使用すると誤動作する可能性がある
   180:   public int epbRoundingDepth;  //深さ
   181:   public int epbRoundingOuterPrec;  //epbRoundingDepth==0のときのepbRoundingPrec
   182:   public int epbRoundingOuterMode;  //epbRoundingDepth==0のときのepbRoundingMode
   183: 
   184:   //------------------------------------------------------------------------
   185:   //レジスタ
   186:   public static final int EPB_SRC_TMP = 8;  //ソース用テンポラリレジスタ
   187:   public static final int EPB_DST_TMP = 9;  //デスティネーション用テンポラリレジスタ
   188:   public static final int EPB_CONST_START = 10;  //定数レジスタ0
   189:   public EFP[] epbFPn;  //浮動小数点レジスタ
   190: 
   191:   //------------------------------------------------------------------------
   192:   //定数
   193:   public static final HashMap<String,Integer> epbConstLongMap = new HashMap<String,Integer> ();  //ロング定数
   194:   static {
   195:     //IOCSコール名(0x00～0xff)
   196:     for (int i = 0; i < Disassembler.DIS_IOCS_NAME.length; i++) {
   197:       String name = Disassembler.DIS_IOCS_NAME[i];
   198:       if (name.length () > 0) {
   199:         epbConstLongMap.put (name.toLowerCase (), i);
   200:       }
   201:     }
   202:     //SXコール名(0xa000～0xa7ff)
   203:     for (int i = 0; i < Disassembler.DIS_SXCALL_NAME.length; i++) {
   204:       String name = Disassembler.DIS_SXCALL_NAME[i];
   205:       if (name.length () > 0) {
   206:         epbConstLongMap.put (name.toLowerCase (), 0xa000 + i);
   207:       }
   208:     }
   209:     //FEファンクションコール名(0xfe00～0xfeff)
   210:     for (int i = 0; i < Disassembler.DIS_FPACK_NAME.length; i++) {
   211:       String name = Disassembler.DIS_FPACK_NAME[i];
   212:       if (name.length () > 0) {
   213:         epbConstLongMap.put (name.toLowerCase (), 0xfe00 + i);
   214:       }
   215:     }
   216:     //DOSコール名(0xff00～0xffff)
   217:     for (int i = 0; i < Disassembler.DIS_DOS_NAME.length; i++) {
   218:       String name = Disassembler.DIS_DOS_NAME[i];
   219:       if (name.length () > 0) {
   220:         epbConstLongMap.put (name.toLowerCase (), 0xff00 + i);
   221:       }
   222:     }
   223:   }  //static
   224: 
   225:   //------------------------------------------------------------------------
   226:   //コンストラクタ
   227:   public EFPBox () {
   228:     //モード
   229:     epbMode = EPB_MODE_EXTENDED | EPB_MODE_MC68882;  //拡張精度、MC68882
   230:     //乱数
   231:     //epbRandSeed = 25214903917L;  //乱数の種(48bit)
   232:     epbRandSeed = System.currentTimeMillis () & (1L << 48) - 1L;  //乱数の種(48bit)
   233:     //浮動小数点レジスタ
   234:     epbFPn = new EFPBox.EFP[EPB_CONST_START + 128];  //FPn。[0]～[7]は汎用、[8]～[9]はテンポラリ、[10]～[137]は定数
   235:     for (int i = 0; i < epbFPn.length; i++) {
   236:       epbFPn[i] = new EFP ();
   237:     }
   238:     //定数
   239:     //  FMOVECRはFPCRのrounding precisionとrounding modeの影響を受ける
   240:     //    使用時に丸める場合は定数を予めextendedに丸めた状態で格納してはならない
   241:     //    rounding modeとrounding precisionのすべての組み合わせを展開しておいて定数の開始インデックスで区別する方法もある
   242:     //  060turboのROMはFMOVECR.X #$01,FP0の結果が0かどうかで68881と68882を見分けている
   243:     epbFPn[EPB_CONST_START + 0x00].sete (PI);       //0x00  pi
   244:     epbSetROMSub ();  //ROMオフセット0x01～0x0aを設定する
   245:     epbFPn[EPB_CONST_START + 0x0b].sete (LOG10_2);  //0x0b  log10(2)    MC68882はRNの値が間違っている
   246:     epbFPn[EPB_CONST_START + 0x0c].sete (E);        //0x0c  e           MC68882はRNの値が間違っている
   247:     epbFPn[EPB_CONST_START + 0x0d].sete (LOG2_E);   //0x0d  log2(e)
   248:     epbFPn[EPB_CONST_START + 0x0e].sete (LOG10_E);  //0x0e  log10(e)    MC68882はRPの値が間違っている。MC68882はINEX2がセットされない
   249:     epbFPn[EPB_CONST_START + 0x0f].set0 ();         //0x0f  0
   250:     epbFPn[EPB_CONST_START + 0x30].sete (LOG_2);    //0x30  log(2)
   251:     epbFPn[EPB_CONST_START + 0x31].sete (LOG_10);   //0x31  log(10)
   252:     epbFPn[EPB_CONST_START + 0x32].set1 ();         //0x32  1
   253:     epbFPn[EPB_CONST_START + 0x33].sete (TEN);      //0x33  10
   254:     epbFPn[EPB_CONST_START + 0x34].sete (TENXP1);   //0x34  10^(2^1)=10^2=100
   255:     epbFPn[EPB_CONST_START + 0x35].sete (TENXP2);   //0x35  10^(2^2)=10^4=10000
   256:     epbFPn[EPB_CONST_START + 0x36].sete (TENXP3);   //0x36  10^(2^3)=10^8=100000000
   257:     epbFPn[EPB_CONST_START + 0x37].sete (TENXP4);   //0x37  10^(2^4)=10^16
   258:     epbFPn[EPB_CONST_START + 0x38].sete (TENXP5);   //0x38  10^(2^5)=10^32
   259:     epbFPn[EPB_CONST_START + 0x39].sete (TENXP6);   //0x39  10^(2^6)=10^64
   260:     epbFPn[EPB_CONST_START + 0x3a].sete (TENXP7);   //0x3a  10^(2^7)=10^128
   261:     epbFPn[EPB_CONST_START + 0x3b].sete (TENXP8);   //0x3b  10^(2^8)=10^256
   262:     epbFPn[EPB_CONST_START + 0x3c].sete (TENXP9);   //0x3c  10^(2^9)=10^512
   263:     epbFPn[EPB_CONST_START + 0x3d].sete (TENXP10);  //0x3d  10^(2^10)=10^1024
   264:     epbFPn[EPB_CONST_START + 0x3e].sete (TENXP11);  //0x3e  10^(2^11)=10^2048
   265:     epbFPn[EPB_CONST_START + 0x3f].sete (TENXP12);  //0x3f  10^(2^12)=10^4096
   266:     //その他
   267:     epbReset ();
   268:     //コプロセッサインタフェイス
   269:     cirInit ();
   270:   }
   271: 
   272:   //epbSetROMSub ()
   273:   //  ROMオフセット0x01～0x0aを設定する
   274:   public final void epbSetROMSub () {
   275:     if ((epbMode & EPB_MODE_MC68882) != 0) {  //MC68882、フルスペック
   276:       epbFPn[EPB_CONST_START + 0x01].setx012 (0x40010000, 0xfe00068200000000L);  //0x01 (MC68882)
   277:       epbFPn[EPB_CONST_START + 0x02].setx012 (0x40010000, 0xffc0050380000000L);  //0x02 (MC68882)
   278:       //epbFPn[EPB_CONST_START + 0x03].setx012 (0x20000000, 0x7fffffff00000000L);  //0x03 (MC68882) Nがセットされる。表現できないのでNaNにする
   279:       epbFPn[EPB_CONST_START + 0x03].setnan ();
   280:       epbFPn[EPB_CONST_START + 0x04].setx012 (0x00000000, 0xffffffffffffffffL);  //0x04 (MC68882)
   281:       epbFPn[EPB_CONST_START + 0x05].setx012 (0x3c000000, 0xfffffffffffff800L);  //0x05 (MC68882)
   282:       epbFPn[EPB_CONST_START + 0x06].setx012 (0x3f800000, 0xffffff0000000000L);  //0x06 (MC68882)
   283:       //epbFPn[EPB_CONST_START + 0x07].setx012 (0x00010000, 0xf65d8d9c00000000L);  //0x07 (MC68882) Nがセットされる。表現できないのでNaNにする
   284:       epbFPn[EPB_CONST_START + 0x07].setnan ();
   285:       //epbFPn[EPB_CONST_START + 0x08].setx012 (0x7fff0000, 0x401e000000000000L);  //0x08 (MC68882) Nがセットされる。表現できないのでNaNにする
   286:       epbFPn[EPB_CONST_START + 0x08].setnan ();
   287:       epbFPn[EPB_CONST_START + 0x09].setx012 (0x43f30000, 0xe000000000000000L);  //0x09 (MC68882)
   288:       epbFPn[EPB_CONST_START + 0x0a].setx012 (0x40720000, 0xc000000000000000L);  //0x0a (MC68882)
   289:     } else {  //MC68881、MC68060
   290:       for (int offset = 0x01; offset <= 0x0a; offset++) {
   291:         epbFPn[EPB_CONST_START + offset].set0 ();
   292:       }
   293:     }
   294:   }  //epbSetROMSub(int)
   295: 
   296:   //epbFmovecr (x, offset)
   297:   //  FMOVECRの下請け
   298:   //  レジスタにROMの定数をコピーしてFPSRのコンディションコードバイトとエクセプションバイトを更新する
   299:   public void epbFmovecr (EFP x, int offset) {
   300:     //特別な場合を処理する
   301:     switch (offset) {
   302:     case 0x01:
   303:       if ((epbMode & EPB_MODE_MC68882) != 0) {  //MC68882、フルスペック
   304:         if (epbRoundingPrec == EPB_PREC_SGL) {
   305:           if (epbRoundingMode == EPB_MODE_RN ||
   306:               epbRoundingMode == EPB_MODE_RZ ||
   307:               epbRoundingMode == EPB_MODE_RM) {
   308:             //x.setx012 (0x40010000, 0xfe00068000000000L);
   309:             x.flg = P;
   310:             x.epp = 0x4001 - 0x3fff;
   311:             x.dvl = 0xfe00068000000000L;
   312:             x.cvl = 0L;
   313:             epbFpsr = epbFpsr & 0x00ff00ff | EPB_FPSR_X2;
   314:             return;
   315:           }
   316:         }
   317:       }
   318:       break;
   319:     case 0x02:
   320:       if ((epbMode & EPB_MODE_MC68882) != 0) {  //MC68882、フルスペック
   321:         if (epbRoundingPrec == EPB_PREC_SGL) {
   322:           if (epbRoundingMode == EPB_MODE_RP) {
   323:             //x.setx012 (0x40010000, 0xffc0058000000000L);
   324:             x.flg = P;
   325:             x.epp = 0x4001 - 0x3fff;
   326:             x.dvl = 0xffc0058000000000L;
   327:             x.cvl = 0L;
   328:             epbFpsr = epbFpsr & 0x00ff00ff | EPB_FPSR_X2;
   329:             return;
   330:           }
   331:         }
   332:       }
   333:       break;
   334:     case 0x03:
   335:       if ((epbMode & EPB_MODE_MC68882) != 0) {  //MC68882、フルスペック
   336:         if (epbRoundingPrec == EPB_PREC_SGL) {
   337:           if (epbRoundingMode == EPB_MODE_RN ||
   338:               epbRoundingMode == EPB_MODE_RP) {
   339:             //x.setx012 (0x20000000, 0x8000000000000000L);
   340:             x.flg = P;
   341:             x.epp = 0x2000 - 0x3fff;
   342:             x.dvl = 0x8000000000000000L;
   343:             x.cvl = 0L;
   344:             epbFpsr = epbFpsr & 0x00ff00ff | EPB_FPSR_I | EPB_FPSR_X2;
   345:           } else {
   346:             //x.setx012 (0x20000000, 0x7fffff0000000000L);
   347:             x.flg = P;
   348:             x.epp = 0x2000 - 0x3fff;
   349:             x.dvl = 0x7fffff0000000000L;
   350:             x.cvl = 0L;
   351:             epbFpsr = epbFpsr & 0x00ff00ff | EPB_FPSR_N | EPB_FPSR_X2;
   352:           }
   353:         } else {
   354:           //x.setx012 (0x20000000, 0x7fffffff00000000L);
   355:           x.flg = P;
   356:           x.epp = 0x2000 - 0x3fff;
   357:           x.dvl = 0x7fffffff00000000L;
   358:           x.cvl = 0L;
   359:           epbFpsr = epbFpsr & 0x00ff00ff | EPB_FPSR_N;
   360:         }
   361:         return;
   362:       }
   363:       break;
   364:     case 0x07:
   365:       if ((epbMode & EPB_MODE_MC68882) != 0) {  //MC68882、フルスペック
   366:         if (epbRoundingPrec == EPB_PREC_SGL) {
   367:           if (epbRoundingMode == EPB_MODE_RN ||
   368:               epbRoundingMode == EPB_MODE_RZ ||
   369:               epbRoundingMode == EPB_MODE_RM) {
   370:             //x.setx012 (0x00010000, 0xf65d8d8000000000L);
   371:             x.flg = P;
   372:             x.epp = 0x0001 - 0x3fff;
   373:             x.dvl = 0xf65d8d8000000000L;
   374:             x.cvl = 0L;
   375:             epbFpsr = epbFpsr & 0x00ff00ff | EPB_FPSR_N | EPB_FPSR_X2;
   376:           } else {
   377:             //x.setx012 (0x00010000, 0xf65d8e0000000000L);
   378:             x.flg = P;
   379:             x.epp = 0x0001 - 0x3fff;
   380:             x.dvl = 0xf65d8e0000000000L;
   381:             x.cvl = 0L;
   382:             epbFpsr = epbFpsr & 0x00ff00ff | EPB_FPSR_N | EPB_FPSR_X2;
   383:           }
   384:         } else {
   385:           //x.setx012 (0x00010000, 0xf65d8d9c00000000L);
   386:           x.flg = P;
   387:           x.epp = 0x0001 - 0x3fff;
   388:           x.dvl = 0xf65d8d9c00000000L;
   389:           x.cvl = 0L;
   390:           epbFpsr = epbFpsr & 0x00ff00ff | EPB_FPSR_N;
   391:         }
   392:         return;
   393:       }
   394:       break;
   395:     case 0x08:
   396:       if ((epbMode & EPB_MODE_MC68882) != 0) {  //MC68882、フルスペック
   397:         //x.setx012 (0x7fff0000, 0x401e000000000000L);
   398:         x.flg = N;
   399:         x.epp = 0;
   400:         x.dvl = 0L;
   401:         x.cvl = 0L;
   402:         epbFpsr = epbFpsr & 0x00ff00ff | EPB_FPSR_N;
   403:         return;
   404:       }
   405:       break;
   406:     case 0x0b:
   407:       if (epbRoundingPrec == EPB_PREC_EXD) {
   408:         if (epbRoundingMode == EPB_MODE_RN) {
   409:           //x.setx012 (0x3ffd0000, 0x9a209a84fbcff798L);
   410:           x.flg = P;
   411:           x.epp = 0x3ffd - 0x3fff;
   412:           x.dvl = 0x9a209a84fbcff798L;
   413:           x.cvl = 0L;
   414:           epbFpsr = epbFpsr & 0x00ff00ff | EPB_FPSR_X2;
   415:           return;
   416:         }
   417:       }
   418:       break;
   419:     case 0x0c:
   420:       if (epbRoundingPrec == EPB_PREC_EXD) {
   421:         if (epbRoundingMode == EPB_MODE_RN) {
   422:           //x.setx012 (0x40000000, 0xadf85458a2bb4a9aL);
   423:           x.flg = P;
   424:           x.epp = 0x4000 - 0x3fff;
   425:           x.dvl = 0xadf85458a2bb4a9aL;
   426:           x.cvl = 0L;
   427:           epbFpsr = epbFpsr & 0x00ff00ff | EPB_FPSR_X2;
   428:           return;
   429:         }
   430:       }
   431:       break;
   432:     case 0x0e:
   433:       if (epbRoundingPrec == EPB_PREC_EXD) {
   434:         //x.setx012 (0x3ffd0000, 0xde5bd8a937287195L);
   435:         x.flg = P;
   436:         x.epp = 0x3ffd - 0x3fff;
   437:         x.dvl = 0xde5bd8a937287195L;
   438:         x.cvl = 0L;
   439:         epbFpsr = epbFpsr & 0x00ff00ff;
   440:         return;
   441:       }
   442:       break;
   443:     }
   444:     //ROMからコピーする
   445:     x.sete (epbFPn[EPB_CONST_START + offset]);
   446:     //FPSRのコンディションコードバイトを設定してエクセプションバイトをクリアする
   447:     epbFpsr = epbFpsr & 0x00ff00ff | x.flg >>> 4;
   448:     //仮数部を丸める。X2がセットされる
   449:     if (epbRoundingPrec == EPB_PREC_EXD) {
   450:       x.roundmanx (epbRoundingMode);
   451:     } else if (epbRoundingPrec == EPB_PREC_SGL) {
   452:       x.roundmanf (epbRoundingMode);
   453:     } else if (epbRoundingPrec == EPB_PREC_DBL ||
   454:                epbRoundingPrec == EPB_PREC_DBL3) {
   455:       x.roundmand (epbRoundingMode);
   456:     } else if (epbRoundingPrec == EPB_PREC_TPL) {
   457:       x.roundmany (epbRoundingMode);
   458:     }
   459:   }  //epbFmovecr(EFP,int)
   460: 
   461:   //epbSetMC68881 ()
   462:   //  MC68881モード
   463:   public void epbSetMC68881 () {
   464:     epbMode = epbMode & ~(EPB_MODE_MC68882 | EPB_MODE_MC68060) | EPB_MODE_MC68881;
   465:     epbSetROMSub ();
   466:   }  //epbSetMC68881()
   467: 
   468:   //epbSetMC68882 ()
   469:   //  MC68882モード
   470:   public void epbSetMC68882 () {
   471:     epbMode = epbMode & ~(EPB_MODE_MC68881 | EPB_MODE_MC68060) | EPB_MODE_MC68882;
   472:     epbSetROMSub ();
   473:   }  //epbSetMC68882()
   474: 
   475:   //epbSetMC68060 ()
   476:   //  MC68060モード
   477:   public void epbSetMC68060 () {
   478:     epbMode = epbMode & ~(EPB_MODE_MC68881 | EPB_MODE_MC68882) | EPB_MODE_MC68060;
   479:     epbSetROMSub ();
   480:   }  //epbSetMC68060()
   481: 
   482:   //epbSetFullSpec ()
   483:   //  フルスペックモード
   484:   public void epbSetFullSpec () {
   485:     epbMode |= EPB_MODE_FULLSPEC;
   486:     epbSetROMSub ();
   487:   }  //epbSetFullSpec()
   488: 
   489:   //epbIsFullSpec ()
   490:   //  フルスペックモードか
   491:   public boolean epbIsFullSpec () {
   492:     return (epbMode & EPB_MODE_FULLSPEC) == EPB_MODE_FULLSPEC;
   493:   }  //epbIsFullSpec()
   494: 
   495:   //epbSetExtended ()
   496:   //  拡張精度モード
   497:   public void epbSetExtended () {
   498:     epbMode = epbMode & ~EPB_MODE_TRIPLE | EPB_MODE_EXTENDED;
   499:   }  //epbSetExtended()
   500: 
   501:   //epbSetTriple ()
   502:   //  三倍精度モード
   503:   public void epbSetTriple () {
   504:     epbMode = epbMode & ~EPB_MODE_EXTENDED | EPB_MODE_TRIPLE;
   505:   }  //epbSetTriple()
   506: 
   507:   //epbIsTriple ()
   508:   //  三倍精度モードか
   509:   public boolean epbIsTriple () {
   510:     return (epbMode & EPB_MODE_TRIPLE) != 0;
   511:   }  //epbIsTriple()
   512: 
   513:   //epbReset ()
   514:   //  リセット
   515:   public final void epbReset () {
   516:     //浮動小数点汎用レジスタ
   517:     for (int n = 0; n < 8; n++) {
   518:       epbFPn[n].setnan ();  //ヌルステートをFRESTOREするとNon-signaling NaNになるのでそれに合わせる
   519:     }
   520:     //浮動小数点制御レジスタ
   521:     epbFpcr = 0;
   522:     epbFpsr = 0;
   523:     epbFpiar = 0;
   524:     epbQuotient = 0;
   525:     epbRoundingPrec = EPB_PREC_EFP;
   526:     epbRoundingMode = EPB_MODE_RN;
   527:     epbRoundingDepth = 0;
   528:     epbRoundingOuterPrec = EPB_PREC_EFP;
   529:     epbRoundingOuterMode = EPB_MODE_RN;
   530:     //浮動小数点例外
   531:     epbExceptionOperandExponent = 0;
   532:     epbExceptionOperandMantissa = 0x0000000000000000L;
   533:     epbExceptionStatusWord = 0;
   534:     //コプロセッサインタフェイス
   535:     cirReset ();
   536:   }
   537: 
   538:   //epbSetRoundingPrec (prec)
   539:   //  丸め桁数を設定する
   540:   //  precはEPB_PREC_EXD,EPB_PREC_SGL,EPB_PREC_DBL,EPB_PREC_DBL3,EPB_PREC_XSGのいずれか
   541:   //  三倍精度が選択されているときEPB_PREC_EXDをEPB_PREC_TPLに読み替える
   542:   public void epbSetRoundingPrec (int prec) {
   543:     epbRoundingPrec = prec == EPB_PREC_EXD && (epbMode & EPB_MODE_TRIPLE) != 0 ? EPB_PREC_TPL : prec;
   544:   }  //epbSetRoundingPrec(int)
   545: 
   546:   //epbSetRoundingMode (mode)
   547:   //  丸めモードを設定する
   548:   //  modeはEPB_MODE_RN,EPB_MODE_RZ,EPB_MODE_RM,EPB_MODE_RPのいずれか
   549:   public void epbSetRoundingMode (int mode) {
   550:     epbRoundingMode = mode;
   551:   }  //epbSetRoundingMode(int)
   552: 
   553:   //------------------------------------------------------------------------
   554:   //乱数ジェネレータ
   555:   //  java.util.Randomと同じ線形合同法を用いる
   556:   public long epbRandSeed;
   557: 
   558:   //epbRandStart (n)
   559:   //  乱数列の初期化
   560:   public void epbRandStart (long n) {
   561:     epbRandSeed = (n ^ 25214903917L) & (1L << 48) - 1L;
   562:   }  //epbRandStart(long)
   563: 
   564:   //l = epbRand48 ()
   565:   //  48bit乱数の取得
   566:   public long epbRand48 () {
   567:     return epbRandSeed = epbRandSeed * 25214903917L + 11L & (1L << 48) - 1L;
   568:   }  //epbRand48()
   569: 
   570:   //i = epbRandInt ()
   571:   //  int乱数の取得
   572:   public int epbRandInt () {
   573:     return (int) (epbRand48 () >>> 16);
   574:   }  //epbRandInt()
   575: 
   576:   //l = epbRandLong ()
   577:   //  long乱数の取得
   578:   public long epbRandLong () {
   579:     return epbRand48 () >>> 16 << 32 | epbRand48 () >>> 16;
   580:   }  //epbRandLong()
   581: 
   582:   //------------------------------------------------------------------------
   583:   //epbMakeCmpTable ()
   584:   //  cmp,compare,eq,ge,gt,le,lt,neで引数のどちらかが±0,±Inf,NaNの場合の結果を求めるためのテーブルを作る
   585:   public static void epbMakeCmpTable () {
   586:     int[] fa = new int[] {
   587:       P | Z,
   588:       M | Z,
   589:       P | I,
   590:       M | I,
   591:       N,
   592:       P,
   593:       M,
   594:     };
   595:     double[] da = new double[] {
   596:       +0.0,
   597:       -0.0,
   598:       Double.POSITIVE_INFINITY,
   599:       Double.NEGATIVE_INFINITY,
   600:       Double.NaN,
   601:       +1.0,
   602:       -1.0,
   603:     };
   604:     String[] na = { "CMP", "COMPARE", "EQ", "GE", "GT", "LE", "LT", "NE" };
   605:     int[][] ba = new int[na.length][];
   606:     for (int j = 0; j < na.length; j++) {
   607:       ba[j] = new int[16];
   608:     }
   609:     for (int xi = 0; xi < fa.length; xi++) {
   610:       int xk = fa[xi] >>> 28;
   611:       double x = da[xi];
   612:       for (int yi = 0; yi < fa.length; yi++) {
   613:         int yk = fa[yi] >>> 28 - 1;
   614:         double y = da[yi];
   615:         ba[0][xk] |= (Double.isNaN (x) || Double.isNaN (y) || x == y ? 0 : x < y ? -1 : 1) << 30 >>> yk;  //cmp
   616:         ba[1][xk] |= Double.compare (x, y) << 30 >>> yk;  //compare
   617:         ba[2][xk] |= (x == y ? -1 : 0) << 30 >>> yk;  //eq
   618:         ba[3][xk] |= (x >= y ? -1 : 0) << 30 >>> yk;  //ge
   619:         ba[4][xk] |= (x > y ? -1 : 0) << 30 >>> yk;  //gt
   620:         ba[5][xk] |= (x <= y ? -1 : 0) << 30 >>> yk;  //le
   621:         ba[6][xk] |= (x < y ? -1 : 0) << 30 >>> yk;  //lt
   622:         ba[7][xk] |= (x != y ? -1 : 0) << 30 >>> yk;  //ne
   623:       }
   624:     }
   625:     for (int ni = 0; ni < na.length; ni++) {
   626:       System.out.print ("    protected static final int[] EFP_" + na[ni] + "_TABLE = { ");
   627:       for (int xk = 0; xk < 16; xk++) {
   628:         System.out.print (ba[ni][xk]);
   629:         if (xk < 16 - 1) {
   630:           System.out.print (", ");
   631:         }
   632:       }
   633:       System.out.println (" };");
   634:     }
   635:   }  //epbMakeCmpTable()
   636: 
   637:   //------------------------------------------------------------------------
   638:   //  cmp,compare,eq,ge,gt,le,lt,neで引数のどちらかが±0,±Inf,NaNの場合の結果を求めるためのテーブル
   639:   public static final int[] EFP_CMP_TABLE = { 205538368, 0, 1077953600, 0, -872397824, 0, 0, 0, -859831104, 0, -859782976, 0, -872397824, 0, 0, 0 };
   640:   public static final int[] EFP_COMPARE_TABLE = { 1010844736, 1145062464, 1883259968, 0, -67091392, 0, 0, 0, -54524736, 0, -54476608, 0, -54508544, 0, 0, 0 };
   641:   public static final int[] EFP_EQ_TABLE = { -1073741824, 0, 201326592, 0, 12583104, 0, 0, 0, 49152, 0, 3072, 0, 12583104, 0, 0, 0 };
   642:   public static final int[] EFP_GE_TABLE = { -1061106496, 0, -859779904, 0, 12635328, 0, 0, 0, 52224, 0, 3072, 0, 12635328, 0, 0, 0 };
   643:   public static final int[] EFP_GT_TABLE = { 12635328, 0, -1061106496, 0, 52224, 0, 0, 0, 3072, 0, 0, 0, 52224, 0, 0, 0 };
   644:   public static final int[] EFP_LE_TABLE = { -872415232, 0, 201326592, 0, -859832128, 0, 0, 0, -859782976, 0, -859779904, 0, -859832128, 0, 0, 0 };
   645:   public static final int[] EFP_LT_TABLE = { 201326592, 0, 0, 0, -872415232, 0, 0, 0, -859832128, 0, -859782976, 0, -872415232, 0, 0, 0 };
   646:   public static final int[] EFP_NE_TABLE = { 1019268288, -54473536, -255800128, 0, -67056640, 0, 0, 0, -54522688, 0, -54476608, 0, -67056640, 0, 0, 0 };
   647: 
   648:   //------------------------------------------------------------------------
   649:   //定数
   650:   //  すべてのEFP定数は内部コンストラクタnew EFP(xf,xe,xd,xc)で構築しなければならない
   651:   //  公開コンストラクタは丸めの処理が入るので定数の構築には使用できない
   652:   public final EFP     ZERO = new EFP (P | Z, 0, 0L, 0L);  //+0
   653:   public final EFP  NEGZERO = new EFP (M | Z, 0, 0L, 0L);  //-0
   654:   public final EFP      INF = new EFP (P | I, 0, 0L, 0L);  //+Inf
   655:   public final EFP   NEGINF = new EFP (M | I, 0, 0L, 0L);  //-Inf
   656:   public final EFP      NAN = new EFP (    N, 0, 0L, 0L);  //NaN
   657: 
   658:   //------------------------------------------------------------------------
   659:   //範囲
   660:   //  echo read("efp.gp");efppub(["EXDNOMAX",EXDNOMAX],["EXDDEMIN",EXDDEMIN],["NEGEXDDEMIN",-EXDDEMIN],["NEGEXDNOMAX",-EXDNOMAX],["SGLNOMAX",SGLNOMAX],["SGLDEMIN",SGLDEMIN],["NEGSGLDEMIN",-SGLDEMIN],["NEGSGLNOMAX",-SGLNOMAX],["DBLNOMAX",DBLNOMAX],["DBLDEMIN",DBLDEMIN],["NEGDBLDEMIN",-DBLDEMIN],["NEGDBLNOMAX",-DBLNOMAX],["TPLNOMAX",TPLNOMAX],["TPLDEMIN",TPLDEMIN],["NEGTPLDEMIN",-TPLDEMIN],["NEGTPLNOMAX",-TPLNOMAX],["XSGNOMAX",XSGNOMAX],["XSGDEMIN",XSGDEMIN],["NEGXSGDEMIN",-XSGDEMIN],["NEGXSGNOMAX",-XSGNOMAX],["EFPNOMAX",EFPNOMAX],["EFPDEMIN",eval("2^-32768")],["NEGEFPDEMIN",eval("-2^-32768")],["NEGEFPNOMAX",-EFPNOMAX]) | gp -q
   661:   public final EFP     EXDNOMAX = new EFP (P,  16383, 0xffffffffffffffffL, 0x0000000L << 36);  //=1.18973149535723176502126385303e+4932
   662:   public final EFP     EXDDEMIN = new EFP (P, -16446, 0x8000000000000000L, 0x0000000L << 36);  //=1.82259976594123730126420296681e-4951
   663:   public final EFP  NEGEXDDEMIN = new EFP (M, -16446, 0x8000000000000000L, 0x0000000L << 36);  //=-1.82259976594123730126420296681e-4951
   664:   public final EFP  NEGEXDNOMAX = new EFP (M,  16383, 0xffffffffffffffffL, 0x0000000L << 36);  //=-1.18973149535723176502126385303e+4932
   665:   public final EFP     SGLNOMAX = new EFP (P,    127, 0xffffff0000000000L, 0x0000000L << 36);  //=3.40282346638528859811704183485e+38
   666:   public final EFP     SGLDEMIN = new EFP (P,   -149, 0x8000000000000000L, 0x0000000L << 36);  //=1.40129846432481707092372958329e-45
   667:   public final EFP  NEGSGLDEMIN = new EFP (M,   -149, 0x8000000000000000L, 0x0000000L << 36);  //=-1.40129846432481707092372958329e-45
   668:   public final EFP  NEGSGLNOMAX = new EFP (M,    127, 0xffffff0000000000L, 0x0000000L << 36);  //=-3.40282346638528859811704183485e+38
   669:   public final EFP     DBLNOMAX = new EFP (P,   1023, 0xfffffffffffff800L, 0x0000000L << 36);  //=1.79769313486231570814527423732e+308
   670:   public final EFP     DBLDEMIN = new EFP (P,  -1074, 0x8000000000000000L, 0x0000000L << 36);  //=4.94065645841246544176568792868e-324
   671:   public final EFP  NEGDBLDEMIN = new EFP (M,  -1074, 0x8000000000000000L, 0x0000000L << 36);  //=-4.94065645841246544176568792868e-324
   672:   public final EFP  NEGDBLNOMAX = new EFP (M,   1023, 0xfffffffffffff800L, 0x0000000L << 36);  //=-1.79769313486231570814527423732e+308
   673:   public final EFP     TPLNOMAX = new EFP (P,  16383, 0xffffffffffffffffL, 0xffff000L << 36);  //=1.18973149535723176508575834251e+4932
   674:   public final EFP     TPLDEMIN = new EFP (P, -16462, 0x8000000000000000L, 0x0000000L << 36);  //=2.78106653738592117502472376527e-4956
   675:   public final EFP  NEGTPLDEMIN = new EFP (M, -16462, 0x8000000000000000L, 0x0000000L << 36);  //=-2.78106653738592117502472376527e-4956
   676:   public final EFP  NEGTPLNOMAX = new EFP (M,  16383, 0xffffffffffffffffL, 0xffff000L << 36);  //=-1.18973149535723176508575834251e+4932
   677:   public final EFP     XSGNOMAX = new EFP (P,  16383, 0xffffff0000000000L, 0x0000000L << 36);  //=1.18973142444370860622365937597e+4932
   678:   public final EFP     XSGDEMIN = new EFP (P, -16406, 0x8000000000000000L, 0x0000000L << 36);  //=2.00396963543420642987649310668e-4939
   679:   public final EFP  NEGXSGDEMIN = new EFP (M, -16406, 0x8000000000000000L, 0x0000000L << 36);  //=-2.00396963543420642987649310668e-4939
   680:   public final EFP  NEGXSGNOMAX = new EFP (M,  16383, 0xffffff0000000000L, 0x0000000L << 36);  //=-1.18973142444370860622365937597e+4932
   681:   public final EFP     EFPNOMAX = new EFP (P,  32767, 0xffffffffffffffffL, 0xfffffffL << 36);  //=1.41546103104495478900155302746e+9864
   682:   public final EFP     EFPDEMIN = new EFP (P, -32768, 0x8000000000000000L, 0x0000000L << 36);  //=7.06483596557763644277740218786e-9865
   683:   public final EFP  NEGEFPDEMIN = new EFP (M, -32768, 0x8000000000000000L, 0x0000000L << 36);  //=-7.06483596557763644277740218786e-9865
   684:   public final EFP  NEGEFPNOMAX = new EFP (M,  32767, 0xffffffffffffffffL, 0xfffffffL << 36);  //=-1.41546103104495478900155302746e+9864
   685: 
   686:   //------------------------------------------------------------------------
   687:   //オーバーフローの値
   688:   //  指数部が大きくなりすぎたときのオーバーフローの値はいつも±Infというわけではなく丸め桁数と丸めモードと符号によって変化する
   689:   //  端数に関係なく±0に近付く方向に丸めるときは±Infではなく絶対値が最大の正規化数を返す
   690:   //  絶対値が最大の正規化数は丸め桁数によって異なる
   691:   //  XSGはアンダーフローしたときは±XSGDEMINだがオーバーフローしたときは±EXDNOMAXになる
   692:   //  OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | flg >>> 31]
   693:   //  inner()～outer()の内側ではepbRoundingPrecが効かないことに注意する
   694:   public final EFP[] OVFL_RESULTS = new EFP[] {
   695:     INF,          //EPB_PREC_EXD,EPB_MODE_RN,+
   696:     NEGINF,       //EPB_PREC_EXD,EPB_MODE_RN,-
   697:     EXDNOMAX,     //EPB_PREC_EXD,EPB_MODE_RZ,+
   698:     NEGEXDNOMAX,  //EPB_PREC_EXD,EPB_MODE_RZ,-
   699:     EXDNOMAX,     //EPB_PREC_EXD,EPB_MODE_RM,+
   700:     NEGINF,       //EPB_PREC_EXD,EPB_MODE_RM,-
   701:     INF,          //EPB_PREC_EXD,EPB_MODE_RP,+
   702:     NEGEXDNOMAX,  //EPB_PREC_EXD,EPB_MODE_RP,-
   703:     //
   704:     INF,          //EPB_PREC_SGL,EPB_MODE_RN,+
   705:     NEGINF,       //EPB_PREC_SGL,EPB_MODE_RN,-
   706:     SGLNOMAX,     //EPB_PREC_SGL,EPB_MODE_RZ,+
   707:     NEGSGLNOMAX,  //EPB_PREC_SGL,EPB_MODE_RZ,-
   708:     SGLNOMAX,     //EPB_PREC_SGL,EPB_MODE_RM,+
   709:     NEGINF,       //EPB_PREC_SGL,EPB_MODE_RM,-
   710:     INF,          //EPB_PREC_SGL,EPB_MODE_RP,+
   711:     NEGSGLNOMAX,  //EPB_PREC_SGL,EPB_MODE_RP,-
   712:     //
   713:     INF,          //EPB_PREC_DBL,EPB_MODE_RN,+
   714:     NEGINF,       //EPB_PREC_DBL,EPB_MODE_RN,-
   715:     DBLNOMAX,     //EPB_PREC_DBL,EPB_MODE_RZ,+
   716:     NEGDBLNOMAX,  //EPB_PREC_DBL,EPB_MODE_RZ,-
   717:     DBLNOMAX,     //EPB_PREC_DBL,EPB_MODE_RM,+
   718:     NEGINF,       //EPB_PREC_DBL,EPB_MODE_RM,-
   719:     INF,          //EPB_PREC_DBL,EPB_MODE_RP,+
   720:     NEGDBLNOMAX,  //EPB_PREC_DBL,EPB_MODE_RP,-
   721:     //
   722:     INF,          //EPB_PREC_DBL3,EPB_MODE_RN,+
   723:     NEGINF,       //EPB_PREC_DBL3,EPB_MODE_RN,-
   724:     DBLNOMAX,     //EPB_PREC_DBL3,EPB_MODE_RZ,+
   725:     NEGDBLNOMAX,  //EPB_PREC_DBL3,EPB_MODE_RZ,-
   726:     DBLNOMAX,     //EPB_PREC_DBL3,EPB_MODE_RM,+
   727:     NEGINF,       //EPB_PREC_DBL3,EPB_MODE_RM,-
   728:     INF,          //EPB_PREC_DBL3,EPB_MODE_RP,+
   729:     NEGDBLNOMAX,  //EPB_PREC_DBL3,EPB_MODE_RP,-
   730:     //
   731:     INF,          //EPB_PREC_TPL,EPB_MODE_RN,+
   732:     NEGINF,       //EPB_PREC_TPL,EPB_MODE_RN,-
   733:     TPLNOMAX,     //EPB_PREC_TPL,EPB_MODE_RZ,+
   734:     NEGTPLNOMAX,  //EPB_PREC_TPL,EPB_MODE_RZ,-
   735:     TPLNOMAX,     //EPB_PREC_TPL,EPB_MODE_RM,+
   736:     NEGINF,       //EPB_PREC_TPL,EPB_MODE_RM,-
   737:     INF,          //EPB_PREC_TPL,EPB_MODE_RP,+
   738:     NEGTPLNOMAX,  //EPB_PREC_TPL,EPB_MODE_RP,-
   739:     //
   740:     INF,          //EPB_PREC_XSG,EPB_MODE_RN,+
   741:     NEGINF,       //EPB_PREC_XSG,EPB_MODE_RN,-
   742:     EXDNOMAX,     //EPB_PREC_XSG,EPB_MODE_RZ,+  XSGNOMAX → EXDNOMAX
   743:     NEGEXDNOMAX,  //EPB_PREC_XSG,EPB_MODE_RZ,-  -XSGNOMAX → -EXDNOMAX
   744:     EXDNOMAX,     //EPB_PREC_XSG,EPB_MODE_RM,+  XSGNOMAX→EXDNOMAX
   745:     NEGINF,       //EPB_PREC_XSG,EPB_MODE_RM,-
   746:     INF,          //EPB_PREC_XSG,EPB_MODE_RP,+
   747:     NEGEXDNOMAX,  //EPB_PREC_XSG,EPB_MODE_RP,-  -XSGNOMAX→-EXDNOMAX
   748:     //
   749:     INF,          //EPB_PREC_EFP,EPB_MODE_RN,+
   750:     NEGINF,       //EPB_PREC_EFP,EPB_MODE_RN,-
   751:     EFPNOMAX,     //EPB_PREC_EFP,EPB_MODE_RZ,+
   752:     NEGEFPNOMAX,  //EPB_PREC_EFP,EPB_MODE_RZ,-
   753:     EFPNOMAX,     //EPB_PREC_EFP,EPB_MODE_RM,+
   754:     NEGINF,       //EPB_PREC_EFP,EPB_MODE_RM,-
   755:     INF,          //EPB_PREC_EFP,EPB_MODE_RP,+
   756:     NEGEFPNOMAX,  //EPB_PREC_EFP,EPB_MODE_RP,-
   757:   };
   758: 
   759:   //------------------------------------------------------------------------
   760:   //アンダーフローの値
   761:   //  指数部が小さくなりすぎたときのアンダーフローの値はいつも±0というわけではなく丸め桁数と丸めモードと符号によって変化する
   762:   //  端数に関係なく±0から遠ざかる方向に丸めるときは±0ではなく絶対値が最小の非正規化数を返す
   763:   //  絶対値が最小の非正規化数は丸め桁数によって異なる
   764:   //  XSGはアンダーフローしたときは±XSGDEMINだがオーバーフローしたときは±EXDNOMAXになる
   765:   //  UNFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | flg >>> 31]
   766:   //  inner()～outer()の内側ではepbRoundingPrecが効かないことに注意する
   767:   public final EFP[] UNFL_RESULTS = new EFP[] {
   768:     ZERO,         //EPB_PREC_EXD,EPB_MODE_RN,+
   769:     NEGZERO,      //EPB_PREC_EXD,EPB_MODE_RN,-
   770:     ZERO,         //EPB_PREC_EXD,EPB_MODE_RZ,+
   771:     NEGZERO,      //EPB_PREC_EXD,EPB_MODE_RZ,-
   772:     ZERO,         //EPB_PREC_EXD,EPB_MODE_RM,+
   773:     NEGEXDDEMIN,  //EPB_PREC_EXD,EPB_MODE_RM,-
   774:     EXDDEMIN,     //EPB_PREC_EXD,EPB_MODE_RP,+
   775:     NEGZERO,      //EPB_PREC_EXD,EPB_MODE_RP,-
   776:     //
   777:     ZERO,         //EPB_PREC_SGL,EPB_MODE_RN,+
   778:     NEGZERO,      //EPB_PREC_SGL,EPB_MODE_RN,-
   779:     ZERO,         //EPB_PREC_SGL,EPB_MODE_RZ,+
   780:     NEGZERO,      //EPB_PREC_SGL,EPB_MODE_RZ,-
   781:     ZERO,         //EPB_PREC_SGL,EPB_MODE_RM,+
   782:     NEGSGLDEMIN,  //EPB_PREC_SGL,EPB_MODE_RM,-
   783:     SGLDEMIN,     //EPB_PREC_SGL,EPB_MODE_RP,+
   784:     NEGZERO,      //EPB_PREC_SGL,EPB_MODE_RP,-
   785:     //
   786:     ZERO,         //EPB_PREC_DBL,EPB_MODE_RN,+
   787:     NEGZERO,      //EPB_PREC_DBL,EPB_MODE_RN,-
   788:     ZERO,         //EPB_PREC_DBL,EPB_MODE_RZ,+
   789:     NEGZERO,      //EPB_PREC_DBL,EPB_MODE_RZ,-
   790:     ZERO,         //EPB_PREC_DBL,EPB_MODE_RM,+
   791:     NEGDBLDEMIN,  //EPB_PREC_DBL,EPB_MODE_RM,-
   792:     DBLDEMIN,     //EPB_PREC_DBL,EPB_MODE_RP,+
   793:     NEGZERO,      //EPB_PREC_DBL,EPB_MODE_RP,-
   794:     //
   795:     ZERO,         //EPB_PREC_DBL3,EPB_MODE_RN,+
   796:     NEGZERO,      //EPB_PREC_DBL3,EPB_MODE_RN,-
   797:     ZERO,         //EPB_PREC_DBL3,EPB_MODE_RZ,+
   798:     NEGZERO,      //EPB_PREC_DBL3,EPB_MODE_RZ,-
   799:     ZERO,         //EPB_PREC_DBL3,EPB_MODE_RM,+
   800:     NEGDBLDEMIN,  //EPB_PREC_DBL3,EPB_MODE_RM,-
   801:     DBLDEMIN,     //EPB_PREC_DBL3,EPB_MODE_RP,+
   802:     NEGZERO,      //EPB_PREC_DBL3,EPB_MODE_RP,-
   803:     //
   804:     ZERO,         //EPB_PREC_TPL,EPB_MODE_RN,+
   805:     NEGZERO,      //EPB_PREC_TPL,EPB_MODE_RN,-
   806:     ZERO,         //EPB_PREC_TPL,EPB_MODE_RZ,+
   807:     NEGZERO,      //EPB_PREC_TPL,EPB_MODE_RZ,-
   808:     ZERO,         //EPB_PREC_TPL,EPB_MODE_RM,+
   809:     NEGTPLDEMIN,  //EPB_PREC_TPL,EPB_MODE_RM,-
   810:     TPLDEMIN,     //EPB_PREC_TPL,EPB_MODE_RP,+
   811:     NEGZERO,      //EPB_PREC_TPL,EPB_MODE_RP,-
   812:     //
   813:     ZERO,         //EPB_PREC_XSG,EPB_MODE_RN,+
   814:     NEGZERO,      //EPB_PREC_XSG,EPB_MODE_RN,-
   815:     ZERO,         //EPB_PREC_XSG,EPB_MODE_RZ,+
   816:     NEGZERO,      //EPB_PREC_XSG,EPB_MODE_RZ,-
   817:     ZERO,         //EPB_PREC_XSG,EPB_MODE_RM,+
   818:     NEGXSGDEMIN,  //EPB_PREC_XSG,EPB_MODE_RM,-
   819:     XSGDEMIN,     //EPB_PREC_XSG,EPB_MODE_RP,+
   820:     NEGZERO,      //EPB_PREC_XSG,EPB_MODE_RP,-
   821:     //
   822:     ZERO,         //EPB_PREC_EFP,EPB_MODE_RN,+
   823:     NEGZERO,      //EPB_PREC_EFP,EPB_MODE_RN,-
   824:     ZERO,         //EPB_PREC_EFP,EPB_MODE_RZ,+
   825:     NEGZERO,      //EPB_PREC_EFP,EPB_MODE_RZ,-
   826:     ZERO,         //EPB_PREC_EFP,EPB_MODE_RM,+
   827:     NEGEFPDEMIN,  //EPB_PREC_EFP,EPB_MODE_RM,-
   828:     EFPDEMIN,     //EPB_PREC_EFP,EPB_MODE_RP,+
   829:     NEGZERO,      //EPB_PREC_EFP,EPB_MODE_RP,-
   830:   };
   831: 
   832:   //------------------------------------------------------------------------
   833:   //  ±1に隣接する値
   834:   //    三角関数や双曲線関数で丸めモードによって結果が±1になってはならないのに端数が小さすぎて±1になってしまうことがある
   835:   //    結果を調節するときに使う
   836:   public final EFP[] NEXTDOWN_MINUSONE = {
   837:     //  echo read("efp.gp");efpmem([exdnextdown(-1)],[sglnextdown(-1)],[dblnextdown(-1)],[dblnextdown(-1)],[tplnextdown(-1)],[xsgnextdown(-1)],[efpnextdown(-1)]) | gp -q
   838:     new EFP (M,      0, 0x8000000000000001L, 0x0000000L << 36),  //=-1.00000000000000000010842021725
   839:     new EFP (M,      0, 0x8000010000000000L, 0x0000000L << 36),  //=-1.00000011920928955078125000000
   840:     new EFP (M,      0, 0x8000000000000800L, 0x0000000L << 36),  //=-1.00000000000000022204460492503
   841:     new EFP (M,      0, 0x8000000000000800L, 0x0000000L << 36),  //=-1.00000000000000022204460492503
   842:     new EFP (M,      0, 0x8000000000000000L, 0x0001000L << 36),  //=-1.00000000000000000000000165436
   843:     new EFP (M,      0, 0x8000010000000000L, 0x0000000L << 36),  //=-1.00000011920928955078125000000
   844:     new EFP (M,      0, 0x8000000000000000L, 0x0000001L << 36),  //=-1.00000000000000000000000000040
   845:   };
   846:   public final EFP[] NEXTUP_MINUSONE = {
   847:     //  echo read("efp.gp");efpmem([exdnextup(-1)],[sglnextup(-1)],[dblnextup(-1)],[dblnextup(-1)],[tplnextup(-1)],[xsgnextup(-1)],[efpnextup(-1)]) | gp -q
   848:     new EFP (M,     -1, 0xffffffffffffffffL, 0x0000000L << 36),  //=-0.999999999999999999945789891376
   849:     new EFP (M,     -1, 0xffffff0000000000L, 0x0000000L << 36),  //=-0.999999940395355224609375000000
   850:     new EFP (M,     -1, 0xfffffffffffff800L, 0x0000000L << 36),  //=-0.999999999999999888977697537484
   851:     new EFP (M,     -1, 0xfffffffffffff800L, 0x0000000L << 36),  //=-0.999999999999999888977697537484
   852:     new EFP (M,     -1, 0xffffffffffffffffL, 0xffff000L << 36),  //=-0.999999999999999999999999172819
   853:     new EFP (M,     -1, 0xffffff0000000000L, 0x0000000L << 36),  //=-0.999999940395355224609375000000
   854:     new EFP (M,     -1, 0xffffffffffffffffL, 0xfffffffL << 36),  //=-0.999999999999999999999999999798
   855:   };
   856:   public final EFP[] NEXTDOWN_PLUSONE = {
   857:     //  echo read("efp.gp");efpmem([exdnextdown(1)],[sglnextdown(1)],[dblnextdown(1)],[dblnextdown(1)],[tplnextdown(1)],[xsgnextdown(1)],[efpnextdown(1)]) | gp -q
   858:     new EFP (P,     -1, 0xffffffffffffffffL, 0x0000000L << 36),  //=0.999999999999999999945789891376
   859:     new EFP (P,     -1, 0xffffff0000000000L, 0x0000000L << 36),  //=0.999999940395355224609375000000
   860:     new EFP (P,     -1, 0xfffffffffffff800L, 0x0000000L << 36),  //=0.999999999999999888977697537484
   861:     new EFP (P,     -1, 0xfffffffffffff800L, 0x0000000L << 36),  //=0.999999999999999888977697537484
   862:     new EFP (P,     -1, 0xffffffffffffffffL, 0xffff000L << 36),  //=0.999999999999999999999999172819
   863:     new EFP (P,     -1, 0xffffff0000000000L, 0x0000000L << 36),  //=0.999999940395355224609375000000
   864:     new EFP (P,     -1, 0xffffffffffffffffL, 0xfffffffL << 36),  //=0.999999999999999999999999999798
   865:   };
   866:   public final EFP[] NEXTUP_PLUSONE = {
   867:     //  echo read("efp.gp");efpmem([exdnextup(1)],[sglnextup(1)],[dblnextup(1)],[dblnextup(1)],[tplnextup(1)],[xsgnextup(1)],[efpnextup(1)]) | gp -q
   868:     new EFP (P,      0, 0x8000000000000001L, 0x0000000L << 36),  //=1.00000000000000000010842021725
   869:     new EFP (P,      0, 0x8000010000000000L, 0x0000000L << 36),  //=1.00000011920928955078125000000
   870:     new EFP (P,      0, 0x8000000000000800L, 0x0000000L << 36),  //=1.00000000000000022204460492503
   871:     new EFP (P,      0, 0x8000000000000800L, 0x0000000L << 36),  //=1.00000000000000022204460492503
   872:     new EFP (P,      0, 0x8000000000000000L, 0x0001000L << 36),  //=1.00000000000000000000000165436
   873:     new EFP (P,      0, 0x8000010000000000L, 0x0000000L << 36),  //=1.00000011920928955078125000000
   874:     new EFP (P,      0, 0x8000000000000000L, 0x0000001L << 36),  //=1.00000000000000000000000000040
   875:   };
   876: 
   877:   //------------------------------------------------------------------------
   878:   //汎用定数
   879:   //  echo read("efp.gp");efppub(["NEGONE",-1],["ONE",1],["TWO",2],["THREE",3],["FOUR",4],["FIVE",5],["SIX",6],["SEVEN",7],["EIGHT",8],["NINE",9],["TEN",10],["ELEVEN",11],["TWELVE",12],["THIRTEEN",13],["FOURTEEN",14],["FIFTEEN",15],[SIXTEEN,16]) | gp -q
   880:   public final EFP       NEGONE = new EFP (M,      0, 0x8000000000000000L, 0x0000000L << 36);  //=-1.00000000000000000000000000000
   881:   public final EFP          ONE = new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36);  //=1.00000000000000000000000000000
   882:   public final EFP          TWO = new EFP (P,      1, 0x8000000000000000L, 0x0000000L << 36);  //=2.00000000000000000000000000000
   883:   public final EFP        THREE = new EFP (P,      1, 0xc000000000000000L, 0x0000000L << 36);  //=3.00000000000000000000000000000
   884:   public final EFP         FOUR = new EFP (P,      2, 0x8000000000000000L, 0x0000000L << 36);  //=4.00000000000000000000000000000
   885:   public final EFP         FIVE = new EFP (P,      2, 0xa000000000000000L, 0x0000000L << 36);  //=5.00000000000000000000000000000
   886:   public final EFP          SIX = new EFP (P,      2, 0xc000000000000000L, 0x0000000L << 36);  //=6.00000000000000000000000000000
   887:   public final EFP        SEVEN = new EFP (P,      2, 0xe000000000000000L, 0x0000000L << 36);  //=7.00000000000000000000000000000
   888:   public final EFP        EIGHT = new EFP (P,      3, 0x8000000000000000L, 0x0000000L << 36);  //=8.00000000000000000000000000000
   889:   public final EFP         NINE = new EFP (P,      3, 0x9000000000000000L, 0x0000000L << 36);  //=9.00000000000000000000000000000
   890:   public final EFP          TEN = new EFP (P,      3, 0xa000000000000000L, 0x0000000L << 36);  //=10.0000000000000000000000000000
   891:   public final EFP       ELEVEN = new EFP (P,      3, 0xb000000000000000L, 0x0000000L << 36);  //=11.0000000000000000000000000000
   892:   public final EFP       TWELVE = new EFP (P,      3, 0xc000000000000000L, 0x0000000L << 36);  //=12.0000000000000000000000000000
   893:   public final EFP     THIRTEEN = new EFP (P,      3, 0xd000000000000000L, 0x0000000L << 36);  //=13.0000000000000000000000000000
   894:   public final EFP     FOURTEEN = new EFP (P,      3, 0xe000000000000000L, 0x0000000L << 36);  //=14.0000000000000000000000000000
   895:   public final EFP      FIFTEEN = new EFP (P,      3, 0xf000000000000000L, 0x0000000L << 36);  //=15.0000000000000000000000000000
   896:   public final EFP      SIXTEEN = new EFP (P,      4, 0x8000000000000000L, 0x0000000L << 36);  //=16.0000000000000000000000000000
   897:   public final EFP[] EFP_DIGIT = {
   898:     ZERO,
   899:     ONE,
   900:     TWO,
   901:     THREE,
   902:     FOUR,
   903:     FIVE,
   904:     SIX,
   905:     SEVEN,
   906:     EIGHT,
   907:     NINE,
   908:     TEN,
   909:     ELEVEN,
   910:     TWELVE,
   911:     THIRTEEN,
   912:     FOURTEEN,
   913:     FIFTEEN,
   914:     SIXTEEN,
   915:   };
   916:   //  echo read("efp.gp");efppub(["ONE_2",1/2],["ONE_3",1/3],["TWO_3",2/3],["ONE_4",1/4],["THREE_4",3/4],["ONE_5",1/5],["TWO_5",2/5],["THREE_5",3/5],["FOUR_5",4/5],["ONE_6",1/6],["FIVE_6",5/6],[ONE_10,1/10]) | gp -q
   917:   public final EFP        ONE_2 = new EFP (P,     -1, 0x8000000000000000L, 0x0000000L << 36);  //=0.500000000000000000000000000000
   918:   public final EFP        ONE_3 = new EFP (P,     -2, 0xaaaaaaaaaaaaaaaaL, 0xaaaaaabL << 36);  //>0.333333333333333333333333333333
   919:   public final EFP        TWO_3 = new EFP (P,     -1, 0xaaaaaaaaaaaaaaaaL, 0xaaaaaabL << 36);  //>0.666666666666666666666666666667
   920:   public final EFP        ONE_4 = new EFP (P,     -2, 0x8000000000000000L, 0x0000000L << 36);  //=0.250000000000000000000000000000
   921:   public final EFP      THREE_4 = new EFP (P,     -1, 0xc000000000000000L, 0x0000000L << 36);  //=0.750000000000000000000000000000
   922:   public final EFP        ONE_5 = new EFP (P,     -3, 0xccccccccccccccccL, 0xccccccdL << 36);  //>0.200000000000000000000000000000
   923:   public final EFP        TWO_5 = new EFP (P,     -2, 0xccccccccccccccccL, 0xccccccdL << 36);  //>0.400000000000000000000000000000
   924:   public final EFP      THREE_5 = new EFP (P,     -1, 0x9999999999999999L, 0x999999aL << 36);  //>0.600000000000000000000000000000
   925:   public final EFP       FOUR_5 = new EFP (P,     -1, 0xccccccccccccccccL, 0xccccccdL << 36);  //>0.800000000000000000000000000000
   926:   public final EFP        ONE_6 = new EFP (P,     -3, 0xaaaaaaaaaaaaaaaaL, 0xaaaaaabL << 36);  //>0.166666666666666666666666666667
   927:   public final EFP       FIVE_6 = new EFP (P,     -1, 0xd555555555555555L, 0x5555555L << 36);  //<0.833333333333333333333333333333
   928:   public final EFP       ONE_10 = new EFP (P,     -4, 0xccccccccccccccccL, 0xccccccdL << 36);  //>0.100000000000000000000000000000
   929:   //  echo read("efp.gp");efppub2(["SQRT2",sqrt(2)],["SQRT2_2",sqrt(2)/2],["DECSQRT2",sqrt(2)-1],["INCSQRT2",sqrt(2)+1]) | gp -q
   930:   public final EFP        SQRT2 = new EFP (P,      0, 0xb504f333f9de6484L, 0x597d89bL << 36);  //<1.41421356237309504880168872421
   931:   public final EFP       SQRT2A = new EFP (P,    -94, 0xdd52afa7c75bd82eL, 0xa24eea1L << 36);  //<8.72965282186712870062036635269e-29
   932:   public final EFP      SQRT2_2 = new EFP (P,     -1, 0xb504f333f9de6484L, 0x597d89bL << 36);  //<0.707106781186547524400844362105
   933:   public final EFP     SQRT2_2A = new EFP (P,    -95, 0xdd52afa7c75bd82eL, 0xa24eea1L << 36);  //<4.36482641093356435031018317635e-29
   934:   public final EFP     DECSQRT2 = new EFP (P,     -2, 0xd413cccfe7799211L, 0x65f626dL << 36);  //>0.414213562373095048801688724210
   935:   public final EFP    DECSQRT2A = new EFP (M,    -96, 0x8ab54160e2909f45L, 0x76c457bL << 36);  //>-1.36776676496182240864975928293e-29
   936:   public final EFP     INCSQRT2 = new EFP (P,      1, 0x9a827999fcef3242L, 0x2cbec4eL << 36);  //>2.41421356237309504880168872421
   937:   public final EFP    INCSQRT2A = new EFP (M,    -92, 0xc8ab54160e2909f4L, 0x576c458L << 36);  //<-3.16600255254486757364601361898e-28
   938:   //  echo read("efp.gp");efppub2(["PI",Pi],["NEGPI",-Pi],["PI2",Pi*2],["PI_2",Pi/2],["NEGPI_2",-Pi/2],["PI3_2",Pi*3/2],["PI_4",Pi/4],["NEGPI_4",-Pi/4],["PI3_4",Pi*3/4],["NEGPI3_4",-Pi*3/4],["PI_6",Pi/6],["PI_8",Pi/8],["TO_RAD",Pi/180]) | gp -q
   939:   public final EFP           PI = new EFP (P,      1, 0xc90fdaa22168c234L, 0xc4c6629L << 36);  //>3.14159265358979323846264338328
   940:   public final EFP          PIA = new EFP (M,    -92, 0x8fe47c65dadfb63eL, 0xeeb3067L << 36);  //>-2.27022372150444021965698652772e-28
   941:   public final EFP        NEGPI = new EFP (M,      1, 0xc90fdaa22168c234L, 0xc4c6629L << 36);  //<-3.14159265358979323846264338328
   942:   public final EFP       NEGPIA = new EFP (P,    -92, 0x8fe47c65dadfb63eL, 0xeeb3067L << 36);  //<2.27022372150444021965698652772e-28
   943:   public final EFP          PI2 = new EFP (P,      2, 0xc90fdaa22168c234L, 0xc4c6629L << 36);  //>6.28318530717958647692528676656
   944:   public final EFP         PI2A = new EFP (M,    -91, 0x8fe47c65dadfb63eL, 0xeeb3067L << 36);  //>-4.54044744300888043931397305544e-28
   945:   public final EFP         PI_2 = new EFP (P,      0, 0xc90fdaa22168c234L, 0xc4c6629L << 36);  //>1.57079632679489661923132169164
   946:   public final EFP        PI_2A = new EFP (M,    -93, 0x8fe47c65dadfb63eL, 0xeeb3067L << 36);  //>-1.13511186075222010982849326386e-28
   947:   public final EFP      NEGPI_2 = new EFP (M,      0, 0xc90fdaa22168c234L, 0xc4c6629L << 36);  //<-1.57079632679489661923132169164
   948:   public final EFP     NEGPI_2A = new EFP (P,    -93, 0x8fe47c65dadfb63eL, 0xeeb3067L << 36);  //<1.13511186075222010982849326386e-28
   949:   public final EFP        PI3_2 = new EFP (P,      2, 0x96cbe3f9990e91a7L, 0x9394c9fL << 36);  //>4.71238898038468985769396507492
   950:   public final EFP       PI3_2A = new EFP (M,    -91, 0xebeb5d4c6427c8afL, 0x330644dL << 36);  //>-7.44430341698824077319353004583e-28
   951:   public final EFP         PI_4 = new EFP (P,     -1, 0xc90fdaa22168c234L, 0xc4c6629L << 36);  //>0.785398163397448309615660845820
   952:   public final EFP        PI_4A = new EFP (M,    -94, 0x8fe47c65dadfb63eL, 0xeeb3067L << 36);  //>-5.67555930376110054914246631930e-29
   953:   public final EFP      NEGPI_4 = new EFP (M,     -1, 0xc90fdaa22168c234L, 0xc4c6629L << 36);  //<-0.785398163397448309615660845820
   954:   public final EFP     NEGPI_4A = new EFP (P,    -94, 0x8fe47c65dadfb63eL, 0xeeb3067L << 36);  //<5.67555930376110054914246631930e-29
   955:   public final EFP        PI3_4 = new EFP (P,      1, 0x96cbe3f9990e91a7L, 0x9394c9fL << 36);  //>2.35619449019234492884698253746
   956:   public final EFP       PI3_4A = new EFP (M,    -92, 0xebeb5d4c6427c8afL, 0x330644dL << 36);  //>-3.72215170849412038659676502291e-28
   957:   public final EFP     NEGPI3_4 = new EFP (M,      1, 0x96cbe3f9990e91a7L, 0x9394c9fL << 36);  //<-2.35619449019234492884698253746
   958:   public final EFP    NEGPI3_4A = new EFP (P,    -92, 0xebeb5d4c6427c8afL, 0x330644dL << 36);  //<3.72215170849412038659676502291e-28
   959:   public final EFP         PI_6 = new EFP (P,     -1, 0x860a91c16b9b2c23L, 0x2dd9970L << 36);  //<0.523598775598298873077107230547
   960:   public final EFP        PI_6A = new EFP (P,    -94, 0xf567ad116e158680L, 0xb633511L << 36);  //>9.67951991326453444626518996796e-29
   961:   public final EFP         PI_8 = new EFP (P,     -2, 0xc90fdaa22168c234L, 0xc4c6629L << 36);  //>0.392699081698724154807830422910
   962:   public final EFP        PI_8A = new EFP (M,    -95, 0x8fe47c65dadfb63eL, 0xeeb3067L << 36);  //>-2.83777965188055027457123315965e-29
   963:   public final EFP       TO_RAD = new EFP (P,     -6, 0x8efa351294e9c8aeL, 0x0ec5f67L << 36);  //>0.0174532925199432957692369076849
   964:   public final EFP      TO_RADA = new EFP (M,   -101, 0xb5bd1d937fa42885L, 0x7f250caL << 36);  //>-5.60025707306011850554567124038e-31
   965:   //  echo read("efp.gp");efppub2(["ONE_2PI",1/(2*Pi)],["ONE_PI",1/Pi],["TWO_PI",2/Pi],["FOUR_PI",4/Pi],["TO_DEG",180/Pi]) | gp -q
   966:   public final EFP      ONE_2PI = new EFP (P,     -3, 0xa2f9836e4e441529L, 0xfc2757dL << 36);  //<0.159154943091895335768883763373
   967:   public final EFP     ONE_2PIA = new EFP (P,    -98, 0xfa9a6ee06db14accL, 0x9e21c82L << 36);  //<6.17784718978010796644368056118e-30
   968:   public final EFP       ONE_PI = new EFP (P,     -2, 0xa2f9836e4e441529L, 0xfc2757dL << 36);  //<0.318309886183790671537767526745
   969:   public final EFP      ONE_PIA = new EFP (P,    -97, 0xfa9a6ee06db14accL, 0x9e21c82L << 36);  //<1.23556943795602159328873611224e-29
   970:   public final EFP       TWO_PI = new EFP (P,     -1, 0xa2f9836e4e441529L, 0xfc2757dL << 36);  //<0.636619772367581343075535053490
   971:   public final EFP      TWO_PIA = new EFP (P,    -96, 0xfa9a6ee06db14accL, 0x9e21c82L << 36);  //<2.47113887591204318657747222447e-29
   972:   public final EFP      FOUR_PI = new EFP (P,      0, 0xa2f9836e4e441529L, 0xfc2757dL << 36);  //<1.27323954473516268615107010698
   973:   public final EFP     FOUR_PIA = new EFP (P,    -95, 0xfa9a6ee06db14accL, 0x9e21c82L << 36);  //<4.94227775182408637315494444895e-29
   974:   public final EFP       TO_DEG = new EFP (P,      5, 0xe52ee0d31e0fbdc3L, 0x0a97538L << 36);  //>57.2957795130823208767981548141
   975:   public final EFP      TO_DEGA = new EFP (M,    -91, 0xbf2da828cb7d5da0L, 0x8340fd2L << 36);  //>-6.03252495991267442675910175947e-28
   976:   //  echo read("efp.gp");efppub2(["E",exp(1)]) | gp -q
   977:   public final EFP            E = new EFP (P,      1, 0xadf85458a2bb4a9aL, 0xafdc562L << 36);  //<2.71828182845904523536028747135
   978:   public final EFP           EA = new EFP (P,    -97, 0x9cf4f3c762e7160fL, 0x38b4da5L << 36);  //<7.73856991537314016398963167104e-30
   979:   //  echo read("efp.gp");efppub2(["LOG_2",log(2)],["LOG_2_2",log(2)/2],["LOG_10",log(10)],["LOG2_E",1/log(2)],["LOG2_10",log(10)/log(2)],["LOG10_2",log(2)/log(10)],["LOG10_E",1/log(10)]) | gp -q
   980:   public final EFP        LOG_2 = new EFP (P,     -1, 0xb17217f7d1cf79abL, 0xc9e3b3aL << 36);  //>0.693147180559945309417232121458
   981:   public final EFP       LOG_2A = new EFP (M,    -94, 0xff81a12a17e1979bL, 0x31ace94L << 36);  //<-1.00779491359051436097542460399e-28
   982:   public final EFP      LOG_2_2 = new EFP (P,     -2, 0xb17217f7d1cf79abL, 0xc9e3b3aL << 36);  //>0.346573590279972654708616060729
   983:   public final EFP     LOG_2_2A = new EFP (M,    -95, 0xff81a12a17e1979bL, 0x31ace94L << 36);  //<-5.03897456795257180487712301994e-29
   984:   public final EFP       LOG_10 = new EFP (P,      1, 0x935d8dddaaa8ac16L, 0xea56d63L << 36);  //>2.30258509299404568401799145468
   985:   public final EFP      LOG_10A = new EFP (M,    -92, 0x8fa59ebae3ae0260L, 0xc4b440eL << 36);  //<-2.26634931190478263500410602069e-28
   986:   public final EFP       LOG2_E = new EFP (P,      0, 0xb8aa3b295c17f0bbL, 0xbe87fedL << 36);  //<1.44269504088896340735992468100
   987:   public final EFP      LOG2_EA = new EFP (P,    -97, 0xd23a7d11d6aef551L, 0xbad2b4bL << 36);  //<1.03650638666742465296873972532e-29
   988:   public final EFP      LOG2_10 = new EFP (P,      1, 0xd49a784bcd1b8afeL, 0x492bf70L << 36);  //>3.32192809488736234787031942949
   989:   public final EFP     LOG2_10A = new EFP (M,    -95, 0xb25024b32693aa01L, 0xc84c52bL << 36);  //>-3.51660504800210370161854327284e-29
   990:   public final EFP      LOG10_2 = new EFP (P,     -2, 0x9a209a84fbcff798L, 0x8f8959bL << 36);  //>0.301029995663981195213738894724
   991:   public final EFP     LOG10_2A = new EFP (M,    -96, 0xfd20dba1f654b3ceL, 0xaf0b833L << 36);  //<-2.49603825457634309563856476519e-29
   992:   public final EFP      LOG10_E = new EFP (P,     -2, 0xde5bd8a937287195L, 0x355baabL << 36);  //>0.434294481903251827651128918917
   993:   public final EFP     LOG10_EA = new EFP (M,    -99, 0xa598479b823973fbL, 0x746cbc0L << 36);  //<-2.04111402292715890833493215303e-30
   994:   //  echo read("efp.gp");for(n=1,14,efppub([Str("TENXP",n),Str("10^(2^",n,")")])) | gp -q
   995:   public final EFP       TENXP1 = new EFP (P,      6, 0xc800000000000000L, 0x0000000L << 36);  //=10^(2^1)=100.000000000000000000000000000
   996:   public final EFP       TENXP2 = new EFP (P,     13, 0x9c40000000000000L, 0x0000000L << 36);  //=10^(2^2)=10000.0000000000000000000000000
   997:   public final EFP       TENXP3 = new EFP (P,     26, 0xbebc200000000000L, 0x0000000L << 36);  //=10^(2^3)=100000000.000000000000000000000
   998:   public final EFP       TENXP4 = new EFP (P,     53, 0x8e1bc9bf04000000L, 0x0000000L << 36);  //=10^(2^4)=10000000000000000.0000000000000
   999:   public final EFP       TENXP5 = new EFP (P,    106, 0x9dc5ada82b70b59dL, 0xf020000L << 36);  //=10^(2^5)=1.00000000000000000000000000000e+32
  1000:   public final EFP       TENXP6 = new EFP (P,    212, 0xc2781f49ffcfa6d5L, 0x3cbf6b7L << 36);  //<10^(2^6)=1.00000000000000000000000000000e+64
  1001:   public final EFP       TENXP7 = new EFP (P,    425, 0x93ba47c980e98cdfL, 0xc66f337L << 36);  //>10^(2^7)=1.00000000000000000000000000000e+128
  1002:   public final EFP       TENXP8 = new EFP (P,    850, 0xaa7eebfb9df9de8dL, 0xddbb902L << 36);  //>10^(2^8)=1.00000000000000000000000000000e+256
  1003:   public final EFP       TENXP9 = new EFP (P,   1700, 0xe319a0aea60e91c6L, 0xcc655c5L << 36);  //<10^(2^9)=1.00000000000000000000000000000e+512
  1004:   public final EFP      TENXP10 = new EFP (P,   3401, 0xc976758681750c17L, 0x650d3d3L << 36);  //>10^(2^10)=1.00000000000000000000000000000e+1024
  1005:   public final EFP      TENXP11 = new EFP (P,   6803, 0x9e8b3b5dc53d5de4L, 0xa74d28dL << 36);  //>10^(2^11)=1.00000000000000000000000000000e+2048
  1006:   public final EFP      TENXP12 = new EFP (P,  13606, 0xc46052028a20979aL, 0xc94c154L << 36);  //>10^(2^12)=1.00000000000000000000000000000e+4096
  1007:   public final EFP      TENXP13 = new EFP (P,  27213, 0x96a3a1d17faf211aL, 0x0c7c289L << 36);  //<10^(2^13)=1.00000000000000000000000000000e+8192
  1008:   public final EFP      TENXP14 = new EFP (P,  54426, 0xb1485471f16603b5L, 0x6226e11L << 36);  //<10^(2^14)=1.00000000000000000000000000000e+16384
  1009:   public final EFP[] EFP_TEN_POWER_P = {
  1010:     TEN,
  1011:     TENXP1,
  1012:     TENXP2,
  1013:     TENXP3,
  1014:     TENXP4,
  1015:     TENXP5,
  1016:     TENXP6,
  1017:     TENXP7,
  1018:     TENXP8,
  1019:     TENXP9,
  1020:     TENXP10,
  1021:     TENXP11,
  1022:     TENXP12,
  1023:     TENXP13,
  1024:     TENXP14,
  1025:     INF,  //番兵 +Inf
  1026:   };
  1027:   //  echo read("efp.gp");for(n=1,14,efppub([Str("TENXM",n),Str("10^(-2^",n,")")])) | gp -q
  1028:   public final EFP       TENXM1 = new EFP (P,     -7, 0xa3d70a3d70a3d70aL, 0x3d70a3dL << 36);  //<10^(-2^1)=0.0100000000000000000000000000000
  1029:   public final EFP       TENXM2 = new EFP (P,    -14, 0xd1b71758e219652bL, 0xd3c3611L << 36);  //<10^(-2^2)=1.00000000000000000000000000000e-4
  1030:   public final EFP       TENXM3 = new EFP (P,    -27, 0xabcc77118461cefcL, 0xfdc20d3L << 36);  //>10^(-2^3)=1.00000000000000000000000000000e-8
  1031:   public final EFP       TENXM4 = new EFP (P,    -54, 0xe69594bec44de15bL, 0x4c2ebe7L << 36);  //>10^(-2^4)=1.00000000000000000000000000000e-16
  1032:   public final EFP       TENXM5 = new EFP (P,   -107, 0xcfb11ead453994baL, 0x67de18fL << 36);  //>10^(-2^5)=1.00000000000000000000000000000e-32
  1033:   public final EFP       TENXM6 = new EFP (P,   -213, 0xa87fea27a539e9a5L, 0x3f2398dL << 36);  //<10^(-2^6)=1.00000000000000000000000000000e-64
  1034:   public final EFP       TENXM7 = new EFP (P,   -426, 0xddd0467c64bce4a0L, 0xac7cb3fL << 36);  //<10^(-2^7)=1.00000000000000000000000000000e-128
  1035:   public final EFP       TENXM8 = new EFP (P,   -851, 0xc0314325637a1939L, 0xfa91115L << 36);  //<10^(-2^8)=1.00000000000000000000000000000e-256
  1036:   public final EFP       TENXM9 = new EFP (P,  -1701, 0x9049ee32db23d21cL, 0x7132d33L << 36);  //<10^(-2^9)=1.00000000000000000000000000000e-512
  1037:   public final EFP      TENXM10 = new EFP (P,  -3402, 0xa2a682a5da57c0bdL, 0x87a6016L << 36);  //>10^(-2^10)=1.00000000000000000000000000000e-1024
  1038:   public final EFP      TENXM11 = new EFP (P,  -6804, 0xceae534f34362de4L, 0x492512dL << 36);  //<10^(-2^11)=1.00000000000000000000000000000e-2048
  1039:   public final EFP      TENXM12 = new EFP (P, -13607, 0xa6dd04c8d2ce9fdeL, 0x2de3812L << 36);  //<10^(-2^12)=1.00000000000000000000000000000e-4096
  1040:   public final EFP      TENXM13 = new EFP (P, -27214, 0xd986c20b686da869L, 0x5d1d4feL << 36);  //>10^(-2^13)=1.00000000000000000000000000000e-8192
  1041:   public final EFP      TENXM14 = new EFP (P, -54427, 0xb8d5bbe70e108517L, 0x456e9e1L << 36);  //>10^(-2^14)=1.00000000000000000000000000000e-16384
  1042:   public final EFP[] EFP_TEN_POWER_M = {
  1043:     ONE_10,
  1044:     TENXM1,
  1045:     TENXM2,
  1046:     TENXM3,
  1047:     TENXM4,
  1048:     TENXM5,
  1049:     TENXM6,
  1050:     TENXM7,
  1051:     TENXM8,
  1052:     TENXM9,
  1053:     TENXM10,
  1054:     TENXM11,
  1055:     TENXM12,
  1056:     TENXM13,
  1057:     TENXM14,
  1058:     ZERO,  //番兵 +0
  1059:   };
  1060: 
  1061:   //------------------------------------------------------------------------
  1062:   //asin
  1063:   //  echo read("efp.gp");efpchebyshev("ASIN_C",asin,-1/16,1/16,17) | gp -q
  1064:   public final EFP      ASIN_C1 = new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36);  //=1.00000000000000000000000000000
  1065:   public final EFP      ASIN_C3 = new EFP (P,     -3, 0xaaaaaaaaaaaaaaaaL, 0xaa9f5a6L << 36);  //=0.166666666666666666666664327061
  1066:   public final EFP      ASIN_C5 = new EFP (P,     -4, 0x999999999999999bL, 0x27bc1b8L << 36);  //=0.0750000000000000000105385402653
  1067:   public final EFP      ASIN_C7 = new EFP (P,     -5, 0xb6db6db6db6d9dfbL, 0x62327e8L << 36);  //=0.0446428571428571212813671978867
  1068:   public final EFP      ASIN_C9 = new EFP (P,     -6, 0xf8e38e38e465b639L, 0x780782eL << 36);  //=0.0303819444444683685951253163427
  1069:   public final EFP     ASIN_C11 = new EFP (P,     -6, 0xb745d17238e942a1L, 0xe80f5beL << 36);  //=0.0223721590753288857337240816603
  1070:   public final EFP     ASIN_C13 = new EFP (P,     -6, 0x8e2765c0b9aaa792L, 0xa93870aL << 36);  //=0.0173527705535908188340798484805
  1071:   public final EFP     ASIN_C15 = new EFP (P,     -7, 0xe4c6ca7a5689895bL, 0x0fdd729L << 36);  //=0.0139634110758853644843472082762
  1072:   public final EFP     ASIN_C17 = new EFP (P,     -7, 0xc0428d0d9769d446L, 0x583b42dL << 36);  //=0.0117346169921491621622941093289
  1073:   //  92.12bit
  1074: 
  1075:   //------------------------------------------------------------------------
  1076:   //asinh
  1077:   //  echo read("efp.gp");efpchebyshev("ASINH_C",asinh,-1/2,1/2,43) | gp -q
  1078:   public final EFP     ASINH_C1 = new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36);  //=1.00000000000000000000000000000
  1079:   public final EFP     ASINH_C3 = new EFP (M,     -3, 0xaaaaaaaaaaaaaaaaL, 0xaaaa73cL << 36);  //=-0.166666666666666666666666622305
  1080:   public final EFP     ASINH_C5 = new EFP (P,     -4, 0x9999999999999999L, 0x98eba3eL << 36);  //=0.0749999999999999999999820129717
  1081:   public final EFP     ASINH_C7 = new EFP (M,     -5, 0xb6db6db6db6db6daL, 0x693062cL << 36);  //=-0.0446428571428571428536948337862
  1082:   public final EFP     ASINH_C9 = new EFP (P,     -6, 0xf8e38e38e38e3802L, 0x877ce5fL << 36);  //=0.0303819444444444440632350540650
  1083:   public final EFP    ASINH_C11 = new EFP (M,     -6, 0xb745d1745d17072fL, 0x8f119f4L << 36);  //=-0.0223721590909090637466150767286
  1084:   public final EFP    ASINH_C13 = new EFP (P,     -6, 0x8e27627627566903L, 0xdf845ccL << 36);  //=0.0173527644230755851112834055009
  1085:   public final EFP    ASINH_C15 = new EFP (M,     -7, 0xe4ccccccc9700e9eL, 0xe0b4a69L << 36);  //=-0.0139648437499522191713609105717
  1086:   public final EFP    ASINH_C17 = new EFP (P,     -7, 0xbd43c3c369baae2eL, 0x0efcbb2L << 36);  //=0.0115518008948602246771685034495
  1087:   public final EFP    ASINH_C19 = new EFP (M,     -7, 0x9fef28648d7f5526L, 0x95df2b5L << 36);  //=-0.00976160950286693766098184072269
  1088:   public final EFP    ASINH_C21 = new EFP (P,     -7, 0x89779e056ca4e338L, 0xd00497cL << 36);  //=0.00839033538586369462750852571141
  1089:   public final EFP    ASINH_C23 = new EFP (M,     -8, 0xef9dde222ea1963bL, 0xe27b426L << 36);  //=-0.00731252046931722928944285830165
  1090:   public final EFP    ASINH_C25 = new EFP (P,     -8, 0xd342a867c46a40d7L, 0x608fa17L << 36);  //=0.00644715521733314071113327514541
  1091:   public final EFP    ASINH_C27 = new EFP (M,     -8, 0xbc1323a7fe6984a7L, 0x201509dL << 36);  //=-0.00573958626772545827330135382977
  1092:   public final EFP    ASINH_C29 = new EFP (P,     -8, 0xa8c41a9477d0f87aL, 0x533f07cL << 36);  //=0.00515033052300720080631063831135
  1093:   public final EFP    ASINH_C31 = new EFP (M,     -8, 0x982f5aab1d57a757L, 0x87f7027L << 36);  //=-0.00464431693238042269332079800182
  1094:   public final EFP    ASINH_C33 = new EFP (P,     -8, 0x88c1b2170947d07cL, 0x03ff2fcL << 36);  //=0.00417348094749513993640755085487
  1095:   public final EFP    ASINH_C35 = new EFP (M,     -9, 0xef58f638c3ca7cffL, 0x77a770cL << 36);  //=-0.00365215312264336578286676378192
  1096:   public final EFP    ASINH_C37 = new EFP (P,     -9, 0xc1c49585f23563ecL, 0x9a83aedL << 36);  //=0.00295666361302767397480120706092
  1097:   public final EFP    ASINH_C39 = new EFP (M,     -9, 0x844314a5dc2c3362L, 0x37b5811L << 36);  //=-0.00201815847491166045931431987253
  1098:   public final EFP    ASINH_C41 = new EFP (P,    -10, 0x824564bc0126d26dL, 0x0c5dd9fL << 36);  //=9.93889376333981375114292565553e-4
  1099:   public final EFP    ASINH_C43 = new EFP (M,    -12, 0x85dfcbe40f7ac39fL, 0xb82e7c3L << 36);  //=-2.55344781642232531153119989033e-4
  1100:   //  94.34bit
  1101: 
  1102:   //------------------------------------------------------------------------
  1103:   //atan
  1104:   //  echo read("efp.gp");efpchebyshev("ATAN_C",atan,1-sqrt(2),sqrt(2)-1,39) | gp -q
  1105:   public final EFP      ATAN_C1 = new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36);  //=1.00000000000000000000000000000
  1106:   public final EFP      ATAN_C3 = new EFP (M,     -2, 0xaaaaaaaaaaaaaaaaL, 0xaaaa510L << 36);  //=-0.333333333333333333333333188469
  1107:   public final EFP      ATAN_C5 = new EFP (P,     -3, 0xccccccccccccccccL, 0xcb75e59L << 36);  //=0.199999999999999999999929089265
  1108:   public final EFP      ATAN_C7 = new EFP (M,     -3, 0x9249249249249247L, 0xef2e1e8L << 36);  //=-0.142857142857142857126478105101
  1109:   public final EFP      ATAN_C9 = new EFP (P,     -4, 0xe38e38e38e38e24dL, 0x0fb9b9aL << 36);  //=0.111111111111111108934840916430
  1110:   public final EFP     ATAN_C11 = new EFP (M,     -4, 0xba2e8ba2e8b9c37fL, 0xd40106dL << 36);  //=-0.0909090909090907233954815301475
  1111:   public final EFP     ATAN_C13 = new EFP (P,     -4, 0x9d89d89d89c01044L, 0xee8e878L << 36);  //=0.0769230769230660198728951590461
  1112:   public final EFP     ATAN_C15 = new EFP (M,     -4, 0x888888888479743eL, 0xd1a4c1cL << 36);  //=-0.0666666666662052227836546394505
  1113:   public final EFP     ATAN_C17 = new EFP (P,     -5, 0xf0f0f0eff12a86f3L, 0x34f4f78L << 36);  //=0.0588235293972255773084039586191
  1114:   public final EFP     ATAN_C19 = new EFP (M,     -5, 0xd79435cd132b46adL, 0x026fbddL << 36);  //=-0.0526315785984461994745177668558
  1115:   public final EFP     ATAN_C21 = new EFP (P,     -5, 0xc30c2f05b9b60e24L, 0x4f7cf62L << 36);  //=0.0476190411387569357252301278730
  1116:   public final EFP     ATAN_C23 = new EFP (M,     -5, 0xb216298497a81754L, 0x9c69988L << 36);  //=-0.0434781667513366645605035624712
  1117:   public final EFP     ATAN_C25 = new EFP (P,     -5, 0xa3d5e99dc5d0a87cL, 0x531842aL << 36);  //=0.0399989247929292486609759555531
  1118:   public final EFP     ATAN_C27 = new EFP (M,     -5, 0x97aa006d0e00c9c7L, 0x30d6815L << 36);  //=-0.0370273605957438052706320851811
  1119:   public final EFP     ATAN_C29 = new EFP (P,     -5, 0x8cf60e9e64655ffeL, 0x38ac19cL << 36);  //=0.0344143458408095737006383246276
  1120:   public final EFP     ATAN_C31 = new EFP (M,     -5, 0x82959208f1c7a2afL, 0xdae8a29L << 36);  //=-0.0318809227456870204466446023911
  1121:   public final EFP     ATAN_C33 = new EFP (P,     -6, 0xeb2210cae680d538L, 0x15fff4fL << 36);  //=0.0287027671794960285031110247127
  1122:   public final EFP     ATAN_C35 = new EFP (M,     -6, 0xc010e629b0e973a6L, 0xe64c5d3L << 36);  //=-0.0234455581062579745139013801043
  1123:   public final EFP     ATAN_C37 = new EFP (P,     -7, 0xf4fd1335dff0ecefL, 0x1237cb3L << 36);  //=0.0149529159166368844370818258508
  1124:   public final EFP     ATAN_C39 = new EFP (M,     -8, 0xae06e746e01494ddL, 0xc1bb093L << 36);  //=-0.00531088154616611800320323885484
  1125:   //  92.91bit
  1126: 
  1127:   //------------------------------------------------------------------------
  1128:   //atanh
  1129:   //  echo read("efp.gp");efpchebyshev("ATANH_C",atanh,-1/16,1/16,19) | gp -q
  1130:   public final EFP     ATANH_C1 = new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36);  //=1.00000000000000000000000000000
  1131:   public final EFP     ATANH_C3 = new EFP (P,     -2, 0xaaaaaaaaaaaaaaaaL, 0xaaaab40L << 36);  //=0.333333333333333333333333348412
  1132:   public final EFP     ATANH_C5 = new EFP (P,     -3, 0xccccccccccccccccL, 0xcb39274L << 36);  //=0.199999999999999999999916527823
  1133:   public final EFP     ATANH_C7 = new EFP (P,     -3, 0x9249249249249258L, 0xc166b48L << 36);  //=0.142857142857142857354447548729
  1134:   public final EFP     ATANH_C9 = new EFP (P,     -4, 0xe38e38e38e38399dL, 0xe3605a0L << 36);  //=0.111111111111110816314276914861
  1135:   public final EFP    ATANH_C11 = new EFP (P,     -4, 0xba2e8ba2eae60f89L, 0xa98ab82L << 36);  //=0.0909090909093377689017810115409
  1136:   public final EFP    ATANH_C13 = new EFP (P,     -4, 0x9d89d8991665e749L, 0xd36e921L << 36);  //=0.0769230767935366725885888098730
  1137:   public final EFP    ATANH_C15 = new EFP (P,     -4, 0x88888e4ace4d77aaL, 0xa2aa416L << 36);  //=0.0666667095736446080100633321247
  1138:   public final EFP    ATANH_C17 = new EFP (P,     -5, 0xf0e7cfa2bdbf9821L, 0x93bcd2aL << 36);  //=0.0588148222703778409986221399492
  1139:   public final EFP    ATANH_C19 = new EFP (P,     -5, 0xdb9f4d0dedd2896fL, 0x4b48c7fL << 36);  //=0.0536187181413551121288347545022
  1140:   //  99.69bit
  1141:   public final EFP[] ATH_T = {
  1142:     //  echo read("efp.gp");for(n=0,92,efpmem([Str("1-2/(2^",n,".5+1)")])) | gp -q
  1143:     new EFP (P,     -3, 0xafb0ccc06219b7baL, 0x682764dL << 36),  //>1-2/(2^0.5+1)=0.171572875253809902396622551581
  1144:     new EFP (P,     -2, 0xf486f8adc4df1a3fL, 0x3373579L << 36),  //>1-2/(2^1.5+1)=0.477592250072517114970463586166
  1145:     new EFP (P,     -1, 0xb31638273cf89250L, 0x55f0c13L << 36),  //>1-2/(2^2.5+1)=0.699557790355330309986660974397
  1146:     new EFP (P,     -1, 0xd66b9a67d12abc57L, 0x98d2421L << 36),  //<1-2/(2^3.5+1)=0.837579393716775426922621893013
  1147:     new EFP (P,     -1, 0xea548bdf707c71a8L, 0x48f4c93L << 36),  //>1-2/(2^4.5+1)=0.915352575350412834517311077936
  1148:     new EFP (P,     -1, 0xf4ee4e9693348047L, 0xc360937L << 36),  //<1-2/(2^5.5+1)=0.956761276017646271068242267538
  1149:     new EFP (P,     -1, 0xfa67aba3bd4ef753L, 0x97d0d24L << 36),  //>1-2/(2^6.5+1)=0.978144385791264050024830160335
  1150:     new EFP (P,     -1, 0xfd2fe692fd3e80eaL, 0xf06feacL << 36),  //>1-2/(2^7.5+1)=0.989012156377834030198271666207
  1151:     new EFP (P,     -1, 0xfe96f56512becc96L, 0x5d9833cL << 36),  //>1-2/(2^8.5+1)=0.994490945030288739194890825379
  1152:     new EFP (P,     -1, 0xff4b3af63364e808L, 0x18a7859L << 36),  //>1-2/(2^9.5+1)=0.997241673572165532752151151462
  1153:     new EFP (P,     -1, 0xffa58d83926f2d61L, 0x373e4afL << 36),  //<1-2/(2^10.5+1)=0.998619885084221356182770883686
  1154:     new EFP (P,     -1, 0xffd2c2c2d8870e17L, 0xed05d07L << 36),  //<1-2/(2^11.5+1)=0.999309704370286962147601894210
  1155:     new EFP (P,     -1, 0xffe960618e30f4faL, 0x87ef4d9L << 36),  //<1-2/(2^12.5+1)=0.999654792611355549595229809320
  1156:     new EFP (P,     -1, 0xfff4aff0cb566033L, 0x22866e9L << 36),  //>1-2/(2^13.5+1)=0.999827381408374463164023282349
  1157:     new EFP (P,     -1, 0xfffa57e86632f050L, 0x0d74b69L << 36),  //<1-2/(2^14.5+1)=0.999913686979379216955639576948
  1158:     new EFP (P,     -1, 0xfffd2bf0332a7066L, 0xd4437adL << 36),  //<1-2/(2^15.5+1)=0.999956842558427322377129017797
  1159:     new EFP (P,     -1, 0xfffe95f71997573eL, 0xc3c2f8aL << 36),  //<1-2/(2^16.5+1)=0.999978421046390553788765568617
  1160:     new EFP (P,     -1, 0xffff4afb4ccbef81L, 0x0515247L << 36),  //<1-2/(2^17.5+1)=0.999989210464988558024532263171
  1161:     new EFP (P,     -1, 0xffffa57d9666003cL, 0xba71034L << 36),  //<1-2/(2^18.5+1)=0.999994605217942481540092531517
  1162:     new EFP (P,     -1, 0xffffd2bec733012dL, 0xe46d4faL << 36),  //<1-2/(2^19.5+1)=0.999997302605333276682525030987
  1163:     new EFP (P,     -1, 0xffffe95f629980b8L, 0xe320c19L << 36),  //<1-2/(2^20.5+1)=0.999998651301757145479438792148
  1164:     new EFP (P,     -1, 0xfffff4afb10cc060L, 0xafaddc0L << 36),  //<1-2/(2^21.5+1)=0.999999325650651199294269995571
  1165:     new EFP (P,     -1, 0xfffffa57d8766030L, 0xdf9aa0eL << 36),  //<1-2/(2^22.5+1)=0.999999662825268756257023430024
  1166:     new EFP (P,     -1, 0xfffffd2bec373018L, 0x80c5c71L << 36),  //>1-2/(2^23.5+1)=0.999999831412620167277390168747
  1167:     new EFP (P,     -1, 0xfffffe95f61a980cL, 0x4281f26L << 36),  //>1-2/(2^24.5+1)=0.999999915706306530925465490884
  1168:     new EFP (P,     -1, 0xffffff4afb0d0c06L, 0x2184db1L << 36),  //>1-2/(2^25.5+1)=0.999999957853152377284369196196
  1169:     new EFP (P,     -1, 0xffffffa57d867603L, 0x10cae9cL << 36),  //>1-2/(2^26.5+1)=0.999999978926575966597586691927
  1170:     new EFP (P,     -1, 0xffffffd2bec33701L, 0x8866846L << 36),  //<1-2/(2^27.5+1)=0.999999989463287927787642992063
  1171:     new EFP (P,     -1, 0xffffffe95f619a80L, 0xc433642L << 36),  //<1-2/(2^28.5+1)=0.999999994731643950016033797887
  1172:     new EFP (P,     -1, 0xfffffff4afb0cd00L, 0x6219b65L << 36),  //<1-2/(2^29.5+1)=0.999999997365821971538569960698
  1173:     new EFP (P,     -1, 0xfffffffa57d86670L, 0x310cdbbL << 36),  //>1-2/(2^30.5+1)=0.999999998682910984901923244074
  1174:     new EFP (P,     -1, 0xfffffffd2bec3334L, 0x18866dfL << 36),  //>1-2/(2^31.5+1)=0.999999999341455492234121187754
  1175:     new EFP (P,     -1, 0xfffffffe95f61999L, 0x0c4336fL << 36),  //<1-2/(2^32.5+1)=0.999999999670727746062850485280
  1176:     new EFP (P,     -1, 0xffffffff4afb0cccL, 0x46219b8L << 36),  //>1-2/(2^33.5+1)=0.999999999835363873017872715487
  1177:     new EFP (P,     -1, 0xffffffffa57d8666L, 0x1310cdcL << 36),  //>1-2/(2^34.5+1)=0.999999999917681936505548225955
  1178:     new EFP (P,     -1, 0xffffffffd2bec333L, 0x058866eL << 36),  //>1-2/(2^35.5+1)=0.999999999958840968251927080030
  1179:     new EFP (P,     -1, 0xffffffffe95f6199L, 0x81c4337L << 36),  //>1-2/(2^36.5+1)=0.999999999979420484125751781778
  1180:     new EFP (P,     -1, 0xfffffffff4afb0ccL, 0xc0a219bL << 36),  //<1-2/(2^37.5+1)=0.999999999989710242062822951330
  1181:     new EFP (P,     -1, 0xfffffffffa57d866L, 0x60410ceL << 36),  //>1-2/(2^38.5+1)=0.999999999994855121031398240775
  1182:     new EFP (P,     -1, 0xfffffffffd2bec33L, 0x301c867L << 36),  //>1-2/(2^39.5+1)=0.999999999997427560515695811665
  1183:     new EFP (P,     -1, 0xfffffffffe95f619L, 0x980d433L << 36),  //<1-2/(2^40.5+1)=0.999999999998713780257847078652
  1184:     new EFP (P,     -1, 0xffffffffff4afb0cL, 0xcc0661aL << 36),  //>1-2/(2^41.5+1)=0.999999999999356890128923332531
  1185:     new EFP (P,     -1, 0xffffffffffa57d86L, 0x660320dL << 36),  //>1-2/(2^42.5+1)=0.999999999999678445064461614567
  1186:     new EFP (P,     -1, 0xffffffffffd2bec3L, 0x33018c6L << 36),  //<1-2/(2^43.5+1)=0.999999999999839222532230794359
  1187:     new EFP (P,     -1, 0xffffffffffe95f61L, 0x9980c53L << 36),  //<1-2/(2^44.5+1)=0.999999999999919611266115393948
  1188:     new EFP (P,     -1, 0xfffffffffff4afb0L, 0xccc0626L << 36),  //>1-2/(2^45.5+1)=0.999999999999959805633057696166
  1189:     new EFP (P,     -1, 0xfffffffffffa57d8L, 0x6660312L << 36),  //>1-2/(2^46.5+1)=0.999999999999979902816528847881
  1190:     new EFP (P,     -1, 0xfffffffffffd2becL, 0x3330189L << 36),  //>1-2/(2^47.5+1)=0.999999999999989951408264423890
  1191:     new EFP (P,     -1, 0xfffffffffffe95f6L, 0x19980c4L << 36),  //<1-2/(2^48.5+1)=0.999999999999994975704132211932
  1192:     new EFP (P,     -1, 0xffffffffffff4afbL, 0x0ccc062L << 36),  //<1-2/(2^49.5+1)=0.999999999999997487852066105963
  1193:     new EFP (P,     -1, 0xffffffffffffa57dL, 0x8666031L << 36),  //<1-2/(2^50.5+1)=0.999999999999998743926033052981
  1194:     new EFP (P,     -1, 0xffffffffffffd2beL, 0xc333019L << 36),  //>1-2/(2^51.5+1)=0.999999999999999371963016526490
  1195:     new EFP (P,     -1, 0xffffffffffffe95fL, 0x619980cL << 36),  //<1-2/(2^52.5+1)=0.999999999999999685981508263245
  1196:     new EFP (P,     -1, 0xfffffffffffff4afL, 0xb0ccc06L << 36),  //<1-2/(2^53.5+1)=0.999999999999999842990754131623
  1197:     new EFP (P,     -1, 0xfffffffffffffa57L, 0xd866603L << 36),  //<1-2/(2^54.5+1)=0.999999999999999921495377065811
  1198:     new EFP (P,     -1, 0xfffffffffffffd2bL, 0xec33302L << 36),  //>1-2/(2^55.5+1)=0.999999999999999960747688532906
  1199:     new EFP (P,     -1, 0xfffffffffffffe95L, 0xf619981L << 36),  //>1-2/(2^56.5+1)=0.999999999999999980373844266453
  1200:     new EFP (P,     -1, 0xffffffffffffff4aL, 0xfb0ccc0L << 36),  //<1-2/(2^57.5+1)=0.999999999999999990186922133226
  1201:     new EFP (P,     -1, 0xffffffffffffffa5L, 0x7d86660L << 36),  //<1-2/(2^58.5+1)=0.999999999999999995093461066613
  1202:     new EFP (P,     -1, 0xffffffffffffffd2L, 0xbec3330L << 36),  //<1-2/(2^59.5+1)=0.999999999999999997546730533307
  1203:     new EFP (P,     -1, 0xffffffffffffffe9L, 0x5f61998L << 36),  //<1-2/(2^60.5+1)=0.999999999999999998773365266653
  1204:     new EFP (P,     -1, 0xfffffffffffffff4L, 0xafb0cccL << 36),  //<1-2/(2^61.5+1)=0.999999999999999999386682633327
  1205:     new EFP (P,     -1, 0xfffffffffffffffaL, 0x57d8666L << 36),  //<1-2/(2^62.5+1)=0.999999999999999999693341316663
  1206:     new EFP (P,     -1, 0xfffffffffffffffdL, 0x2bec333L << 36),  //<1-2/(2^63.5+1)=0.999999999999999999846670658332
  1207:     new EFP (P,     -1, 0xfffffffffffffffeL, 0x95f619aL << 36),  //>1-2/(2^64.5+1)=0.999999999999999999923335329166
  1208:     new EFP (P,     -1, 0xffffffffffffffffL, 0x4afb0cdL << 36),  //>1-2/(2^65.5+1)=0.999999999999999999961667664583
  1209:     new EFP (P,     -1, 0xffffffffffffffffL, 0xa57d866L << 36),  //<1-2/(2^66.5+1)=0.999999999999999999980833832291
  1210:     new EFP (P,     -1, 0xffffffffffffffffL, 0xd2bec33L << 36),  //<1-2/(2^67.5+1)=0.999999999999999999990416916146
  1211:     new EFP (P,     -1, 0xffffffffffffffffL, 0xe95f61aL << 36),  //>1-2/(2^68.5+1)=0.999999999999999999995208458073
  1212:     new EFP (P,     -1, 0xffffffffffffffffL, 0xf4afb0dL << 36),  //>1-2/(2^69.5+1)=0.999999999999999999997604229036
  1213:     new EFP (P,     -1, 0xffffffffffffffffL, 0xfa57d86L << 36),  //<1-2/(2^70.5+1)=0.999999999999999999998802114518
  1214:     new EFP (P,     -1, 0xffffffffffffffffL, 0xfd2bec3L << 36),  //<1-2/(2^71.5+1)=0.999999999999999999999401057259
  1215:     new EFP (P,     -1, 0xffffffffffffffffL, 0xfe95f62L << 36),  //>1-2/(2^72.5+1)=0.999999999999999999999700528630
  1216:     new EFP (P,     -1, 0xffffffffffffffffL, 0xff4afb1L << 36),  //>1-2/(2^73.5+1)=0.999999999999999999999850264315
  1217:     new EFP (P,     -1, 0xffffffffffffffffL, 0xffa57d8L << 36),  //<1-2/(2^74.5+1)=0.999999999999999999999925132157
  1218:     new EFP (P,     -1, 0xffffffffffffffffL, 0xffd2becL << 36),  //<1-2/(2^75.5+1)=0.999999999999999999999962566079
  1219:     new EFP (P,     -1, 0xffffffffffffffffL, 0xffe95f6L << 36),  //<1-2/(2^76.5+1)=0.999999999999999999999981283039
  1220:     new EFP (P,     -1, 0xffffffffffffffffL, 0xfff4afbL << 36),  //<1-2/(2^77.5+1)=0.999999999999999999999990641520
  1221:     new EFP (P,     -1, 0xffffffffffffffffL, 0xfffa57eL << 36),  //>1-2/(2^78.5+1)=0.999999999999999999999995320760
  1222:     new EFP (P,     -1, 0xffffffffffffffffL, 0xfffd2bfL << 36),  //>1-2/(2^79.5+1)=0.999999999999999999999997660380
  1223:     new EFP (P,     -1, 0xffffffffffffffffL, 0xfffe95fL << 36),  //<1-2/(2^80.5+1)=0.999999999999999999999998830190
  1224:     new EFP (P,     -1, 0xffffffffffffffffL, 0xffff4b0L << 36),  //>1-2/(2^81.5+1)=0.999999999999999999999999415095
  1225:     new EFP (P,     -1, 0xffffffffffffffffL, 0xffffa58L << 36),  //>1-2/(2^82.5+1)=0.999999999999999999999999707547
  1226:     new EFP (P,     -1, 0xffffffffffffffffL, 0xffffd2cL << 36),  //>1-2/(2^83.5+1)=0.999999999999999999999999853774
  1227:     new EFP (P,     -1, 0xffffffffffffffffL, 0xffffe96L << 36),  //>1-2/(2^84.5+1)=0.999999999999999999999999926887
  1228:     new EFP (P,     -1, 0xffffffffffffffffL, 0xfffff4bL << 36),  //>1-2/(2^85.5+1)=0.999999999999999999999999963443
  1229:     new EFP (P,     -1, 0xffffffffffffffffL, 0xfffffa5L << 36),  //<1-2/(2^86.5+1)=0.999999999999999999999999981722
  1230:     new EFP (P,     -1, 0xffffffffffffffffL, 0xfffffd3L << 36),  //>1-2/(2^87.5+1)=0.999999999999999999999999990861
  1231:     new EFP (P,     -1, 0xffffffffffffffffL, 0xfffffe9L << 36),  //<1-2/(2^88.5+1)=0.999999999999999999999999995430
  1232:     new EFP (P,     -1, 0xffffffffffffffffL, 0xffffff5L << 36),  //>1-2/(2^89.5+1)=0.999999999999999999999999997715
  1233:     new EFP (P,     -1, 0xffffffffffffffffL, 0xffffffaL << 36),  //<1-2/(2^90.5+1)=0.999999999999999999999999998858
  1234:     new EFP (P,     -1, 0xffffffffffffffffL, 0xffffffdL << 36),  //<1-2/(2^91.5+1)=0.999999999999999999999999999429
  1235:     new EFP (P,     -1, 0xffffffffffffffffL, 0xfffffffL << 36),  //>1-2/(2^92.5+1)=0.999999999999999999999999999714
  1236:   };  //ATH_T
  1237:   //  echo read("efp.gp");efpchebyshev("ATH_C",atanh,2*sqrt(2)-3,3-2*sqrt(2),27) | gp -q
  1238:   public final EFP       ATH_C1 = new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36);  //=1.00000000000000000000000000000
  1239:   public final EFP       ATH_C3 = new EFP (P,     -2, 0xaaaaaaaaaaaaaaaaL, 0xaaaaafaL << 36);  //=0.333333333333333333333333341344
  1240:   public final EFP       ATH_C5 = new EFP (P,     -3, 0xccccccccccccccccL, 0xcc9635cL << 36);  //=0.199999999999999999999988711045
  1241:   public final EFP       ATH_C7 = new EFP (P,     -3, 0x9249249249249249L, 0xb11c709L << 36);  //=0.142857142857142857150297250720
  1242:   public final EFP       ATH_C9 = new EFP (P,     -4, 0xe38e38e38e38e1f4L, 0xa08ab7fL << 36);  //=0.111111111111111108335586715660
  1243:   public final EFP      ATH_C11 = new EFP (P,     -4, 0xba2e8ba2e8bba550L, 0x957b4b0L << 36);  //=0.0909090909090915592120576087311
  1244:   public final EFP      ATH_C13 = new EFP (P,     -4, 0x9d89d89d88f3a6b4L, 0xb83ee9bL << 36);  //=0.0769230769229752425509012132237
  1245:   public final EFP      ATH_C15 = new EFP (P,     -4, 0x88888888e97610a0L, 0x018bbc5L << 36);  //=0.0666666666776860883121262399402
  1246:   public final EFP      ATH_C17 = new EFP (P,     -5, 0xf0f0f0b6e98b6c2fL, 0x176ec78L << 36);  //=0.0588235285673331770514149020773
  1247:   public final EFP      ATH_C19 = new EFP (P,     -5, 0xd79442422528c14bL, 0xdacdc08L << 36);  //=0.0526316250055264844984084010822
  1248:   public final EFP      ATH_C21 = new EFP (P,     -5, 0xc30a54423d395d6dL, 0xa2f5188L << 36);  //=0.0476172725064557245020882061529
  1249:   public final EFP      ATH_C23 = new EFP (P,     -5, 0xb247b3a940a7a020L, 0x5cb7483L << 36);  //=0.0435254114163771411702547167136
  1250:   public final EFP      ATH_C25 = new EFP (P,     -5, 0xa07d6fb3e1085165L, 0x68590abL << 36);  //=0.0391821254143583526005317341260
  1251:   public final EFP      ATH_C27 = new EFP (P,     -5, 0xb976c8a2f3029b2dL, 0xa0b471bL << 36);  //=0.0452792966236194263462909201691
  1252:   //  98.60bit
  1253: 
  1254:   //------------------------------------------------------------------------
  1255:   //cos
  1256:   //  echo read("efp.gp");efpchebyshev("COS_C",cos,-Pi/4,Pi/4,20) | gp -q
  1257:   public final EFP       COS_C0 = new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36);  //=1.00000000000000000000000000000
  1258:   public final EFP       COS_C2 = new EFP (M,     -2, 0xffffffffffffffffL, 0xffffff8L << 36);  //=-0.499999999999999999999999999192
  1259:   public final EFP       COS_C4 = new EFP (P,     -5, 0xaaaaaaaaaaaaaaaaL, 0xaaa9a56L << 36);  //=0.0416666666666666666666666138992
  1260:   public final EFP       COS_C6 = new EFP (M,    -10, 0xb60b60b60b60b60bL, 0x5d7bff4L << 36);  //=-0.00138888888888888888888755433738
  1261:   public final EFP       COS_C8 = new EFP (P,    -16, 0xd00d00d00d00d002L, 0x8a46e65L << 36);  //=2.48015873015873015699919557419e-5
  1262:   public final EFP      COS_C10 = new EFP (M,    -22, 0x93f27dbbc4facfccL, 0xd7af990L << 36);  //=-2.75573192239858775556350380978e-7
  1263:   public final EFP      COS_C12 = new EFP (P,    -29, 0x8f76c77fc6961076L, 0x0290d00L << 36);  //=2.08767569878619213856987201647e-9
  1264:   public final EFP      COS_C14 = new EFP (M,    -37, 0xc9cba54576804449L, 0x648c611L << 36);  //=-1.14707455958584021049089234187e-11
  1265:   public final EFP      COS_C16 = new EFP (P,    -45, 0xd73f9e26754ce09dL, 0xec906ebL << 36);  //=4.77947696821877613102951591111e-14
  1266:   public final EFP      COS_C18 = new EFP (M,    -53, 0xb412768e7c3c3046L, 0x846cd1fL << 36);  //=-1.56187668293428465635746630579e-16
  1267:   public final EFP      COS_C20 = new EFP (P,    -62, 0xf0dad505af592189L, 0x064973cL << 36);  //=4.08023924165342585701515258359e-19
  1268:   //  97.20bit
  1269:   //  echo read("efp.gp");efpchebyshev("SIN_C",sin,-Pi/4,Pi/4,21) | gp -q
  1270:   public final EFP       SIN_C1 = new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36);  //=1.00000000000000000000000000000
  1271:   public final EFP       SIN_C3 = new EFP (M,     -3, 0xaaaaaaaaaaaaaaaaL, 0xaaaaaa8L << 36);  //=-0.166666666666666666666666666532
  1272:   public final EFP       SIN_C5 = new EFP (P,     -7, 0x8888888888888888L, 0x88880d0L << 36);  //=0.00833333333333333333333332709649
  1273:   public final EFP       SIN_C7 = new EFP (M,    -13, 0xd00d00d00d00d00cL, 0xfe77205L << 36);  //=-1.98412698412698412698291342662e-4
  1274:   public final EFP       SIN_C9 = new EFP (P,    -19, 0xb8ef1d2ab6399c76L, 0xfe4484aL << 36);  //=2.75573192239858906394404635468e-6
  1275:   public final EFP      SIN_C11 = new EFP (M,    -26, 0xd7322b3faa27078eL, 0x1700055L << 36);  //=-2.50521083854417101136670463394e-8
  1276:   public final EFP      SIN_C13 = new EFP (P,    -33, 0xb092309d433be4baL, 0xeb15e86L << 36);  //=1.60590438368179416703490738961e-10
  1277:   public final EFP      SIN_C15 = new EFP (M,    -41, 0xd73f9f392253780eL, 0x670f3ecL << 36);  //=-7.64716373079884612335141370435e-13
  1278:   public final EFP      SIN_C17 = new EFP (P,    -49, 0xca963aa1cfea3bf8L, 0x08cec0aL << 36);  //=2.81145706929778488157207193776e-15
  1279:   public final EFP      SIN_C19 = new EFP (M,    -57, 0x97a3db8f70e5ae02L, 0x8f1dd1fL << 36);  //=-8.22042461090320344889517792891e-18
  1280:   public final EFP      SIN_C21 = new EFP (P,    -66, 0xb791d94ca9fd98fdL, 0x74f2261L << 36);  //=1.94362003290782920561352619652e-20
  1281:   //  96.74bit
  1282: 
  1283:   //------------------------------------------------------------------------
  1284:   //cosh
  1285:   //  echo read("efp.gp");efpchebyshev("COSH_C",cosh,-1/8,1/8,14) | gp -q
  1286:   public final EFP      COSH_C0 = new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36);  //=1.00000000000000000000000000000
  1287:   public final EFP      COSH_C2 = new EFP (P,     -1, 0x8000000000000000L, 0x0000000L << 36);  //=0.500000000000000000000000000000
  1288:   public final EFP      COSH_C4 = new EFP (P,     -5, 0xaaaaaaaaaaaaaaaaL, 0xaaa9902L << 36);  //=0.0416666666666666666666666096078
  1289:   public final EFP      COSH_C6 = new EFP (P,    -10, 0xb60b60b60b60b60bL, 0xa75a997L << 36);  //=0.00138888888888888888891810606314
  1290:   public final EFP      COSH_C8 = new EFP (P,    -16, 0xd00d00d00d00beb4L, 0xa29cfbaL << 36);  //=2.48015873015872942413289979337e-5
  1291:   public final EFP     COSH_C10 = new EFP (P,    -22, 0x93f27dbbc74aee4dL, 0x312895cL << 36);  //=2.75573192240861864407003360028e-7
  1292:   public final EFP     COSH_C12 = new EFP (P,    -29, 0x8f76c72851473b51L, 0xdc04f2cL << 36);  //=2.08767562292826617371683025321e-9
  1293:   public final EFP     COSH_C14 = new EFP (P,    -37, 0xc9d919ab996aa4aeL, 0x80c913fL << 36);  //=1.14737331357355798829750446122e-11
  1294:   //  100.26bit
  1295: 
  1296:   //------------------------------------------------------------------------
  1297:   //exp
  1298:   public final EFP[] EXP_P_I = {
  1299:     //  echo read("efp.gp");for(n=0,14,efpmem([Str("exp(2^",n,")")])) | gp -q
  1300:     new EFP (P,      1, 0xadf85458a2bb4a9aL, 0xafdc562L << 36),  //<exp(2^0)=2.71828182845904523536028747135
  1301:     new EFP (P,      2, 0xec7325c6a6ed6e61L, 0x9d1dd10L << 36),  //<exp(2^1)=7.38905609893065022723042746058
  1302:     new EFP (P,      5, 0xda64817139d2c33cL, 0x6b69dffL << 36),  //>exp(2^2)=54.5981500331442390781102612029
  1303:     new EFP (P,     11, 0xba4f53ea38636f85L, 0xf007042L << 36),  //<exp(2^3)=2980.95798704172827474359209945
  1304:     new EFP (P,     23, 0x87975e8540010249L, 0x11f8b84L << 36),  //<exp(2^4)=8886110.52050787263676302374078
  1305:     new EFP (P,     46, 0x8fa1fe625b3163ecL, 0x23c4201L << 36),  //>exp(2^5)=78962960182680.6951609780226351
  1306:     new EFP (P,     92, 0xa12cc167acbe6902L, 0xe71eadaL << 36),  //<exp(2^6)=6235149080811616882909238708.93
  1307:     new EFP (P,    184, 0xcaf2a62eea10bbfaL, 0x9fa6a91L << 36),  //>exp(2^7)=3.88770840599459509222267368836e+55
  1308:     new EFP (P,    369, 0xa0e3d440a5f5d071L, 0x919807cL << 36),  //>exp(2^8)=1.51142766500410354252008966571e+111
  1309:     new EFP (P,    738, 0xca3b2825d4297360L, 0x4e42b3eL << 36),  //<exp(2^9)=2.28441358653975664037875151712e+222
  1310:     new EFP (P,   1477, 0x9fc169073a8d0d13L, 0x21c376bL << 36),  //<exp(2^10)=5.21854543436743420112120953370e+444
  1311:     new EFP (P,   2954, 0xc763a52d0570da4eL, 0xe13cad2L << 36),  //<exp(2^11)=2.72332164505571925012480592774e+889
  1312:     new EFP (P,   5909, 0x9b4c119529dab99dL, 0xde62927L << 36),  //<exp(2^12)=7.41648078242898890481921050373e+1778
  1313:     new EFP (P,  11818, 0xbc6a67ca24e9ba38L, 0x5a44770L << 36),  //<exp(2^13)=5.50041871961385074607498352511e+3557
  1314:     new EFP (P,  23637, 0x8aac74ab03b22463L, 0x55451adL << 36),  //<exp(2^14)=3.02546060910784732301427230567e+7115
  1315:   };  //EXP_P_I
  1316:   public final EFP[] EXP_M_I = {
  1317:     //  echo read("efp.gp");for(n=0,14,efpmem([Str("exp(-2^",n,")")])) | gp -q
  1318:     new EFP (P,     -2, 0xbc5ab1b16779be35L, 0x75bd8f0L << 36),  //<exp(-2^0)=0.367879441171442321595523770161
  1319:     new EFP (P,     -3, 0x8a95551dfc0e5cfeL, 0xdbb7571L << 36),  //>exp(-2^1)=0.135335283236612691893999494972
  1320:     new EFP (P,     -6, 0x960aadc109e7a3bfL, 0x4578099L << 36),  //<exp(-2^2)=0.0183156388887341802937180212732
  1321:     new EFP (P,    -12, 0xafe10820813d65dfL, 0xe6a33c0L << 36),  //<exp(-2^3)=3.35462627902511838821389125781e-4
  1322:     new EFP (P,    -24, 0xf1aaddd7742e56d3L, 0x2fb9f99L << 36),  //<exp(-2^4)=1.12535174719259114513775179060e-7
  1323:     new EFP (P,    -47, 0xe42327bb0b2340f1L, 0x4cd0092L << 36),  //<exp(-2^5)=1.26641655490941757231209041560e-14
  1324:     new EFP (P,    -93, 0xcb4ea3990f265d5fL, 0x9694038L << 36),  //<exp(-2^6)=1.60381089054863785297608703414e-28
  1325:     new EFP (P,   -185, 0xa175cf9cd7d85844L, 0x76b75a8L << 36),  //>exp(-2^7)=2.57220937264241482683953808361e-56
  1326:     new EFP (P,   -370, 0xcbaacab56a74dfdcL, 0xe09d13dL << 36),  //<exp(-2^8)=6.61626105670948526102953080736e-112
  1327:     new EFP (P,   -739, 0xa2084f6d90498ad1L, 0xc4658daL << 36),  //<exp(-2^9)=4.37749103705305145412147276290e-223
  1328:     new EFP (P,  -1478, 0xcd1d09977435cc77L, 0x7a9a998L << 36),  //>exp(-2^10)=1.91624277794797998988359419145e-445
  1329:     new EFP (P,  -2955, 0xa45784a7bcca7d6dL, 0xc205c90L << 36),  //<exp(-2^11)=3.67198638403779134660860694154e-890
  1330:     new EFP (P,  -5910, 0xd3007fc4b14655ddL, 0x1be84e5L << 36),  //>exp(-2^12)=1.34834840045589340763610867190e-1779
  1331:     new EFP (P, -11819, 0xade9d29e7bfeb08eL, 0x33a8236L << 36),  //<exp(-2^13)=1.81804340901196629372122861908e-3558
  1332:     new EFP (P, -23638, 0xec4bb8768ab8ab91L, 0x718a7e7L << 36),  //<exp(-2^14)=3.30528183705185176386021874079e-7116
  1333:   };  //EXP_M_I
  1334:   //  echo read("efp.gp");efpchebyshev("EXP_C",exp,-1/64,1/64,10) | gp -q
  1335:   public final EFP       EXP_C0 = new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36);  //=1.00000000000000000000000000000
  1336:   public final EFP       EXP_C1 = new EFP (P,      0, 0x8000000000000000L, 0x0000001L << 36);  //=1.00000000000000000000000000040
  1337:   public final EFP       EXP_C2 = new EFP (P,     -1, 0x8000000000000000L, 0x0000000L << 36);  //=0.500000000000000000000000000000
  1338:   public final EFP       EXP_C3 = new EFP (P,     -3, 0xaaaaaaaaaaaaaaaaL, 0xaa4e330L << 36);  //=0.166666666666666666666647544847
  1339:   public final EFP       EXP_C4 = new EFP (P,     -5, 0xaaaaaaaaaaaaaaaaL, 0xaa6fd2eL << 36);  //=0.0416666666666666666666636245582
  1340:   public final EFP       EXP_C5 = new EFP (P,     -7, 0x8888888888888a8eL, 0x59cdd2cL << 36);  //=0.00833333333333333377194178560698
  1341:   public final EFP       EXP_C6 = new EFP (P,    -10, 0xb60b60b60b60b801L, 0x80edd29L << 36);  //=0.00138888888888888894205353133322
  1342:   public final EFP       EXP_C7 = new EFP (P,    -13, 0xd00d00cffa827bd9L, 0xd1653b8L << 36);  //=1.98412698408592036950274523884e-4
  1343:   public final EFP       EXP_C8 = new EFP (P,    -16, 0xd00d00cffddf45a5L, 0xbdc8fc1L << 36);  //=2.48015873011673314697922289744e-5
  1344:   public final EFP       EXP_C9 = new EFP (P,    -19, 0xb8ef6724028aa32dL, 0x54addf6L << 36);  //=2.75574874209809900360756318657e-6
  1345:   public final EFP      EXP_C10 = new EFP (P,    -22, 0x93f2b38858c23b84L, 0xa93e7c6L << 36);  //=2.75574721303097208995296164475e-7
  1346:   //  98.10bit
  1347:   public final EFP[] EXP_P_T = {
  1348:     //  echo read("efp.gp");for(n=0,63,efpmem([Str("exp(",n,"/64)")])) | gp -q
  1349:     new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36),  //=exp(0/64)=1.00000000000000000000000000000
  1350:     new EFP (P,      0, 0x8204055aaef1c8bdL, 0x5c3259fL << 36),  //<exp(1/64)=1.01574770858668574745853507208
  1351:     new EFP (P,      0, 0x84102b00893f64c7L, 0x05e841dL << 36),  //<exp(2/64)=1.03174340749910267093874781528
  1352:     new EFP (P,      0, 0x862491b414f45e14L, 0x967f31fL << 36),  //>exp(3/64)=1.04799100201663270227673829182
  1353:     new EFP (P,      0, 0x88415abbe9a76beaL, 0xd8d00cfL << 36),  //<exp(4/64)=1.06449445891785942956339059464
  1354:     new EFP (P,      0, 0x8a66a7e4c4e6b22aL, 0xaf50ce3L << 36),  //<exp(5/64)=1.08125780744903960314089465174
  1355:     new EFP (P,      0, 0x8c949b83a7066b44L, 0x9e8c66eL << 36),  //>exp(6/64)=1.09828514030782584865020993426
  1356:     new EFP (P,      0, 0x8ecb5877f873c9e8L, 0xac7a4d3L << 36),  //<exp(7/64)=1.11558061464248075869370450838
  1357:     new EFP (P,      0, 0x910b022db7ae67ceL, 0x76b441cL << 36),  //<exp(8/64)=1.13314845306682631682900722781
  1358:     new EFP (P,      0, 0x9353bc9fb00b215aL, 0xeb98600L << 36),  //<exp(9/64)=1.15099294469117644932213966578
  1359:     new EFP (P,      0, 0x95a5ac59b963ca80L, 0x9bb3e06L << 36),  //<exp(10/64)=1.16911844616950440229818469151
  1360:     new EFP (P,      0, 0x9800f67b00d7b805L, 0xeae44b2L << 36),  //>exp(11/64)=1.18752938276310060558880782283
  1361:     new EFP (P,      0, 0x9a65c0b85ac1a96aL, 0x7062466L << 36),  //>exp(12/64)=1.20623024942098071065558601045
  1362:     new EFP (P,      0, 0x9cd4315e9e0832fbL, 0xa34f398L << 36),  //>exp(13/64)=1.22522561187730757944926592758
  1363:     new EFP (P,      0, 0x9f4c6f5508ee5d51L, 0xbbdee02L << 36),  //<exp(14/64)=1.24452010776609515494619895208
  1364:     new EFP (P,      0, 0xa1cea21faf8ac771L, 0xd268bc6L << 36),  //<exp(15/64)=1.26411844775346636339843460346
  1365:     new EFP (P,      0, 0xa45af1e1f40c333bL, 0x3de1db5L << 36),  //>exp(16/64)=1.28402541668774148407342056806
  1366:     new EFP (P,      0, 0xa6f1876108f3009dL, 0xa911f65L << 36),  //<exp(17/64)=1.30424587476763777548930001105
  1367:     new EFP (P,      0, 0xa9928c067d67bb65L, 0x16cc14dL << 36),  //>exp(18/64)=1.32478475872886556893523756069
  1368:     new EFP (P,      0, 0xac3e29e2d3d7813bL, 0x0e93c01L << 36),  //<exp(19/64)=1.34564708304941053148260309432
  1369:     new EFP (P,      0, 0xaef48bb022ffa9daL, 0x899232aL << 36),  //>exp(20/64)=1.36683794117379636283875677272
  1370:     new EFP (P,      0, 0xb1b5dcd4c192c269L, 0x39863eeL << 36),  //<exp(21/64)=1.38836250675662682438443747530
  1371:     new EFP (P,      0, 0xb4824965fca1967eL, 0xd7cc083L << 36),  //>exp(22/64)=1.41022603492571070569972793418
  1372:     new EFP (P,      0, 0xb759fe2ad8f3ada4L, 0xeb266efL << 36),  //>exp(23/64)=1.43243386356507811497143795682
  1373:     new EFP (P,      0, 0xba3d289edf7b5311L, 0xa3c5b2dL << 36),  //>exp(24/64)=1.45499141461820133605379369199
  1374:     new EFP (P,      0, 0xbd2bf6f4f511ef19L, 0xfdaedb7L << 36),  //<exp(25/64)=1.47790419541173842781020947116
  1375:     new EFP (P,      0, 0xc026981a3daa2e5dL, 0x65cddb9L << 36),  //>exp(26/64)=1.50117780000012275190098436819
  1376:     new EFP (P,      0, 0xc32d3bb90b262a0aL, 0xee10dd1L << 36),  //>exp(27/64)=1.52481791053132670462330880246
  1377:     new EFP (P,      0, 0xc640123bd8007ee1L, 0x26da077L << 36),  //>exp(28/64)=1.54883029863413309799855198460
  1378:     new EFP (P,      0, 0xc95f4cd04df7fdb9L, 0x9bfe7cfL << 36),  //>exp(29/64)=1.57322082682725288629956103460
  1379:     new EFP (P,      0, 0xcc8b1d6a58ee609bL, 0x8c7b82aL << 36),  //>exp(30/64)=1.59799544995063326789964514708
  1380:     new EFP (P,      0, 0xcfc3b6c7462b3282L, 0xc0bf5ecL << 36),  //>exp(31/64)=1.62316021661930561000723988290
  1381:     new EFP (P,      0, 0xd3094c70f034de4bL, 0x96ff7d6L << 36),  //>exp(32/64)=1.64872127070012814684865078781
  1382:     new EFP (P,      0, 0xd65c12c0f772a298L, 0xdbec9f1L << 36),  //>exp(33/64)=1.67468485281178399151929488215
  1383:     new EFP (P,      0, 0xd9bc3ee407caf517L, 0x6670eb8L << 36),  //<exp(34/64)=1.70105730184840067940618349548
  1384:     new EFP (P,      0, 0xdd2a06dd2b72af4bL, 0x7809cf2L << 36),  //>exp(35/64)=1.72784505652716322817720155244
  1385:     new EFP (P,      0, 0xe0a5a1892b223221L, 0x955289eL << 36),  //>exp(36/64)=1.75505465696029855724404703660
  1386:     new EFP (P,      0, 0xe42f46a1fbe683ddL, 0x1461033L << 36),  //<exp(37/64)=1.78269274625181505976568319611
  1387:     new EFP (P,      0, 0xe7c72ec23ac545bfL, 0x66c74a2L << 36),  //<exp(38/64)=1.81076607211938716412053043885
  1388:     new EFP (P,      0, 0xeb6d9368b66b3bf1L, 0xc77fd15L << 36),  //>exp(39/64)=1.83928148854178086081396691197
  1389:     new EFP (P,      0, 0xef22aefc071e02e5L, 0x44bd839L << 36),  //<exp(40/64)=1.86824595743222240650183562019
  1390:     new EFP (P,      0, 0xf2e6bcce352a7191L, 0x2542fa9L << 36),  //>exp(41/64)=1.89766655033811875072299372819
  1391:     new EFP (P,      0, 0xf6b9f9206e0a0fc3L, 0xabd8e27L << 36),  //>exp(42/64)=1.92755045016754466459088319259
  1392:     new EFP (P,      0, 0xfa9ca126c87af32bL, 0xb68e7a5L << 36),  //<exp(43/64)=1.95790495294291808566640006188
  1393:     new EFP (P,      0, 0xfe8ef30c17c644e9L, 0x61db684L << 36),  //<exp(44/64)=1.98873746958229183111747734965
  1394:     new EFP (P,      1, 0x814896fae739522fL, 0xd207331L << 36),  //>exp(45/64)=2.02005552770869657368538323652
  1395:     new EFP (P,      1, 0x8351c903f850495fL, 0xf940cd1L << 36),  //>exp(46/64)=2.05186677348797682356990329034
  1396:     new EFP (P,      1, 0x856330348b2806b5L, 0x6ded10fL << 36),  //<exp(47/64)=2.08417897349556861578737600208
  1397:     new EFP (P,      1, 0x877ceda33ee7bdeaL, 0x61ab772L << 36),  //>exp(48/64)=2.11700001661267466854536981984
  1398:     new EFP (P,      1, 0x899f22ec174a8c1aL, 0x3d1e65aL << 36),  //>exp(49/64)=2.15033791595229995544075729131
  1399:     new EFP (P,      1, 0x8bc9f23296628075L, 0x3fa07acL << 36),  //<exp(50/64)=2.18420081081561792457635501545
  1400:     new EFP (P,      1, 0x8dfd7e23ded395adL, 0xcd8bb99L << 36),  //<exp(51/64)=2.21859696867914500278504863552
  1401:     new EFP (P,      1, 0x9039e9f8dea8bffcL, 0x88e9e18L << 36),  //<exp(52/64)=2.25353478721320854485733107843
  1402:     new EFP (P,      1, 0x927f597882e5bd3aL, 0x5153fb8L << 36),  //<exp(53/64)=2.28902279633220102782484126941
  1403:     new EFP (P,      1, 0x94cdf0f9f3f8e05cL, 0x238b7d8L << 36),  //<exp(54/64)=2.32506966027712105082411019795
  1404:     new EFP (P,      1, 0x9725d566db309f9dL, 0x44caba1L << 36),  //<exp(55/64)=2.36168417973090958374598641969
  1405:     new EFP (P,      1, 0x99872c3db1593ce1L, 0x10ffabeL << 36),  //>exp(56/64)=2.39887529396709791469164573372
  1406:     new EFP (P,      1, 0x9bf21b9416a77258L, 0x29f648fL << 36),  //>exp(57/64)=2.43665208303229187916051857011
  1407:     new EFP (P,      1, 0x9e66ca193415a245L, 0xd019082L << 36),  //<exp(58/64)=2.47502376996302521487450632646
  1408:     new EFP (P,      1, 0xa0e55f1826599febL, 0x28fc34fL << 36),  //>exp(59/64)=2.51399972303752327721338612207
  1409:     new EFP (P,      1, 0xa36e027a7299c128L, 0x96ff655L << 36),  //>exp(60/64)=2.55358945806292687344696507755
  1410:     new EFP (P,      1, 0xa600dcca8508845aL, 0xa0a2a0dL << 36),  //<exp(61/64)=2.59380264069853463138124458905
  1411:     new EFP (P,      1, 0xa89e1736398eb461L, 0xfd1d370L << 36),  //>exp(62/64)=2.63464908881563111180226593835
  1412:     new EFP (P,      1, 0xab45db916eac95afL, 0x15018e6L << 36),  //>exp(63/64)=2.67613877489447680634939027005
  1413:   };  //EXP_P_T
  1414:   public final EFP[] EXP_M_T = {
  1415:     //  echo read("efp.gp");for(n=0,63,efpmem([Str("exp(-",n,"/64)")])) | gp -q
  1416:     new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36),  //=exp(-0/64)=1.00000000000000000000000000000
  1417:     new EFP (P,     -1, 0xfc07f55ff77d2493L, 0xe885eebL << 36),  //>exp(-1/64)=0.984496437005408405986988829697
  1418:     new EFP (P,     -1, 0xf81fab5445aebc8aL, 0x58055fdL << 36),  //>exp(-2/64)=0.969233234476344081848109193246
  1419:     new EFP (P,     -1, 0xf446e357f67dfd8eL, 0x33bd6c8L << 36),  //>exp(-3/64)=0.954206665969188316193630283451
  1420:     new EFP (P,     -1, 0xf07d5fde38151e72L, 0xf18ff03L << 36),  //<exp(-4/64)=0.939413062813475786119710824622
  1421:     new EFP (P,     -1, 0xecc2e44e820d18c3L, 0xcc6f18aL << 36),  //>exp(-5/64)=0.924848813216204834253805278288
  1422:     new EFP (P,     -1, 0xe9173500cbe0159aL, 0xa3084a2L << 36),  //>exp(-6/64)=0.910510361380034127843504886276
  1423:     new EFP (P,     -1, 0xe57a1739d263ec94L, 0x8222e86L << 36),  //<exp(-7/64)=0.896394206635150411490036193614
  1424:     new EFP (P,     -1, 0xe1eb51276c110c3cL, 0x3eb126aL << 36),  //>exp(-8/64)=0.882496902584595402864892143229
  1425:     new EFP (P,     -1, 0xde6aa9dcebdb100bL, 0x56a61aaL << 36),  //>exp(-9/64)=0.868815056262843166738503531191
  1426:     new EFP (P,     -1, 0xdaf7e94f9261313dL, 0x5fd7d71L << 36),  //>exp(-10/64)=0.855345327307422537695731635071
  1427:     new EFP (P,     -1, 0xd792d8530d3da531L, 0x2b5abcbL << 36),  //<exp(-11/64)=0.842084427143382346804098369012
  1428:     new EFP (P,     -1, 0xd43b4096043bde02L, 0xc9dd905L << 36),  //<exp(-12/64)=0.829029118180400343014645509343
  1429:     new EFP (P,     -1, 0xd0f0ec9eb43e8078L, 0xe9af6bbL << 36),  //<exp(-13/64)=0.816176213022339786977651290021
  1430:     new EFP (P,     -1, 0xcdb3a7c7979ebd5cL, 0x80489dbL << 36),  //>exp(-14/64)=0.803522573689060733999784586587
  1431:     new EFP (P,     -1, 0xca833e3c1bcf93e9L, 0x0747d1aL << 36),  //>exp(-15/64)=0.791065110850296014797613273422
  1432:     new EFP (P,     -1, 0xc75f7cf564105743L, 0x415cbcaL << 36),  //>exp(-16/64)=0.778800783071404868245170266978
  1433:     new EFP (P,     -1, 0xc44831b718faa1d9L, 0xc29d8daL << 36),  //>exp(-17/64)=0.766726596070820080189659545196
  1434:     new EFP (P,     -1, 0xc13d2b0c44b8af4aL, 0x68aa4e8L << 36),  //>exp(-18/64)=0.754839601989007337327347095918
  1435:     new EFP (P,     -1, 0xbe3e38443bb1dfefL, 0x65597dbL << 36),  //>exp(-19/64)=0.743136898668758315788243931197
  1436:     new EFP (P,     -1, 0xbb4b296f917bf09aL, 0x22fbaa2L << 36),  //<exp(-20/64)=0.731615628946641791159559420491
  1437:     new EFP (P,     -1, 0xb863cf5d19e0354eL, 0x91dbb17L << 36),  //<exp(-21/64)=0.720272979955439780859653963562
  1438:     new EFP (P,     -1, 0xb587fb96f5c4e712L, 0xa053452L << 36),  //>exp(-22/64)=0.709106182437398411721447410017
  1439:     new EFP (P,     -1, 0xb2b7805fabcb5327L, 0xcdbad0eL << 36),  //<exp(-23/64)=0.698112510068125846011729230536
  1440:     new EFP (P,     -1, 0xaff230af4c747553L, 0xd8db805L << 36),  //>exp(-24/64)=0.687289278790972198545202339147
  1441:     new EFP (P,     -1, 0xad37e030a19e3f45L, 0x315a9f6L << 36),  //<exp(-25/64)=0.676633846161728936684014615264
  1442:     new EFP (P,     -1, 0xaa88633e692c84abL, 0x9760affL << 36),  //<exp(-26/64)=0.666143610703487774469791357130
  1443:     new EFP (P,     -1, 0xa7e38ee09ab13658L, 0x8e4fa89L << 36),  //>exp(-27/64)=0.655816011271501552530892254763
  1444:     new EFP (P,     -1, 0xa54938c9b7e846b1L, 0x22756d1L << 36),  //<exp(-28/64)=0.645648526427892037348355680061
  1445:     new EFP (P,     -1, 0xa2b9375427dc3ef5L, 0xfdb6013L << 36),  //<exp(-29/64)=0.635638673826051977545950221758
  1446:     new EFP (P,     -1, 0xa033617f9c893772L, 0xb7f2709L << 36),  //>exp(-30/64)=0.625784009604591121679874456535
  1447:     new EFP (P,     -1, 0x9db78eee82d48c8cL, 0x5e432e4L << 36),  //>exp(-31/64)=0.616082127790678232119777202994
  1448:     new EFP (P,     -1, 0x9b4597e37cb04ff3L, 0xd675a35L << 36),  //<exp(-32/64)=0.606530659712633423603799534991
  1449:     new EFP (P,     -1, 0x98dd553ee54217fdL, 0x5f7533bL << 36),  //>exp(-33/64)=0.597127273421627413476334433038
  1450:     new EFP (P,     -1, 0x967ea07c5ee56f55L, 0x27376f0L << 36),  //>exp(-34/64)=0.587869673122346494029544878732
  1451:     new EFP (P,     -1, 0x942953b06ae2c503L, 0xc6e249aL << 36),  //<exp(-35/64)=0.578755598612484226311212770922
  1452:     new EFP (P,     -1, 0x91dd49860ab457feL, 0x49ecbc0L << 36),  //<exp(-36/64)=0.569782824730923009766629689829
  1453:     new EFP (P,     -1, 0x8f9a5d3c6ab3325dL, 0xe98839bL << 36),  //>exp(-37/64)=0.560949160814470803677121262158
  1454:     new EFP (P,     -1, 0x8d606aa49606deddL, 0x68c91a3L << 36),  //<exp(-38/64)=0.552252450163020365060397724731
  1455:     new EFP (P,     -1, 0x8b2f4e1f33b31766L, 0x67ee085L << 36),  //>exp(-39/64)=0.543690569513000424018191779441
  1456:     new EFP (P,     -1, 0x8906e49a4c9f3d59L, 0x58a5d18L << 36),  //>exp(-40/64)=0.535261428518990241956622508022
  1457:     new EFP (P,     -1, 0x86e70b8f1a73fbd8L, 0x1858e19L << 36),  //>exp(-41/64)=0.526962969243370991158669068037
  1458:     new EFP (P,     -1, 0x84cfa0ffdf2c01beL, 0x9229f8cL << 36),  //>exp(-42/64)=0.518793165653889356342645457337
  1459:     new EFP (P,     -1, 0x82c08375c5354c26L, 0xfed9d9bL << 36),  //>exp(-43/64)=0.510750023129010690574689186791
  1460:     new EFP (P,     -1, 0x80b991fec8010361L, 0x182aa18L << 36),  //<exp(-44/64)=0.502831577970940959688636611438
  1461:     new EFP (P,     -2, 0xfd75585749c0e65aL, 0xe0e13c7L << 36),  //<exp(-45/64)=0.495035896926198581667568450965
  1462:     new EFP (P,     -2, 0xf987641ba81c57c1L, 0x08b166eL << 36),  //>exp(-46/64)=0.487361076713619110714884696034
  1463:     new EFP (P,     -2, 0xf5a9086b1385b9a8L, 0xb38238dL << 36),  //>exp(-47/64)=0.479805243559677530439035766024
  1464:     new EFP (P,     -2, 0xf1da075f7e6bf297L, 0x7e1e9a0L << 36),  //>exp(-48/64)=0.472366552741014707138046550943
  1465:     new EFP (P,     -2, 0xee1a240886d56f4fL, 0x1d073e3L << 36),  //>exp(-49/64)=0.465043188134056313033903075269
  1466:     new EFP (P,     -2, 0xea692267a754ef29L, 0x4911dc3L << 36),  //<exp(-50/64)=0.457833361771614260902146840654
  1467:     new EFP (P,     -2, 0xe6c6c76c771c2d60L, 0x96a4be2L << 36),  //<exp(-51/64)=0.450735313406362396291400791633
  1468:     new EFP (P,     -2, 0xe332d8f0f8f06820L, 0xcd7f8e6L << 36),  //<exp(-52/64)=0.443747310081079871847240349999
  1469:     new EFP (P,     -2, 0xdfad1db5f8c5b458L, 0x70f8209L << 36),  //<exp(-53/64)=0.436867645705557280554577433900
  1470:     new EFP (P,     -2, 0xdc355d5f77c6f7b3L, 0x2d36b03L << 36),  //<exp(-54/64)=0.430094640640062251395946518606
  1471:     new EFP (P,     -2, 0xd8cb6071269148f0L, 0x7444892L << 36),  //<exp(-55/64)=0.423426641285262812386917145715
  1472:     new EFP (P,     -2, 0xd56ef04aed6a5a01L, 0x2a76dd4L << 36),  //<exp(-56/64)=0.416862019678508402585297182336
  1473:     new EFP (P,     -2, 0xd21fd725823a6f09L, 0x0871f0bL << 36),  //<exp(-57/64)=0.410399173096369966862764164781
  1474:     new EFP (P,     -2, 0xcedde00f0c13419aL, 0x4cddcf7L << 36),  //>exp(-58/64)=0.404036523663342095355029060572
  1475:     new EFP (P,     -2, 0xcba8d6e7d40e0852L, 0x3c9f035L << 36),  //>exp(-59/64)=0.397772517966611673942683333515
  1476:     new EFP (P,     -2, 0xc880885f034bb070L, 0x530b9f4L << 36),  //<exp(-60/64)=0.391605626676798993226807728469
  1477:     new EFP (P,     -2, 0xc564c1ef6de32926L, 0x3b6f5ecL << 36),  //<exp(-61/64)=0.385534344174578721612836653797
  1478:     new EFP (P,     -2, 0xc25551dc6a8a6f40L, 0xdc958f1L << 36),  //<exp(-62/64)=0.379557188183089583659076182722
  1479:     new EFP (P,     -2, 0xbf52072eb6c7d377L, 0xd431325L << 36),  //>exp(-63/64)=0.373672699406042998133147992189
  1480:   };  //EXP_M_T
  1481: 
  1482:   //------------------------------------------------------------------------
  1483:   //exp10
  1484:   public final EFP[] EXP10_P_I = {
  1485:     //  echo read("efp.gp");for(n=0,13,efpmem([Str("10^(2^",n,")")])) | gp -q
  1486:     new EFP (P,      3, 0xa000000000000000L, 0x0000000L << 36),  //=10^(2^0)=10.0000000000000000000000000000
  1487:     new EFP (P,      6, 0xc800000000000000L, 0x0000000L << 36),  //=10^(2^1)=100.000000000000000000000000000
  1488:     new EFP (P,     13, 0x9c40000000000000L, 0x0000000L << 36),  //=10^(2^2)=10000.0000000000000000000000000
  1489:     new EFP (P,     26, 0xbebc200000000000L, 0x0000000L << 36),  //=10^(2^3)=100000000.000000000000000000000
  1490:     new EFP (P,     53, 0x8e1bc9bf04000000L, 0x0000000L << 36),  //=10^(2^4)=10000000000000000.0000000000000
  1491:     new EFP (P,    106, 0x9dc5ada82b70b59dL, 0xf020000L << 36),  //=10^(2^5)=1.00000000000000000000000000000e+32
  1492:     new EFP (P,    212, 0xc2781f49ffcfa6d5L, 0x3cbf6b7L << 36),  //<10^(2^6)=1.00000000000000000000000000000e+64
  1493:     new EFP (P,    425, 0x93ba47c980e98cdfL, 0xc66f337L << 36),  //>10^(2^7)=1.00000000000000000000000000000e+128
  1494:     new EFP (P,    850, 0xaa7eebfb9df9de8dL, 0xddbb902L << 36),  //>10^(2^8)=1.00000000000000000000000000000e+256
  1495:     new EFP (P,   1700, 0xe319a0aea60e91c6L, 0xcc655c5L << 36),  //<10^(2^9)=1.00000000000000000000000000000e+512
  1496:     new EFP (P,   3401, 0xc976758681750c17L, 0x650d3d3L << 36),  //>10^(2^10)=1.00000000000000000000000000000e+1024
  1497:     new EFP (P,   6803, 0x9e8b3b5dc53d5de4L, 0xa74d28dL << 36),  //>10^(2^11)=1.00000000000000000000000000000e+2048
  1498:     new EFP (P,  13606, 0xc46052028a20979aL, 0xc94c154L << 36),  //>10^(2^12)=1.00000000000000000000000000000e+4096
  1499:     new EFP (P,  27213, 0x96a3a1d17faf211aL, 0x0c7c289L << 36),  //<10^(2^13)=1.00000000000000000000000000000e+8192
  1500:   };  //EXP10_P_I
  1501:   public final EFP[] EXP10_M_I = {
  1502:     //  echo read("efp.gp");for(n=0,13,efpmem([Str("10^(-2^",n,")")])) | gp -q
  1503:     new EFP (P,     -4, 0xccccccccccccccccL, 0xccccccdL << 36),  //>10^(-2^0)=0.100000000000000000000000000000
  1504:     new EFP (P,     -7, 0xa3d70a3d70a3d70aL, 0x3d70a3dL << 36),  //<10^(-2^1)=0.0100000000000000000000000000000
  1505:     new EFP (P,    -14, 0xd1b71758e219652bL, 0xd3c3611L << 36),  //<10^(-2^2)=1.00000000000000000000000000000e-4
  1506:     new EFP (P,    -27, 0xabcc77118461cefcL, 0xfdc20d3L << 36),  //>10^(-2^3)=1.00000000000000000000000000000e-8
  1507:     new EFP (P,    -54, 0xe69594bec44de15bL, 0x4c2ebe7L << 36),  //>10^(-2^4)=1.00000000000000000000000000000e-16
  1508:     new EFP (P,   -107, 0xcfb11ead453994baL, 0x67de18fL << 36),  //>10^(-2^5)=1.00000000000000000000000000000e-32
  1509:     new EFP (P,   -213, 0xa87fea27a539e9a5L, 0x3f2398dL << 36),  //<10^(-2^6)=1.00000000000000000000000000000e-64
  1510:     new EFP (P,   -426, 0xddd0467c64bce4a0L, 0xac7cb3fL << 36),  //<10^(-2^7)=1.00000000000000000000000000000e-128
  1511:     new EFP (P,   -851, 0xc0314325637a1939L, 0xfa91115L << 36),  //<10^(-2^8)=1.00000000000000000000000000000e-256
  1512:     new EFP (P,  -1701, 0x9049ee32db23d21cL, 0x7132d33L << 36),  //<10^(-2^9)=1.00000000000000000000000000000e-512
  1513:     new EFP (P,  -3402, 0xa2a682a5da57c0bdL, 0x87a6016L << 36),  //>10^(-2^10)=1.00000000000000000000000000000e-1024
  1514:     new EFP (P,  -6804, 0xceae534f34362de4L, 0x492512dL << 36),  //<10^(-2^11)=1.00000000000000000000000000000e-2048
  1515:     new EFP (P, -13607, 0xa6dd04c8d2ce9fdeL, 0x2de3812L << 36),  //<10^(-2^12)=1.00000000000000000000000000000e-4096
  1516:     new EFP (P, -27214, 0xd986c20b686da869L, 0x5d1d4feL << 36),  //>10^(-2^13)=1.00000000000000000000000000000e-8192
  1517:   };  //EXP10_M_I
  1518:   //  echo read("efp.gp");eval("exp10(x)=10^x");efpchebyshev("EXP10_C",exp10,-1/64,1/64,11) | gp -q
  1519:   public final EFP     EXP10_C0 = new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36);  //=1.00000000000000000000000000000
  1520:   public final EFP     EXP10_C1 = new EFP (P,      1, 0x935d8dddaaa8ac16L, 0xea56d63L << 36);  //=2.30258509299404568401799145491
  1521:   public final EFP     EXP10_C2 = new EFP (P,      1, 0xa9a92639e753443aL, 0x80aa0a5L << 36);  //=2.65094905523919900528083460848
  1522:   public final EFP     EXP10_C3 = new EFP (P,      1, 0x82382c8ef1652304L, 0x6a4fce8L << 36);  //=2.03467859229347619683099182492
  1523:   public final EFP     EXP10_C4 = new EFP (P,      0, 0x95ebb04fecc62263L, 0x3516d57L << 36);  //=1.17125514891226696311068508120
  1524:   public final EFP     EXP10_C5 = new EFP (P,     -1, 0x8a14ffe8ea6bb111L, 0x0f9d433L << 36);  //=0.539382929195581410178946055296
  1525:   public final EFP     EXP10_C6 = new EFP (P,     -3, 0xd3f6b8423e47031dL, 0xb2e8d4cL << 36);  //=0.206995848696869277613713506791
  1526:   public final EFP     EXP10_C7 = new EFP (P,     -4, 0x8b726fe199d4dd8aL, 0x0319896L << 36);  //=0.0680893650744373537029952682197
  1527:   public final EFP     EXP10_C8 = new EFP (P,     -6, 0xa08b582ea51b0457L, 0xa2bc993L << 36);  //=0.0195976946171499984930236007292
  1528:   public final EFP     EXP10_C9 = new EFP (P,     -8, 0xa44be22db201cf47L, 0x94dcaeaL << 36);  //=0.00501392883178657960091531266074
  1529:   public final EFP    EXP10_C10 = new EFP (P,    -10, 0x9753b9561c0a683fL, 0x0135acdL << 36);  //=0.00115453374296954907615286737273
  1530:   public final EFP    EXP10_C11 = new EFP (P,    -13, 0xfd69aac60b9f8924L, 0x6d6c8b2L << 36);  //=2.41673242615286373608040289945e-4
  1531:   //  95.99bit
  1532:   public final EFP[] EXP10_P_T = {
  1533:     //  echo read("efp.gp");for(n=0,63,efpmem([Str("10^(",n,"/64)")])) | gp -q
  1534:     new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36),  //=10^(0/64)=1.00000000000000000000000000000
  1535:     new EFP (P,      0, 0x84b06346cc5e15f9L, 0x701148dL << 36),  //>10^(1/64)=1.03663292843769799729165172493
  1536:     new EFP (P,      0, 0x898cbfd35533bb59L, 0x3c49e31L << 36),  //<10^(2/64)=1.07460782832131749721594153196
  1537:     new EFP (P,      0, 0x8e96b208a3664881L, 0x0ec125aL << 36),  //<10^(3/64)=1.11397385999480237628676508624
  1538:     new EFP (P,      0, 0x93cfe56520272d66L, 0x5aa4cf9L << 36),  //<10^(4/64)=1.15478198468945817966648288730
  1539:     new EFP (P,      0, 0x993a151041524281L, 0xa5bb585L << 36),  //>10^(5/64)=1.19708503049572996552827088892
  1540:     new EFP (P,      0, 0x9ed70c6d6669efa1L, 0xfe3df3cL << 36),  //<10^(6/64)=1.24093776075171956609870735535
  1541:     new EFP (P,      0, 0xa4a8a7b416dcf6d2L, 0xcb3598fL << 36),  //>10^(7/64)=1.28639694493697450748440704963
  1542:     new EFP (P,      0, 0xaab0d48dd40a21eeL, 0xe3993e6L << 36),  //<10^(8/64)=1.33352143216332402567593171530
  1543:     new EFP (P,      0, 0xb0f192b9b34f3a68L, 0x955eb28L << 36),  //>10^(9/64)=1.38237222735789961915257040197
  1544:     new EFP (P,      0, 0xb76cf4b5f65b3109L, 0xa96afc1L << 36),  //>10^(10/64)=1.43301257023696274155836644455
  1545:     new EFP (P,      0, 0xbe25206fd9f7d185L, 0xaebfd1dL << 36),  //>10^(11/64)=1.48550801717277507269503768560
  1546:     new EFP (P,      0, 0xc51c4ff9d58e742dL, 0x8b26b72L << 36),  //>10^(12/64)=1.53992652605949198957048599495
  1547:     new EFP (P,      0, 0xcc54d24887cd8593L, 0x587bd74L << 36),  //<10^(13/64)=1.59633854428794223977352853358
  1548:     new EFP (P,      0, 0xd3d10bf68f0b258cL, 0xf7a8720L << 36),  //>10^(14/64)=1.65481709994318142294561394026
  1549:     new EFP (P,      0, 0xdb93780f8e4c4878L, 0xa97bdbaL << 36),  //<10^(15/64)=1.71543789634287892263242774792
  1550:     new EFP (P,      0, 0xe39ea8e2a2387187L, 0xf37c989L << 36),  //>10^(16/64)=1.77827941003892280122542119519
  1551:     new EFP (P,      0, 0xebf548dc8bb914d9L, 0x7f50e38L << 36),  //<10^(17/64)=1.84342299240911047379928682108
  1552:     new EFP (P,      0, 0xf49a1b69d891c56dL, 0x960a16fL << 36),  //>10^(18/64)=1.91095297497044051626887333608
  1553:     new EFP (P,      0, 0xfd8ffde154e45e46L, 0x6d275e3L << 36),  //<10^(19/64)=1.98095677855033875589271948122
  1554:     new EFP (P,      1, 0x836cf43b89a99c01L, 0x4fdf0c0L << 36),  //>10^(20/64)=2.05352502645714607460575234830
  1555:     new EFP (P,      1, 0x883d779c2e260ef2L, 0x8fcb8a1L << 36),  //>10^(21/64)=2.12875166179637259331084646179
  1556:     new EFP (P,      1, 0x8d3b21886bfd0401L, 0xb2e86d9L << 36),  //<10^(22/64)=2.20673406908458980028232378190
  1557:     new EFP (P,      1, 0x9267996ca4b54f44L, 0xfac62acL << 36),  //>10^(23/64)=2.28757320031839568693918290553
  1558:     new EFP (P,      1, 0x97c496381a501b96L, 0x8f187f6L << 36),  //>10^(24/64)=2.37137370566165526165175275748
  1559:     new EFP (P,      1, 0x9d53deee66493377L, 0x48d07c3L << 36),  //>10^(25/64)=2.45824406892019739301085187675
  1560:     new EFP (P,      1, 0xa3174b3e44c3bf1cL, 0x5882b85L << 36),  //>10^(26/64)=2.54829674797934652767525759152
  1561:     new EFP (P,      1, 0xa910c41de5dcba7fL, 0x26e2683L << 36),  //<10^(27/64)=2.64164832038609245760602422495
  1562:     new EFP (P,      1, 0xaf42446cf8f10ddbL, 0xdeffc99L << 36),  //<10^(28/64)=2.73841963426436129418869698739
  1563:     new EFP (P,      1, 0xb5add99ca78b05aeL, 0xb531acaL << 36),  //>10^(29/64)=2.83873596475875476410634665940
  1564:     new EFP (P,      1, 0xbc55a45db7a285f3L, 0x2c86e23L << 36),  //<10^(30/64)=2.94272717620928181136420323011
  1565:     new EFP (P,      1, 0xc33bd9550ee56612L, 0x36b705cL << 36),  //<10^(31/64)=3.05052789026702553649413782738
  1566:     new EFP (P,      1, 0xca62c1d6d2da9490L, 0x2515e42L << 36),  //>10^(32/64)=3.16227766016837933199889354443
  1567:     new EFP (P,      1, 0xd1ccbca863e3a684L, 0x9dcd927L << 36),  //<10^(33/64)=3.27812115139345863868052715836
  1568:     new EFP (P,      1, 0xd97c3ec973660921L, 0xc624e27L << 36),  //>10^(34/64)=3.39820832894255937150660921812
  1569:     new EFP (P,      1, 0xe173d44477bfebc8L, 0xc9e83d6L << 36),  //<10^(35/64)=3.52269465147310144505670477089
  1570:     new EFP (P,      1, 0xe9b62106c31def2cL, 0x8c4b218L << 36),  //<10^(36/64)=3.65174127254837705824995256605
  1571:     new EFP (P,      1, 0xf245e1c084ce80edL, 0x038ee92L << 36),  //>10^(37/64)=3.78551524925862997316336724952
  1572:     new EFP (P,      1, 0xfb25ecccff4f619aL, 0x3e59575L << 36),  //<10^(38/64)=3.92418975848453586166641294060
  1573:     new EFP (P,      2, 0x822c9991a00501dfL, 0x459ef69L << 36),  //>10^(39/64)=4.06794432108304725128134842000
  1574:     new EFP (P,      2, 0x86f160a7d4429212L, 0x10e2195L << 36),  //>10^(40/64)=4.21696503428582248569013359509
  1575:     new EFP (P,      2, 0x8be2e03b4ddf0e98L, 0x12bb325L << 36),  //>10^(41/64)=4.37144481261108970238502724308
  1576:     new EFP (P,      2, 0x9102bbb052b20069L, 0x01f46c1L << 36),  //>10^(42/64)=4.53158363760081788320489309709
  1577:     new EFP (P,      2, 0x9652a5c839e93b97L, 0xa26a9f7L << 36),  //<10^(43/64)=4.69758881670649182019894641275
  1578:     new EFP (P,      2, 0x9bd461318075e327L, 0xba8d5a6L << 36),  //<10^(44/64)=4.86967525165863114935297485034
  1579:     new EFP (P,      2, 0xa189c11d24a8aa65L, 0x85c7857L << 36),  //<10^(45/64)=5.04806571666747076993748259343
  1580:     new EFP (P,      2, 0xa774a9d97a7cc699L, 0x267ff04L << 36),  //<10^(46/64)=5.23299114681494688097670550264
  1581:     new EFP (P,      2, 0xad971172abe13529L, 0x4e7987eL << 36),  //<10^(47/64)=5.42469093701132600419719579894
  1582:     new EFP (P,      2, 0xb3f300591a312caeL, 0x82ddc80L << 36),  //>10^(48/64)=5.62341325190349080394951039776
  1583:     new EFP (P,      2, 0xba8a920dd7ff6294L, 0x8fdbe3cL << 36),  //>10^(49/64)=5.82941534713607396382074746488
  1584:     new EFP (P,      2, 0xc15ff5d5745ce801L, 0xf9cbdb1L << 36),  //>10^(50/64)=6.04296390238132819036274581338
  1585:     new EFP (P,      2, 0xc8756f7152dc6b33L, 0xd916f2aL << 36),  //<10^(51/64)=6.26433536656885561228272629955
  1586:     new EFP (P,      2, 0xcfcd57dfcdbe57f5L, 0x06243dfL << 36),  //>10^(52/64)=6.49381631576211315128032840698
  1587:     new EFP (P,      2, 0xd76a1e2361f25a79L, 0x376f47eL << 36),  //<10^(53/64)=6.73170382414498230366796296997
  1588:     new EFP (P,      2, 0xdf4e481126efea96L, 0x226ac46L << 36),  //<10^(54/64)=6.97830584859866338414831761727
  1589:     new EFP (P,      2, 0xe77c7326d6d287faL, 0x80d6746L << 36),  //>10^(55/64)=7.23394162736674761521631443578
  1590:     new EFP (P,      2, 0xeff75568ada7ffc1L, 0x9a2a3e9L << 36),  //<10^(56/64)=7.49894209332455827302184275615
  1591:     new EFP (P,      2, 0xf8c1be4769784541L, 0xfbc290fL << 36),  //>10^(57/64)=7.77365030238775803292348188791
  1592:     new EFP (P,      3, 0x80ef4bc75b9ffbd5L, 0x0910ec4L << 36),  //>10^(58/64)=8.05842187761481817002575395741
  1593:     new EFP (P,      3, 0x85a8732e2df0c035L, 0xb3cb958L << 36),  //<10^(59/64)=8.35362546957826173294463685160
  1594:     new EFP (P,      3, 0x8a8de610357adc41L, 0x4850544L << 36),  //>10^(60/64)=8.65964323360065352353169183420
  1595:     new EFP (P,      3, 0x8fa143d3703294f4L, 0x841b5f8L << 36),  //>10^(61/64)=8.97687132447314194541938363834
  1596:     new EFP (P,      3, 0x94e43b157a67a6c0L, 0x97fe98cL << 36),  //>10^(62/64)=9.30572040929698979290646316499
  1597:     new EFP (P,      3, 0x9a588a3a43ff4e3cL, 0x381b0ceL << 36),  //<10^(63/64)=9.64661619911199213711208256038
  1598:   };  //EXP10_P_T
  1599:   public final EFP[] EXP10_M_T = {
  1600:     //  echo read("efp.gp");for(n=0,63,efpmem([Str("10^(-",n,"/64)")])) | gp -q
  1601:     new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36),  //=10^(-0/64)=1.00000000000000000000000000000
  1602:     new EFP (P,     -1, 0xf6f4105d39987d2dL, 0x2691ae4L << 36),  //>10^(-1/64)=0.964661619911199213711208256038
  1603:     new EFP (P,     -1, 0xee39f8225d72a467L, 0x59975acL << 36),  //<10^(-2/64)=0.930572040929698979290646316499
  1604:     new EFP (P,     -1, 0xe5ced2ebe6b754baL, 0x6cf898cL << 36),  //<10^(-3/64)=0.897687132447314194541938363834
  1605:     new EFP (P,     -1, 0xddafd68055916068L, 0x73b3b9fL << 36),  //<10^(-4/64)=0.865964323360065352353169183420
  1606:     new EFP (P,     -1, 0xd5da51e37cb466bcL, 0x52df55aL << 36),  //>10^(-5/64)=0.835362546957826173294463685160
  1607:     new EFP (P,     -1, 0xce4bac722c332c88L, 0x0e8179fL << 36),  //<10^(-6/64)=0.805842187761481817002575395741
  1608:     new EFP (P,     -1, 0xc7016505edf9d101L, 0x963540cL << 36),  //>10^(-7/64)=0.777365030238775803292348188791
  1609:     new EFP (P,     -1, 0xbff911208aeccc9aL, 0xe1bb654L << 36),  //<10^(-8/64)=0.749894209332455827302184275615
  1610:     new EFP (P,     -1, 0xb9305c1f12420662L, 0x00ab904L << 36),  //<10^(-9/64)=0.723394162736674761521631443578
  1611:     new EFP (P,     -1, 0xb2a506741f265544L, 0xe85569fL << 36),  //>10^(-10/64)=0.697830584859866338414831761727
  1612:     new EFP (P,     -1, 0xac54e4e91b284860L, 0xf925d32L << 36),  //>10^(-11/64)=0.673170382414498230366796296997
  1613:     new EFP (P,     -1, 0xa63ddfe63e31dff7L, 0x381cfe5L << 36),  //<10^(-12/64)=0.649381631576211315128032840698
  1614:     new EFP (P,     -1, 0xa05df2c10f16bc29L, 0x7a78c22L << 36),  //>10^(-13/64)=0.626433536656885561228272629955
  1615:     new EFP (P,     -1, 0x9ab32b1129e3ecceL, 0x616fe27L << 36),  //>10^(-14/64)=0.604296390238132819036274581338
  1616:     new EFP (P,     -1, 0x953ba80b1332b543L, 0xa649830L << 36),  //>10^(-15/64)=0.582941534713607396382074746488
  1617:     new EFP (P,     -1, 0x8ff599e0e1c0f08bL, 0x9be4a00L << 36),  //>10^(-16/64)=0.562341325190349080394951039776
  1618:     new EFP (P,     -1, 0x8adf41288980f754L, 0x3ec79ffL << 36),  //>10^(-17/64)=0.542469093701132600419719579894
  1619:     new EFP (P,     -1, 0x85f6ee4795309ee0L, 0xeb998d0L << 36),  //<10^(-18/64)=0.523299114681494688097670550264
  1620:     new EFP (P,     -1, 0x813b00e41d53bb84L, 0x6b06046L << 36),  //>10^(-19/64)=0.504806571666747076993748259343
  1621:     new EFP (P,     -2, 0xf953ceb59a56383fL, 0x90e22a4L << 36),  //>10^(-20/64)=0.486967525165863114935297485034
  1622:     new EFP (P,     -2, 0xf0843c738fdb928cL, 0x3710ff2L << 36),  //<10^(-21/64)=0.469758881670649182019894641275
  1623:     new EFP (P,     -2, 0xe8045f80845000a8L, 0x0320aceL << 36),  //>10^(-22/64)=0.453158363760081788320489309709
  1624:     new EFP (P,     -2, 0xdfd166c54964e426L, 0x845eb6eL << 36),  //<10^(-23/64)=0.437144481261108970238502724308
  1625:     new EFP (P,     -2, 0xd7e89aa6206a8350L, 0x1b035bbL << 36),  //<10^(-24/64)=0.421696503428582248569013359509
  1626:     new EFP (P,     -2, 0xd0475c1c333b3632L, 0x08fe574L << 36),  //<10^(-25/64)=0.406794432108304725128134842000
  1627:     new EFP (P,     -2, 0xc8eb23d732a5e7aeL, 0x9847791L << 36),  //>10^(-26/64)=0.392418975848453586166641294060
  1628:     new EFP (P,     -2, 0xc1d18166d0a533f0L, 0xcfa5875L << 36),  //>10^(-27/64)=0.378551524925862997316336724952
  1629:     new EFP (P,     -2, 0xbaf81a6bcf4b25bdL, 0x3d08e7aL << 36),  //>10^(-28/64)=0.365174127254837705824995256605
  1630:     new EFP (P,     -2, 0xb45ca9d05fccbca0L, 0xa186978L << 36),  //<10^(-29/64)=0.352269465147310144505670477089
  1631:     new EFP (P,     -2, 0xadfcff078f84d41bL, 0x04ea4ecL << 36),  //>10^(-30/64)=0.339820832894255937150660921812
  1632:     new EFP (P,     -2, 0xa7d6fd53831c8536L, 0xe4a4753L << 36),  //>10^(-31/64)=0.327812115139345863868052715836
  1633:     new EFP (P,     -2, 0xa1e89b12424876d9L, 0xb744b68L << 36),  //>10^(-32/64)=0.316227766016837933199889354443
  1634:     new EFP (P,     -2, 0x9c2fe110d8b784dbL, 0x5ef8d17L << 36),  //>10^(-33/64)=0.305052789026702553649413782738
  1635:     new EFP (P,     -2, 0x96aae9e492e86b28L, 0xf06be83L << 36),  //>10^(-34/64)=0.294272717620928181136420323011
  1636:     new EFP (P,     -2, 0x9157e14a1fa26af2L, 0x2a8e23bL << 36),  //>10^(-35/64)=0.283873596475875476410634665940
  1637:     new EFP (P,     -2, 0x8c35038a60c0d7e3L, 0x18cca14L << 36),  //<10^(-36/64)=0.273841963426436129418869698739
  1638:     new EFP (P,     -2, 0x87409ce4b7e3c865L, 0xb8b5203L << 36),  //>10^(-37/64)=0.264164832038609245760602422495
  1639:     new EFP (P,     -2, 0x827908fe9d6965b0L, 0x46cef9dL << 36),  //<10^(-38/64)=0.254829674797934652767525759152
  1640:     new EFP (P,     -3, 0xfbb964b0a3a85258L, 0x7480c6bL << 36),  //>10^(-39/64)=0.245824406892019739301085187675
  1641:     new EFP (P,     -3, 0xf2d4238cf6e6928aL, 0x7e8d989L << 36),  //<10^(-40/64)=0.237137370566165526165175275748
  1642:     new EFP (P,     -3, 0xea3f5be107887ed4L, 0xc470446L << 36),  //>10^(-41/64)=0.228757320031839568693918290553
  1643:     new EFP (P,     -3, 0xe1f835a7132e6ccfL, 0x84a715cL << 36),  //>10^(-42/64)=0.220673406908458980028232378190
  1644:     new EFP (P,     -3, 0xd9fbf2937d09b184L, 0x1945a9bL << 36),  //<10^(-43/64)=0.212875166179637259331084646179
  1645:     new EFP (P,     -3, 0xd247ed2c0f75c668L, 0x7fcb466L << 36),  //>10^(-44/64)=0.205352502645714607460575234830
  1646:     new EFP (P,     -3, 0xcad997e7771d1838L, 0x5752b1cL << 36),  //<10^(-45/64)=0.198095677855033875589271948122
  1647:     new EFP (P,     -3, 0xc3ae7c54ad416abeL, 0x11a1abfL << 36),  //>10^(-46/64)=0.191095297497044051626887333608
  1648:     new EFP (P,     -3, 0xbcc43a4a0960dd7aL, 0xcc40b60L << 36),  //<10^(-47/64)=0.184342299240911047379928682108
  1649:     new EFP (P,     -3, 0xb618871bb4f9f46cL, 0xc2ca13aL << 36),  //<10^(-48/64)=0.177827941003892280122542119519
  1650:     new EFP (P,     -3, 0xafa92cd93ea36d2dL, 0x5463162L << 36),  //>10^(-49/64)=0.171543789634287892263242774792
  1651:     new EFP (P,     -3, 0xa97409920c08ead7L, 0x2c86c19L << 36),  //<10^(-50/64)=0.165481709994318142294561394026
  1652:     new EFP (P,     -3, 0xa3770ea06ca46adcL, 0x46c9790L << 36),  //<10^(-51/64)=0.159633854428794223977352853358
  1653:     new EFP (P,     -3, 0x9db03ffb113ec357L, 0xa2855f5L << 36),  //>10^(-52/64)=0.153992652605949198957048599495
  1654:     new EFP (P,     -3, 0x981db38cae5fdad1L, 0x589974aL << 36),  //<10^(-53/64)=0.148550801717277507269503768560
  1655:     new EFP (P,     -3, 0x92bd909191e28da1L, 0x5455967L << 36),  //<10^(-54/64)=0.143301257023696274155836644455
  1656:     new EFP (P,     -3, 0x8d8e0efaf5d8fb86L, 0xdde55baL << 36),  //>10^(-55/64)=0.138237222735789961915257040197
  1657:     new EFP (P,     -3, 0x888d76d7dcd4e7f2L, 0x4fadcb8L << 36),  //<10^(-56/64)=0.133352143216332402567593171530
  1658:     new EFP (P,     -3, 0x83ba1fc3457d9242L, 0x3c2ae0cL << 36),  //>10^(-57/64)=0.128639694493697450748440704963
  1659:     new EFP (P,     -4, 0xfe24e0af0a431903L, 0x30631faL << 36),  //<10^(-58/64)=0.124093776075171956609870735535
  1660:     new EFP (P,     -4, 0xf529bb4d35506a69L, 0x092bc07L << 36),  //<10^(-59/64)=0.119708503049572996552827088892
  1661:     new EFP (P,     -4, 0xec7fd56e99d848a3L, 0xc43ae5bL << 36),  //<10^(-60/64)=0.115478198468945817966648288730
  1662:     new EFP (P,     -4, 0xe424500dd23d40ceL, 0x7e01d5dL << 36),  //<10^(-61/64)=0.111397385999480237628676508624
  1663:     new EFP (P,     -4, 0xdc14661eeeb92bc1L, 0xfa0fd1cL << 36),  //>10^(-62/64)=0.107460782832131749721594153196
  1664:     new EFP (P,     -4, 0xd44d6ba47a302328L, 0xb34edaeL << 36),  //<10^(-63/64)=0.103663292843769799729165172493
  1665:   };  //EXP10_M_T
  1666: 
  1667:   //------------------------------------------------------------------------
  1668:   //exp2
  1669:   //  echo read("efp.gp");eval("exp2(x)=2^x");efpchebyshev("EXP2P_C",exp2,0,1/64,8) | gp -q
  1670:   public final EFP     EXP2P_C0 = new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36);  //=1.00000000000000000000000000000
  1671:   public final EFP     EXP2P_C1 = new EFP (P,     -1, 0xb17217f7d1cf79abL, 0xc9e3289L << 36);  //=0.693147180559945309417231672224
  1672:   public final EFP     EXP2P_C2 = new EFP (P,     -3, 0xf5fdeffc162c7543L, 0x87306ceL << 36);  //=0.240226506959100712334317834550
  1673:   public final EFP     EXP2P_C3 = new EFP (P,     -5, 0xe35846b82505fbc4L, 0xf77c6dfL << 36);  //=0.0555041086648215794495051454975
  1674:   public final EFP     EXP2P_C4 = new EFP (P,     -7, 0x9d955b7dd276b5acL, 0xbf41024L << 36);  //=0.00961812910762864290798786714666
  1675:   public final EFP     EXP2P_C5 = new EFP (P,    -10, 0xaec3ff3c41fa05ceL, 0xd0dbae7L << 36);  //=0.00133335581461220558296277742225
  1676:   public final EFP     EXP2P_C6 = new EFP (P,    -13, 0xa18489b6bbee153cL, 0x79516f1L << 36);  //=1.54035307260420586747761266932e-4
  1677:   public final EFP     EXP2P_C7 = new EFP (P,    -17, 0xffe516c43da39259L, 0x7cbaceaL << 36);  //=1.52525233411920778640460590036e-5
  1678:   public final EFP     EXP2P_C8 = new EFP (P,    -20, 0xb256aa5495805ceeL, 0xb4df34eL << 36);  //=1.32872563999697042645099045935e-6
  1679:   //  93.22bit
  1680:   //  echo read("efp.gp");eval("exp2(x)=2^x");efpchebyshev("EXP2M_C",exp2,-1/64,0,8) | gp -q
  1681:   public final EFP     EXP2M_C0 = new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36);  //=1.00000000000000000000000000000
  1682:   public final EFP     EXP2M_C1 = new EFP (P,     -1, 0xb17217f7d1cf79abL, 0xc9e32a0L << 36);  //=0.693147180559945309417231676869
  1683:   public final EFP     EXP2M_C2 = new EFP (P,     -3, 0xf5fdeffc162c7543L, 0x6a5f7f6L << 36);  //=0.240226506959100712332792321650
  1684:   public final EFP     EXP2M_C3 = new EFP (P,     -5, 0xe35846b82505fbc6L, 0x6a8d50cL << 36);  //=0.0555041086648215794544161625987
  1685:   public final EFP     EXP2M_C4 = new EFP (P,     -7, 0x9d955b7dd270c42fL, 0x60d628cL << 36);  //=0.00961812910762831298749547774027
  1686:   public final EFP     EXP2M_C5 = new EFP (P,    -10, 0xaec3ff3c422238b3L, 0x26278f5L << 36);  //=0.00133335581461248451814736607925
  1687:   public final EFP     EXP2M_C6 = new EFP (P,    -13, 0xa184894230721e7bL, 0x5e05decL << 36);  //=1.54035300635612277279514659537e-4
  1688:   public final EFP     EXP2M_C7 = new EFP (P,    -17, 0xffe518860467684dL, 0x1c0262cL << 36);  //=1.52525249391189379086239626896e-5
  1689:   public final EFP     EXP2M_C8 = new EFP (P,    -20, 0xb06adfb7eea07e61L, 0xba36904L << 36);  //=1.31441262493409658027106967485e-6
  1690:   //  93.24bit
  1691:   public final EFP[] EXP2P_T = {
  1692:     //  echo read("efp.gp");for(n=0,63,efpmem([Str("2^(",n,"/64)")])) | gp -q
  1693:     new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36),  //=2^(0/64)=1.00000000000000000000000000000
  1694:     new EFP (P,      0, 0x8164d1f3bc030773L, 0x7be5652L << 36),  //<2^(1/64)=1.01088928605170046002040979056
  1695:     new EFP (P,      0, 0x82cd8698ac2ba1d7L, 0x3e2a476L << 36),  //>2^(2/64)=1.02189714865411667823448013478
  1696:     new EFP (P,      0, 0x843a28c3acde4046L, 0x1af92edL << 36),  //>2^(3/64)=1.03302487902122842250010828397
  1697:     new EFP (P,      0, 0x85aac367cc487b14L, 0xc5c95b9L << 36),  //>2^(4/64)=1.04427378242741384032196647874
  1698:     new EFP (P,      0, 0x871f61969e8d1010L, 0x3a1727cL << 36),  //<2^(5/64)=1.05564517836055715880834132515
  1699:     new EFP (P,      0, 0x88980e8092da8527L, 0x5df8d77L << 36),  //>2^(6/64)=1.06714040067682361816952112099
  1700:     new EFP (P,      0, 0x8a14d575496efd9aL, 0x080ca1eL << 36),  //>2^(7/64)=1.07876079775711979374068003744
  1701:     new EFP (P,      0, 0x8b95c1e3ea8bd6e6L, 0xfbe4628L << 36),  //<2^(8/64)=1.09050773266525765920701065576
  1702:     new EFP (P,      0, 0x8d1adf5b7e5ba9e5L, 0xb4c7b49L << 36),  //<2^(9/64)=1.10238258330784094355641420943
  1703:     new EFP (P,      0, 0x8ea4398b45cd53c0L, 0x2dc0145L << 36),  //>2^(10/64)=1.11438674259589253630881295692
  1704:     new EFP (P,      0, 0x9031dc431466b1dcL, 0x775814bL << 36),  //>2^(11/64)=1.12652161860824189979479864379
  1705:     new EFP (P,      0, 0x91c3d373ab11c336L, 0x0fd6d8eL << 36),  //<2^(12/64)=1.13878863475669165370383028384
  1706:     new EFP (P,      0, 0x935a2b2f13e6e92bL, 0xd339941L << 36),  //>2^(13/64)=1.15118922995298270581775963520
  1707:     new EFP (P,      0, 0x94f4efa8fef70961L, 0x2e8afadL << 36),  //<2^(14/64)=1.16372485877757751381357359909
  1708:     new EFP (P,      0, 0x96942d3720185a00L, 0x48ea9b7L << 36),  //>2^(15/64)=1.17639699165028127628464572848
  1709:     new EFP (P,      0, 0x9837f0518db8a96fL, 0x46ad232L << 36),  //>2^(16/64)=1.18920711500272106671749997056
  1710:     new EFP (P,      0, 0x99e0459320b7fa64L, 0xe43086dL << 36),  //>2^(17/64)=1.20215673145270314209639695750
  1711:     new EFP (P,      0, 0x9b8d39b9d54e5538L, 0xa2a817aL << 36),  //<2^(18/64)=1.21524735998046887811652025134
  1712:     new EFP (P,      0, 0x9d3ed9a72cffb750L, 0xde494cfL << 36),  //<2^(19/64)=1.22848053610687000569400895779
  1713:     new EFP (P,      0, 0x9ef5326091a111adL, 0xa0911f1L << 36),  //>2^(20/64)=1.24185781207348404859367746873
  1714:     new EFP (P,      0, 0xa0b0510fb9714fc2L, 0x192dc7aL << 36),  //>2^(21/64)=1.25538075702469108957939065744
  1715:     new EFP (P,      0, 0xa27043030c496818L, 0x9b7a04fL << 36),  //>2^(22/64)=1.26905095719173322255441908103
  1716:     new EFP (P,      0, 0xa43515ae09e6809eL, 0x0d1db48L << 36),  //<2^(23/64)=1.28287001607877828072666978102
  1717:     new EFP (P,      0, 0xa5fed6a9b15138eaL, 0x1cbd7f6L << 36),  //<2^(24/64)=1.29683955465100966593375411779
  1718:     new EFP (P,      0, 0xa7cd93b4e9653569L, 0x9ec5b4dL << 36),  //<2^(25/64)=1.31096121152476434192299178633
  1719:     new EFP (P,      0, 0xa9a15ab4ea7c0ef8L, 0x541e24fL << 36),  //>2^(26/64)=1.32523664315974129462953709550
  1720:     new EFP (P,      0, 0xab7a39b5a93ed337L, 0x658023bL << 36),  //<2^(27/64)=1.33966752405330300536003066972
  1721:     new EFP (P,      0, 0xad583eea42a14ac6L, 0x4980a8dL << 36),  //>2^(28/64)=1.35425554693689272829801474014
  1722:     new EFP (P,      0, 0xaf3b78ad690a4374L, 0xdf26102L << 36),  //>2^(29/64)=1.36900242297459061192960113298
  1723:     new EFP (P,      0, 0xb123f581d2ac258fL, 0x87d037fL << 36),  //>2^(30/64)=1.38390988196383195487265952727
  1724:     new EFP (P,      0, 0xb311c412a9112489L, 0x3ecf14eL << 36),  //>2^(31/64)=1.39897967253831114020952813672
  1725:     new EFP (P,      0, 0xb504f333f9de6484L, 0x597d89bL << 36),  //<2^(32/64)=1.41421356237309504880168872421
  1726:     new EFP (P,      0, 0xb6fd91e328d17791L, 0x07165f1L << 36),  //>2^(33/64)=1.42961333839197001123506577828
  1727:     new EFP (P,      0, 0xb8fbaf4762fb9ee9L, 0x1b87978L << 36),  //>2^(34/64)=1.44518080697704662003700624147
  1728:     new EFP (P,      0, 0xbaff5ab2133e45fbL, 0x74d519dL << 36),  //<2^(35/64)=1.46091779418064698865130289031
  1729:     new EFP (P,      0, 0xbd08a39f580c36beL, 0xa8811fbL << 36),  //<2^(36/64)=1.47682614593949931138690748037
  1730:     new EFP (P,      0, 0xbf1799b67a731082L, 0xe815d0bL << 36),  //>2^(37/64)=1.49290772829126484920064353149
  1731:     new EFP (P,      0, 0xc12c4cca66709456L, 0x7c457d6L << 36),  //>2^(38/64)=1.50916442759342273976601955103
  1732:     new EFP (P,      0, 0xc346ccda24976407L, 0x20ec856L << 36),  //<2^(39/64)=1.52559815074453830685125368952
  1733:     new EFP (P,      0, 0xc5672a115506daddL, 0x3e2ad0dL << 36),  //>2^(40/64)=1.54221082540794082361229186209
  1734:     new EFP (P,      0, 0xc78d74c8abb9b15cL, 0xc13a2e4L << 36),  //>2^(41/64)=1.55900440023783696703372808947
  1735:     new EFP (P,      0, 0xc9b9bd866e2f27a2L, 0x80e1f93L << 36),  //>2^(42/64)=1.57598084510788648645527016018
  1736:     new EFP (P,      0, 0xcbec14fef2727c5cL, 0xf4907c9L << 36),  //>2^(43/64)=1.59314215134226689793724864312
  1737:     new EFP (P,      0, 0xce248c151f8480e3L, 0xe235839L << 36),  //>2^(44/64)=1.61049033194925430817952066736
  1738:     new EFP (P,      0, 0xd06333daef2b2594L, 0xd6d45c6L << 36),  //<2^(45/64)=1.62802742185734776684821852201
  1739:     new EFP (P,      0, 0xd2a81d91f12ae45aL, 0x12248e5L << 36),  //<2^(46/64)=1.64575547815396484451875672473
  1740:     new EFP (P,      0, 0xd4f35aabcfedfa1fL, 0x5921df0L << 36),  //>2^(47/64)=1.66367658032673643504633645698
  1741:     new EFP (P,      0, 0xd744fccad69d6af4L, 0x39a68bcL << 36),  //>2^(48/64)=1.68179283050742908606225095247
  1742:     new EFP (P,      0, 0xd99d15c278afd7b5L, 0xfe873dfL << 36),  //>2^(49/64)=1.70010635371852346950136257350
  1743:     new EFP (P,      0, 0xdbfbb797daf23755L, 0x3d840d6L << 36),  //>2^(50/64)=1.71861929812247791562934437646
  1744:     new EFP (P,      0, 0xde60f4825e0e9123L, 0xdd07a2eL << 36),  //>2^(51/64)=1.73733383527370624899420208187
  1745:     new EFP (P,      0, 0xe0ccdeec2a94e111L, 0x0658950L << 36),  //<2^(52/64)=1.75625216037329948311216061938
  1746:     new EFP (P,      0, 0xe33f8972be8a5a51L, 0x09bfe90L << 36),  //<2^(53/64)=1.77537649252652125255055920020
  1747:     new EFP (P,      0, 0xe5b906e77c8348a8L, 0x1e5e8f5L << 36),  //>2^(54/64)=1.79470907500310718642770324213
  1748:     new EFP (P,      0, 0xe8396a503c4bdc68L, 0x791790dL << 36),  //<2^(55/64)=1.81425217550039875624983460036
  1749:     new EFP (P,      0, 0xeac0c6e7dd24392eL, 0xd02d75bL << 36),  //<2^(56/64)=1.83400808640934246348708318959
  1750:     new EFP (P,      0, 0xed4f301ed9942b84L, 0x600d2dbL << 36),  //<2^(57/64)=1.85397912508338556839245307034
  1751:     new EFP (P,      0, 0xefe4b99bdcdaf5cbL, 0x46561cfL << 36),  //<2^(58/64)=1.87416763411029990132999894995
  1752:     new EFP (P,      0, 0xf281773c59ffb139L, 0xe8980aaL << 36),  //>2^(59/64)=1.89457598158696564134021865343
  1753:     new EFP (P,      0, 0xf5257d152486cc2cL, 0x7b9d0c8L << 36),  //>2^(60/64)=1.91520656139714729387261127030
  1754:     new EFP (P,      0, 0xf7d0df730ad13bb8L, 0xfe90d49L << 36),  //<2^(61/64)=1.93606179349229445059805590457
  1755:     new EFP (P,      0, 0xfa83b2db722a033aL, 0x7c25bb1L << 36),  //<2^(62/64)=1.95714412417540026901832225163
  1756:     new EFP (P,      0, 0xfd3e0c0cf486c174L, 0x853f3a6L << 36),  //>2^(63/64)=1.97845602638795096825824991813
  1757:   };  //EXP2P_T
  1758:   public final EFP[] EXP2M_T = {
  1759:     //  echo read("efp.gp");for(n=0,63,efpmem([Str("2^(-",n,"/64)")])) | gp -q
  1760:     new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36),  //=2^(-0/64)=1.00000000000000000000000000000
  1761:     new EFP (P,     -1, 0xfd3e0c0cf486c174L, 0x853f3a6L << 36),  //>2^(-1/64)=0.989228013193975484129124959066
  1762:     new EFP (P,     -1, 0xfa83b2db722a033aL, 0x7c25bb1L << 36),  //<2^(-2/64)=0.978572062087700134509161125813
  1763:     new EFP (P,     -1, 0xf7d0df730ad13bb8L, 0xfe90d49L << 36),  //<2^(-3/64)=0.968030896746147225299027952283
  1764:     new EFP (P,     -1, 0xf5257d152486cc2cL, 0x7b9d0c8L << 36),  //>2^(-4/64)=0.957603280698573646936305635148
  1765:     new EFP (P,     -1, 0xf281773c59ffb139L, 0xe8980aaL << 36),  //>2^(-5/64)=0.947287990793482820670109326713
  1766:     new EFP (P,     -1, 0xefe4b99bdcdaf5cbL, 0x46561cfL << 36),  //<2^(-6/64)=0.937083817055149950664999474977
  1767:     new EFP (P,     -1, 0xed4f301ed9942b84L, 0x600d2dbL << 36),  //<2^(-7/64)=0.926989562541692784196226535169
  1768:     new EFP (P,     -1, 0xeac0c6e7dd24392eL, 0xd02d75bL << 36),  //<2^(-8/64)=0.917004043204671231743541594794
  1769:     new EFP (P,     -1, 0xe8396a503c4bdc68L, 0x791790dL << 36),  //<2^(-9/64)=0.907126087750199378124917300181
  1770:     new EFP (P,     -1, 0xe5b906e77c8348a8L, 0x1e5e8f5L << 36),  //>2^(-10/64)=0.897354537501553593213851621064
  1771:     new EFP (P,     -1, 0xe33f8972be8a5a51L, 0x09bfe90L << 36),  //<2^(-11/64)=0.887688246263260626275279600100
  1772:     new EFP (P,     -1, 0xe0ccdeec2a94e111L, 0x0658950L << 36),  //<2^(-12/64)=0.878126080186649741556080309688
  1773:     new EFP (P,     -1, 0xde60f4825e0e9123L, 0xdd07a2eL << 36),  //>2^(-13/64)=0.868666917636853124497101040936
  1774:     new EFP (P,     -1, 0xdbfbb797daf23755L, 0x3d840d6L << 36),  //>2^(-14/64)=0.859309649061238957814672188228
  1775:     new EFP (P,     -1, 0xd99d15c278afd7b5L, 0xfe873dfL << 36),  //>2^(-15/64)=0.850053176859261734750681286749
  1776:     new EFP (P,     -1, 0xd744fccad69d6af4L, 0x39a68bcL << 36),  //>2^(-16/64)=0.840896415253714543031125476233
  1777:     new EFP (P,     -1, 0xd4f35aabcfedfa1fL, 0x5921df0L << 36),  //>2^(-17/64)=0.831838290163368217523168228488
  1778:     new EFP (P,     -1, 0xd2a81d91f12ae45aL, 0x12248e5L << 36),  //<2^(-18/64)=0.822877739076982422259378362363
  1779:     new EFP (P,     -1, 0xd06333daef2b2594L, 0xd6d45c6L << 36),  //<2^(-19/64)=0.814013710928673883424109261007
  1780:     new EFP (P,     -1, 0xce248c151f8480e3L, 0xe235839L << 36),  //>2^(-20/64)=0.805245165974627154089760333679
  1781:     new EFP (P,     -1, 0xcbec14fef2727c5cL, 0xf4907c9L << 36),  //>2^(-21/64)=0.796571075671133448968624321560
  1782:     new EFP (P,     -1, 0xc9b9bd866e2f27a2L, 0x80e1f93L << 36),  //>2^(-22/64)=0.787990422553943243227635080091
  1783:     new EFP (P,     -1, 0xc78d74c8abb9b15cL, 0xc13a2e4L << 36),  //>2^(-23/64)=0.779502200118918483516864044737
  1784:     new EFP (P,     -1, 0xc5672a115506daddL, 0x3e2ad0dL << 36),  //>2^(-24/64)=0.771105412703970411806145931045
  1785:     new EFP (P,     -1, 0xc346ccda24976407L, 0x20ec856L << 36),  //<2^(-25/64)=0.762799075372269153425626844758
  1786:     new EFP (P,     -1, 0xc12c4cca66709456L, 0x7c457d6L << 36),  //>2^(-26/64)=0.754582213796711369883009775517
  1787:     new EFP (P,     -1, 0xbf1799b67a731082L, 0xe815d0bL << 36),  //>2^(-27/64)=0.746453864145632424600321765743
  1788:     new EFP (P,     -1, 0xbd08a39f580c36beL, 0xa8811fbL << 36),  //<2^(-28/64)=0.738413072969749655693453740187
  1789:     new EFP (P,     -1, 0xbaff5ab2133e45fbL, 0x74d519dL << 36),  //<2^(-29/64)=0.730458897090323494325651445155
  1790:     new EFP (P,     -1, 0xb8fbaf4762fb9ee9L, 0x1b87978L << 36),  //>2^(-30/64)=0.722590403488523310018503120736
  1791:     new EFP (P,     -1, 0xb6fd91e328d17791L, 0x07165f1L << 36),  //>2^(-31/64)=0.714806669195985005617532889138
  1792:     new EFP (P,     -1, 0xb504f333f9de6484L, 0x597d89bL << 36),  //<2^(-32/64)=0.707106781186547524400844362105
  1793:     new EFP (P,     -1, 0xb311c412a9112489L, 0x3ecf14eL << 36),  //>2^(-33/64)=0.699489836269155570104764068358
  1794:     new EFP (P,     -1, 0xb123f581d2ac258fL, 0x87d037fL << 36),  //>2^(-34/64)=0.691954940981915977436329763633
  1795:     new EFP (P,     -1, 0xaf3b78ad690a4374L, 0xdf26102L << 36),  //>2^(-35/64)=0.684501211487295305964800566491
  1796:     new EFP (P,     -1, 0xad583eea42a14ac6L, 0x4980a8dL << 36),  //>2^(-36/64)=0.677127773468446364149007370070
  1797:     new EFP (P,     -1, 0xab7a39b5a93ed337L, 0x658023bL << 36),  //<2^(-37/64)=0.669833762026651502680015334862
  1798:     new EFP (P,     -1, 0xa9a15ab4ea7c0ef8L, 0x541e24fL << 36),  //>2^(-38/64)=0.662618321579870647314768547749
  1799:     new EFP (P,     -1, 0xa7cd93b4e9653569L, 0x9ec5b4dL << 36),  //<2^(-39/64)=0.655480605762382170961495893165
  1800:     new EFP (P,     -1, 0xa5fed6a9b15138eaL, 0x1cbd7f6L << 36),  //<2^(-40/64)=0.648419777325504832966877058896
  1801:     new EFP (P,     -1, 0xa43515ae09e6809eL, 0x0d1db48L << 36),  //<2^(-41/64)=0.641435008039389140363334890511
  1802:     new EFP (P,     -1, 0xa27043030c496818L, 0x9b7a04fL << 36),  //>2^(-42/64)=0.634525478595866611277209540516
  1803:     new EFP (P,     -1, 0xa0b0510fb9714fc2L, 0x192dc7aL << 36),  //>2^(-43/64)=0.627690378512345544789695328721
  1804:     new EFP (P,     -1, 0x9ef5326091a111adL, 0xa0911f1L << 36),  //>2^(-44/64)=0.620928906036742024296838734363
  1805:     new EFP (P,     -1, 0x9d3ed9a72cffb750L, 0xde494cfL << 36),  //<2^(-45/64)=0.614240268053435002847004478896
  1806:     new EFP (P,     -1, 0x9b8d39b9d54e5538L, 0xa2a817aL << 36),  //<2^(-46/64)=0.607623679990234439058260125669
  1807:     new EFP (P,     -1, 0x99e0459320b7fa64L, 0xe43086dL << 36),  //>2^(-47/64)=0.601078365726351571048198478749
  1808:     new EFP (P,     -1, 0x9837f0518db8a96fL, 0x46ad232L << 36),  //>2^(-48/64)=0.594603557501360533358749985280
  1809:     new EFP (P,     -1, 0x96942d3720185a00L, 0x48ea9b7L << 36),  //>2^(-49/64)=0.588198495825140638142322864242
  1810:     new EFP (P,     -1, 0x94f4efa8fef70961L, 0x2e8afadL << 36),  //<2^(-50/64)=0.581862429388788756906786799546
  1811:     new EFP (P,     -1, 0x935a2b2f13e6e92bL, 0xd339941L << 36),  //>2^(-51/64)=0.575594614976491352908879817601
  1812:     new EFP (P,     -1, 0x91c3d373ab11c336L, 0x0fd6d8eL << 36),  //<2^(-52/64)=0.569394317378345826851915141921
  1813:     new EFP (P,     -1, 0x9031dc431466b1dcL, 0x775814bL << 36),  //>2^(-53/64)=0.563260809304120949897399321894
  1814:     new EFP (P,     -1, 0x8ea4398b45cd53c0L, 0x2dc0145L << 36),  //>2^(-54/64)=0.557193371297946268154406478460
  1815:     new EFP (P,     -1, 0x8d1adf5b7e5ba9e5L, 0xb4c7b49L << 36),  //<2^(-55/64)=0.551191291653920471778207104713
  1816:     new EFP (P,     -1, 0x8b95c1e3ea8bd6e6L, 0xfbe4628L << 36),  //<2^(-56/64)=0.545253866332628829603505327880
  1817:     new EFP (P,     -1, 0x8a14d575496efd9aL, 0x080ca1eL << 36),  //>2^(-57/64)=0.539380398878559896870340018719
  1818:     new EFP (P,     -1, 0x88980e8092da8527L, 0x5df8d77L << 36),  //>2^(-58/64)=0.533570200338411809084760560496
  1819:     new EFP (P,     -1, 0x871f61969e8d1010L, 0x3a1727cL << 36),  //<2^(-59/64)=0.527822589180278579404170662576
  1820:     new EFP (P,     -1, 0x85aac367cc487b14L, 0xc5c95b9L << 36),  //>2^(-60/64)=0.522136891213706920160983239370
  1821:     new EFP (P,     -1, 0x843a28c3acde4046L, 0x1af92edL << 36),  //>2^(-61/64)=0.516512439510614211250054141985
  1822:     new EFP (P,     -1, 0x82cd8698ac2ba1d7L, 0x3e2a476L << 36),  //>2^(-62/64)=0.510948574327058339117240067392
  1823:     new EFP (P,     -1, 0x8164d1f3bc030773L, 0x7be5652L << 36),  //<2^(-63/64)=0.505444643025850230010204895281
  1824:   };  //EXP2M_T
  1825: 
  1826:   //------------------------------------------------------------------------
  1827:   //exp2m1
  1828:   //  echo read("efp.gp");eval("exp2m1(x)=2^x-1");efppoly("EXP2M1_C",exp2m1,sum(n=1,17,eval("efp(log(2)^n/factorial(n))*x^n")),-1/4,1/4) | gp -q
  1829:   public final EFP    EXP2M1_C1 = new EFP (P,     -1, 0xb17217f7d1cf79abL, 0xc9e3b3aL << 36);  //=0.693147180559945309417232121559
  1830:   public final EFP    EXP2M1_C2 = new EFP (P,     -3, 0xf5fdeffc162c7543L, 0x78b5837L << 36);  //=0.240226506959100712333551263143
  1831:   public final EFP    EXP2M1_C3 = new EFP (P,     -5, 0xe35846b82505fc59L, 0x9d3b15eL << 36);  //=0.0555041086648215799531422637737
  1832:   public final EFP    EXP2M1_C4 = new EFP (P,     -7, 0x9d955b7dd273b94eL, 0x65df05bL << 36);  //=0.00961812910762847716197907157485
  1833:   public final EFP    EXP2M1_C5 = new EFP (P,    -10, 0xaec3ff3c53398883L, 0x8bfb4d3L << 36);  //=0.00133335581464284434234122219898
  1834:   public final EFP    EXP2M1_C6 = new EFP (P,    -13, 0xa184897c363c3b7aL, 0x58544c3L << 36);  //=1.54035303933816099544370973310e-4
  1835:   public final EFP    EXP2M1_C7 = new EFP (P,    -17, 0xffe5fe2c45863435L, 0x8a8e644L << 36);  //=1.52527338040598402800254390122e-5
  1836:   public final EFP    EXP2M1_C8 = new EFP (P,    -20, 0xb160111d2e411fecL, 0x7ff3037L << 36);  //=1.32154867901443094884037582290e-6
  1837:   public final EFP    EXP2M1_C9 = new EFP (P,    -24, 0xda929e9caf3e1ed2L, 0x53872d2L << 36);  //=1.01780860092396997274900075965e-7
  1838:   public final EFP   EXP2M1_C10 = new EFP (P,    -28, 0xf267a8ac5c764fb7L, 0xed0eca9L << 36);  //=7.05491162080112332987539218087e-9
  1839:   public final EFP   EXP2M1_C11 = new EFP (P,    -32, 0xf465639a8dd92607L, 0xabccaf2L << 36);  //=4.44553827187081149759640855868e-10
  1840:   public final EFP   EXP2M1_C12 = new EFP (P,    -36, 0xe1deb287e14c2f15L, 0xab43f0cL << 36);  //=2.56784359934882051419948023929e-11
  1841:   public final EFP   EXP2M1_C13 = new EFP (P,    -40, 0xc0b0c98b3687cb14L, 0x0d61808L << 36);  //=1.36914888539041288808919539964e-12
  1842:   public final EFP   EXP2M1_C14 = new EFP (P,    -44, 0x98a4b26ac3c54b9fL, 0x8a1b12bL << 36);  //=6.77872635482254563344910431422e-14
  1843:   public final EFP   EXP2M1_C15 = new EFP (P,    -49, 0xe1b7421d82010f33L, 0xd8abf8dL << 36);  //=3.13243670708842862163494444075e-15
  1844:   public final EFP   EXP2M1_C16 = new EFP (P,    -53, 0x9c744d73cfc59c91L, 0xc7f2765L << 36);  //=1.35702479487551471931129662273e-16
  1845:   public final EFP   EXP2M1_C17 = new EFP (P,    -58, 0xcc2225a0e12d3eabL, 0x0ec4008L << 36);  //=5.53304653245824204348554609564e-18
  1846:   //  92.12bit
  1847: 
  1848:   //------------------------------------------------------------------------
  1849:   //expm1
  1850:   //  echo read("efp.gp");efppoly("EXPM1_C",expm1,sum(n=1,18,eval("efp(1/factorial(n))*x^n")),-1/4,1/4) | gp -q
  1851:   public final EFP     EXPM1_C1 = new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36);  //=1.00000000000000000000000000000
  1852:   public final EFP     EXPM1_C2 = new EFP (P,     -1, 0x8000000000000000L, 0x0000000L << 36);  //=0.500000000000000000000000000000
  1853:   public final EFP     EXPM1_C3 = new EFP (P,     -3, 0xaaaaaaaaaaaaaaaaL, 0xaaaaaabL << 36);  //=0.166666666666666666666666666683
  1854:   public final EFP     EXPM1_C4 = new EFP (P,     -5, 0xaaaaaaaaaaaaaaaaL, 0xaaaaaabL << 36);  //=0.0416666666666666666666666666709
  1855:   public final EFP     EXPM1_C5 = new EFP (P,     -7, 0x8888888888888888L, 0x8888889L << 36);  //=0.00833333333333333333333333333481
  1856:   public final EFP     EXPM1_C6 = new EFP (P,    -10, 0xb60b60b60b60b60bL, 0x60b60b6L << 36);  //=0.00138888888888888888888888888887
  1857:   public final EFP     EXPM1_C7 = new EFP (P,    -13, 0xd00d00d00d00d00dL, 0x00d00d0L << 36);  //=1.98412698412698412698412698410e-4
  1858:   public final EFP     EXPM1_C8 = new EFP (P,    -16, 0xd00d00d00d00d00dL, 0x00d00d0L << 36);  //=2.48015873015873015873015873013e-5
  1859:   public final EFP     EXPM1_C9 = new EFP (P,    -19, 0xb8ef1d2ab6399c7dL, 0x560e447L << 36);  //=2.75573192239858906525573192228e-6
  1860:   public final EFP    EXPM1_C10 = new EFP (P,    -22, 0x93f27dbbc4fae397L, 0x780b69fL << 36);  //=2.75573192239858906525573192209e-7
  1861:   public final EFP    EXPM1_C11 = new EFP (P,    -26, 0xd7322b3faa271c7fL, 0x3a3f25cL << 36);  //=2.50521083854417187750521083848e-8
  1862:   public final EFP    EXPM1_C12 = new EFP (P,    -29, 0x8f76c77fc6c4bdaaL, 0x26d4c3dL << 36);  //=2.08767569878680989792100903181e-9
  1863:   public final EFP    EXPM1_C13 = new EFP (P,    -33, 0xb092309d43684be5L, 0x1c198e9L << 36);  //=1.60590438368216145993923771696e-10
  1864:   public final EFP    EXPM1_C14 = new EFP (P,    -37, 0xc9cba54603e4e905L, 0xd6f8a2fL << 36);  //=1.14707455977297247138516979787e-11
  1865:   public final EFP    EXPM1_C15 = new EFP (P,    -41, 0xd73f9f399dc0f88eL, 0xc32b587L << 36);  //=7.64716373181981647590113198495e-13
  1866:   public final EFP    EXPM1_C16 = new EFP (P,    -45, 0xd73f9f399dc0f88eL, 0xc32b587L << 36);  //=4.77947733238738529743820749060e-14
  1867:   public final EFP    EXPM1_C17 = new EFP (P,    -49, 0xca963b81856a5359L, 0x3028cbcL << 36);  //=2.81145725434552076319894558321e-15
  1868:   public final EFP    EXPM1_C18 = new EFP (P,    -53, 0xb413c31dcbecbbddL, 0x8024435L << 36);  //=1.56192069685862264622163643497e-16
  1869:   //  92.61bit
  1870: 
  1871:   //------------------------------------------------------------------------
  1872:   //ieeerempi2
  1873:   public static final int[] TWO_PI_ARRAY = {
  1874:     //  perl ../misc/two_pi.pl
  1875:     0x00000000, 0x00000000, 0x00000000, 0x517cc1b7, 0x1391054a, 0x3f84eafa, 0x1f534ddc, 0x06db14ac, 0x64f10e41, 0x03fca2c7,
  1876:     0x2bdebbc5, 0x30db9237, 0x0e909374, 0x5c00c925, 0x6ea09d19, 0x10e7f0ef, 0x2c72c4a6, 0x4e7dd104, 0x35f52ebb, 0x224274ce,
  1877:     0x1c09ad17, 0x6fc82732, 0x1d639835, 0x19cfa4e4, 0x117e2ef7, 0x7250763f, 0x7897ffde, 0x02cc07f7, 0x4bc462d6, 0x414da3ed,
  1878:     0x5367ecf2, 0x3e584dba, 0x3d18fd9a, 0x3cbfd45a, 0x7527bac7, 0x75f2f8bd, 0x4f41ce7d, 0x714a525d, 0x26bfb5fb, 0x08fc6ae8,
  1879:     0x21580cc1, 0x0df8f6d7, 0x2bf0cfbc, 0x104d7a1b, 0x076a78e4, 0x2c2bdcc3, 0x30865998, 0x2af8a503, 0x210237ff, 0x31009ae6,
  1880:     0x27310606, 0x0aab6539, 0x6a325838, 0x4f78118d, 0x347c419c, 0x1b3e6ee7, 0x2024aa0d, 0x3388ed17, 0x161ca6dd, 0x57a268ab,
  1881:     0x46414fa9, 0x3fe0e0a7, 0x77e33e83, 0x1616f27c, 0x60c9f6ef, 0x067a4dde, 0x6b1e5ef8, 0x4f9d0f9a, 0x72bc9fc7, 0x30fe2432,
  1882:     0x07c7c246, 0x57d376ab, 0x5cb4c10c, 0x762b8c29, 0x359d19c3, 0x616256a0, 0x534b1740, 0x0188cfb0, 0x62d71e39, 0x5634d803,
  1883:     0x08cdf34a, 0x692f4f69, 0x555537f6, 0x1f6b8c08, 0x28ff1d93, 0x2553ac95, 0x3d770f87, 0x631abd83, 0x6b9c545d, 0x2c9381b3,
  1884:     0x563b3884, 0x53e59192, 0x1de2b588, 0x6a8b5723, 0x7001b0af, 0x0efe70cf, 0x7cc67da8, 0x3cccc2af, 0x1947fbac, 0x6c3fbf5b,
  1885:     0x5948a27a, 0x064c17fc, 0x6cdc4ef0, 0x49b366a1, 0x7d775f78, 0x2dbc76b1, 0x129bde28, 0x11697443, 0x0a135638, 0x465958c2,
  1886:     0x6e308cb7, 0x6f028600, 0x5e9c77cd, 0x37c03068, 0x132e6212, 0x4180a441, 0x56e3bd5f, 0x7615be5d, 0x11e434a4, 0x469b3886,
  1887:     0x6376a909, 0x3f5d9cc2, 0x6aa4280a, 0x5a4ce9f9, 0x29819fdd, 0x6b907854, 0x3883c617, 0x439c52d4, 0x32bef75d, 0x5ec74c5b,
  1888:     0x4bbff4ef, 0x40c6b3e0, 0x49917295, 0x26db395a, 0x2a8288d6, 0x0e13be48, 0x48509812, 0x368c2588, 0x59c444c5, 0x6448d926,
  1889:     0x7cc5c02b, 0x287a9ca9, 0x12910d5f, 0x6fe5f006, 0x32507bbb, 0x1ce1ea7c, 0x1380f1ec, 0x61f3d994, 0x3e31e501, 0x3267ce38,
  1890:     0x1b3092ef, 0x1a285ce0, 0x4a21ec82, 0x573f6a5d, 0x4292472f, 0x193db6aa, 0x432429dc, 0x43fced72, 0x6cb314a1, 0x33cf13ca,
  1891:     0x06277fd2, 0x2f29d109, 0x66e29731, 0x4cb5f6c4, 0x0d97d7c3, 0x5fb77693, 0x2486ca46, 0x3a139389, 0x497636e0, 0x2b3e13cb,
  1892:     0x3c25318d, 0x1cba7b8e, 0x014c0043, 0x01ad0109, 0x358ee2c9, 0x05523817, 0x1dd0935a, 0x7b4cfbee, 0x72486eef, 0x0b4fd34a,
  1893:     0x23bda46d, 0x0a2a7a3e, 0x20acf339, 0x4103f25f, 0x55a18ec9, 0x3e7dba06, 0x5d407f89, 0x4294a92a, 0x70190dc4, 0x1b0da649,
  1894:     0x032754c5, 0x5ea38a73, 0x39511704, 0x1216d3ea, 0x2ad56614, 0x4e8393a8, 0x011776ce, 0x7698aedd, 0x217f9877, 0x6b5a4dd1,
  1895:     0x1c74a5a6, 0x2d59998c, 0x5414ad6a, 0x714844ec, 0x62141c8b, 0x17d48092, 0x40777703, 0x07993fe0, 0x02a1c7a9, 0x1384cc7b,
  1896:     0x606483dd, 0x4bcb9fd1, 0x7f6510e3, 0x10c1bbc8, 0x1319d399, 0x146386ef, 0x1edc5cef, 0x3e10566e, 0x15a0805c, 0x49c02d49,
  1897:     0x0444363a, 0x01f5f00d, 0x44bffdb0, 0x7c81c3b0, 0x61645695, 0x457796c3, 0x3989c7bd, 0x20080279, 0x3489dd52, 0x3ed6dd77,
  1898:     0x322dbaa1, 0x20517934, 0x25da0d90, 0x66761235, 0x140eaa3a, 0x28e1518e, 0x6bbb6bc4, 0x44cb89b8, 0x26d9c7a2, 0x6cbab604,
  1899:     0x0cfc0fdb, 0x60131880, 0x2b99316d, 0x03da1c8a, 0x480316f0, 0x7b18925e, 0x54badc6a, 0x2e527669, 0x5e9cdaa7, 0x4d292556,
  1900:     0x6842ddde, 0x318cf7c6, 0x1d94a2da, 0x06fb7f95, 0x3a1ae311, 0x2efd0d70, 0x036bec31, 0x4c9ac96e, 0x05ed3065, 0x14dfab2b,
  1901:     0x4ebfd1ee, 0x3f2d5e77, 0x675df932, 0x4184055f, 0x5a319857, 0x16080c45, 0x7a1de4d9, 0x52599ec7, 0x46d5c273, 0x26dd2849,
  1902:     0x6a4be13b, 0x291998d5, 0x2bc2a195, 0x1f4b83a4, 0x0f3f0bcd, 0x3c2dbb7c, 0x48c122de, 0x6e42f12a, 0x3a6c6e26, 0x7378075f,
  1903:     0x3d612a6e, 0x6fb58974, 0x66aacfcf, 0x3b0e8168, 0x4b7c6c70, 0x33318ef5, 0x5c3da488, 0x3502efbf, 0x520318bf, 0x615935d9,
  1904:     0x5dbc5c3f, 0x36ef680f, 0x71e42db6, 0x654744b4, 0x39aaf009, 0x1a9d6822, 0x5edad0b4, 0x52fd0097, 0x2707da0e, 0x553b50ac,
  1905:     0x5eca8485, 0x45b6fb9f, 0x5e5fafed, 0x5c4fedf4, 0x25b1db93, 0x79520ce1, 0x003e156e, 0x42ffc3fe, 0x41cf8a0c, 0x6cec30c3,
  1906:     0x02aeabd4, 0x6d7f3d9b, 0x39b63ce5, 0x4f2ab77e, 0x3148d784, 0x0b6f9821, 0x4b71cd58, 0x24b9ce19, 0x1b8cb30f, 0x6b65fd10,
  1907:     0x029391b0, 0x0b41bab4, 0x476f21d2, 0x0931422e, 0x2e52585c, 0x1c0acd60, 0x15299375, 0x2a85bea8, 0x7b13c4cd, 0x3edc27c8,
  1908:     0x305da92e, 0x42e1d90e, 0x4d8ca869, 0x16e11a96, 0x1ea21f71, 0x37234c7b, 0x5ffc9e00, 0x06185a81, 0x0da0cd4f, 0x4cd29069,
  1909:     0x68acc297, 0x25e85f36, 0x4cbda11d, 0x05f3ee0e, 0x6e6ef45e, 0x57034594, 0x5c6a0817, 0x2a972a80, 0x09fc051f, 0x70c0fc2c,
  1910:     0x40b148d4, 0x0cb6f5f4, 0x1cabf76a, 0x6c4ad669, 0x097bfef3, 0x02cf5fdc, 0x53da9a2a, 0x05494b58, 0x44fbcf82, 0x6cc2d6bc,
  1911:     0x571fd235, 0x1a1b4c74, 0x205f57a4, 0x589f8a4a, 0x4e200048, 0x1990dbae, 0x1b6dec9f, 0x2b05f88b, 0x1535ac1c, 0x03596119,
  1912:     0x50c0b248, 0x2aa8877d, 0x47b0dca5, 0x2760d466, 0x540c07bd, 0x6036622f, 0x03e8a53b, 0x1195ac83, 0x73e8de64, 0x3e6c324d,
  1913:     0x4c6fb670, 0x72f49a8b, 0x077c5e36, 0x489ed781, 0x70eae918, 0x308cbeea, 0x55f5bdd2, 0x6349372e, 0x4bab3b51, 0x01c847c3,
  1914:     0x487c461e, 0x4fe94f9e, 0x5b9f29f0, 0x446b22df, 0x45e0088d, 0x6bfff135, 0x1bb1bf6c, 0x1821126e, 0x45d7cb2a, 0x6b5ceb76,
  1915:     0x35edc8f9, 0x54238d53, 0x4ff7df73, 0x14dd64da, 0x54402dc3, 0x365c4497, 0x274607de, 0x2c56c3a1, 0x30543430, 0x310328cc,
  1916:     0x7e162901, 0x3b3d4fdf, 0x3f7f7bd1, 0x2ac6cfdb, 0x113d9ecb, 0x4dd45fe4, 0x5f109ea0, 0x6386dde2, 0x36c59456, 0x546c5ad4,
  1917:     0x2d03b333, 0x65b12246, 0x4576f895, 0x31671e74, 0x66e4835a, 0x54bcd738, 0x2a3ecc5f, 0x08a505fe, 0x7efd385b, 0x2771c590,
  1918:     0x6e284d4e, 0x4d4da7e6, 0x47bbbf24, 0x6a5cc272, 0x2f442138, 0x646c8d85, 0x3f205a92, 0x5f7b0385, 0x784b4538, 0x64ca7661,
  1919:     0x09537154, 0x55ad8d81, 0x16190bb8, 0x380d324a, 0x5a581689, 0x5dca47e1, 0x7117f11b, 0x2fa7ae5f, 0x70b6f0d3, 0x5d786998,
  1920:     0x5de8605e, 0x6ecdc733, 0x7bcce4ae, 0x02f9336b, 0x061bc57e, 0x0e341a88, 0x40fb6121, 0x63bbba38, 0x2da118af, 0x231610eb,
  1921:     0x7cd6661e, 0x5b380a93, 0x6fa864ff, 0x6032b573, 0x6794d88a, 0x12455a71, 0x5c9367aa, 0x742a9c13, 0x20a6f9f2, 0x5481aa36,
  1922:     0x133990ed, 0x3d4a402b, 0x27c2c996, 0x4f10ff2e, 0x4c8836d1, 0x7cd9c910, 0x52a09ec8, 0x39f31b93, 0x7405547d, 0x61d3a70a,
  1923:     0x0bad9f7e, 0x3bfcbfa8, 0x5ea4677b, 0x3d565d51, 0x3d9548e2, 0x056ab748, 0x1086e598, 0x31510c1a, 0x1ce79b8e, 0x13a93dca,
  1924:     0x40fb49e9, 0x2b7fe507, 0x47229671, 0x257f5298, 0x5c1d3cfc, 0x287d72d6, 0x6e1b151d, 0x44870a77, 0x06219479, 0x1643b088,
  1925:     0x1ed30a86, 0x45900257, 0x74390268, 0x4449e3c7, 0x1312a1ef, 0x37cb8475, 0x44eaf426, 0x4533fbdf, 0x64834ae8, 0x6cb63267,
  1926:     0x50b7cbdd, 0x628d231e, 0x749f7785, 0x52332935, 0x1529a828, 0x67345a76, 0x424827d1, 0x195309cc, 0x38270237, 0x63f195c8,
  1927:     0x3e3bd69f, 0x4eac2811, 0x71212a9d, 0x5aa6bf37, 0x5446696a, 0x7f36badb, 0x78261dd9, 0x3011b0b4, 0x7ceb1286, 0x4506dbda,
  1928:     0x727a8d39, 0x54dc412e, 0x0c9ad6c9, 0x68dda680, 0x07700d25, 0x2fa7e26a, 0x640601c7, 0x41c27f13, 0x3295f364, 0x5478d753,
  1929:     0x52ce3f13, 0x1d565768, 0x7270babc, 0x1d39a5d3, 0x014b74d3, 0x70ac75d6, 0x7e8a31bb, 0x1b2c4adb, 0x51fdea65, 0x18755a72,
  1930:     0x2251e7f3, 0x76c4ba75, 0x6ea53f62, 0x5c03ccc3, 0x34393d8e, 0x5291d519, 0x41a3858c, 0x76a77631, 0x01d3a9d4, 0x009e8660,
  1931:     0x6f97e18b, 0x4e77e51e, 0x39b5bf0b, 0x611a913a, 0x1fa891f0, 0x1aa5a3e3, 0x1add3909, 0x26fc988e, 0x42d0ac95, 0x12db65c4,
  1932:     0x64b25ef1, 0x1a9de352, 0x0692b42a, 0x5925cc9d, 0x08657309, 0x0cc167d9, 0x446c6821, 0x65177b9d, 0x6160e142, 0x75b20ee8,
  1933:     0x2ee8f956, 0x3a8b2f71, 0x42a4483f, 0x1995d7c2, 0x219cb234, 0x365f5360, 0x50f3ddf9, 0x7ab9edb0, 0x6d3f88cf, 0x4d8834dd,
  1934:     0x6a318775, 0x5135e2f2, 0x733a9c22, 0x29b8afc4, 0x0196f1e8, 0x1cdf2428, 0x574b4bd3, 0x52aabb2d, 0x6c2e7d75, 0x2b182706,
  1935:     0x00b83bf1, 0x014177f3, 0x337125a7, 0x1116fdfb, 0x067620e3, 0x038cc33c, 0x6b20d55b, 0x5a89bbcf, 0x2026be45, 0x121ae7bc,
  1936:     0x0b0da5ce, 0x3fac560c, 0x4d1c9199, 0x6f434273, 0x626bc455, 0x2f3ac2e5, 0x55c47451, 0x10d32290, 0x0d6056ad, 0x55eb17b2,
  1937:     0x25bb8308, 0x25fe6bad, 0x588a6768, 0x24ab28f5, 0x2e782937, 0x3dfcae20, 0x10836a39, 0x7c7518cf, 0x0e077ab2, 0x1639592d,
  1938:     0x337f21ed, 0x282f4cc2, 0x1d0e7f15, 0x5806636e, 0x3b8bf886, 0x72b546e1, 0x50d88c39, 0x7279faad, 0x28f2d733, 0x0028d781,
  1939:     0x06827f2d, 0x682b43aa, 0x6b236ff7, 0x1297a5e3, 0x6e29645f, 0x758b2b8a, 0x5de212c3, 0x458994b2, 0x73fd40d9, 0x44c5f4f6,
  1940:     0x16f4d9a6, 0x1567f3f8, 0x1d00f535, 0x408dfb22, 0x631b1bfc, 0x5da282de, 0x5f203386, 0x28d7ac86, 0x4fd91cdf, 0x22a1af9a,
  1941:     0x14f8ad6a, 0x5935d902, 0x31485f9d, 0x15fdd6dc, 0x79dbd6e6, 0x5e2b9f94, 0x318214b5, 0x36f4ff26, 0x543f0d7d, 0x35dab45a,
  1942:     0x0c1c9605, 0x38c975b7, 0x2476481f, 0x22895d47, 0x46343566, 0x136ada18, 0x58788dfc, 0x344413df, 0x7958e234, 0x49bcc1af,
  1943:     0x52992f70, 0x05857c27, 0x3e80a00b, 0x395188ae, 0x17c786f4, 0x21b69a70, 0x69e85969, 0x3b595648, 0x7e289b08, 0x60e1e008,
  1944:     0x1412fc9f, 0x52fb951c, 0x271a1e38, 0x554eca19, 0x7e155927, 0x249a71c0, 0x2a4bdd54, 0x67e14c7b, 0x34399971, 0x715baad4,
  1945:     0x629f0023, 0x63358a9a, 0x22ea0b4f, 0x2f9f0306, 0x2127ff49, 0x535ca59c, 0x7a5fdde9, 0x67037d85, 0x3a294333, 0x5d53a7c6,
  1946:     0x766ddb83, 0x27a86d04, 0x4211be21, 0x15c7aa13, 0x1a032eae, 0x16fe5a05, 0x3ee6ccf8, 0x503ba362, 0x6bad8c0a, 0x7ecb5cbd,
  1947:     0x54b72670, 0x4efeb2a3, 0x5521ccd6, 0x5b24b5ac, 0x1158acee, 0x5e5434b8, 0x47ca2cfa, 0x4dc9ebdb, 0x6e2520f4, 0x712d6079,
  1948:     0x479cb1d0, 0x412ec476, 0x6df4e0ce, 0x218dccdd, 0x112dc112, 0x01a06f3c, 0x0a83fb99, 0x4cf103b8, 0x0ae80abf, 0x669460db,
  1949:     0x6b378631, 0x1f046ecc, 0x6b9959db, 0x21603fd5, 0x2f580e29, 0x2ae0ad5d, 0x6bf5b0bd, 0x4af4a5f0, 0x02e7ace9, 0x43c47e49,
  1950:     0x2d62c9ac, 0x278d6bae, 0x104be4ed, 0x5c16985d, 0x546c0ed2, 0x72af0b2a, 0x61e1a03e, 0x7eced683, 0x6698ec3a, 0x7142ea4b,
  1951:     0x5f24a858, 0x6e9c3272, 0x06f911c9, 0x0d5513a3, 0x1fc36964, 0x67ed3ad4, 0x2578ec29, 0x7cfd545a, 0x2b766f3e, 0x76b83a17,
  1952:     0x688dd533, 0x7f6f1b7b, 0x7bd82cc2, 0x16398030, 0x29ebb591, 0x28bd8e64, 0x5adfbbc3, 0x1bc4cf94, 0x73d1a019, 0x21dc51ba,
  1953:     0x258a3a9a, 0x46e4c4c5, 0x6928185e, 0x530afef7, 0x2d875f8b, 0x1f4f5d6f, 0x148d28b4, 0x463d8e26, 0x00bc57e7, 0x30a17145,
  1954:     0x5b016cdd, 0x2b1c719f, 0x52ced170, 0x525ea256, 0x04b90d6f, 0x6c1ccaef, 0x2b714760, 0x4c558061, 0x1a2a9160, 0x12d57856,
  1955:     0x4f909d7d, 0x32160cfc, 0x774b63e8, 0x5580957f, 0x3f205106, 0x6cf7f633, 0x76d4d795, 0x2bffd269, 0x6c2ca700, 0x4c9bac8e,
  1956:     0x34a1ad86, 0x19f38439, 0x16f7e283, 0x77df8d0a, 0x251e13b6, 0x32e8b8c3, 0x46a1068a, 0x1e9c5c29, 0x5b2fa425, 0x02e01623,
  1957:     0x51ce180d, 0x66090a25, 0x5df2cab5, 0x552ac91c, 0x2e89ef09, 0x0c000db6, 0x6951b1e0, 0x789a0cbc, 0x6ae6f080, 0x197c594d,
  1958:     0x10fa6934, 0x798f992f, 0x4bfbe442, 0x665adf98, 0x0215d378, 0x367fd774, 0x574985bf, 0x447087e5, 0x4828acdf, 0x26924cf7,
  1959:     0x0f3ac27c, 0x0df67285, 0x60d6c4e2, 0x260b1d34, 0x22381ff4, 0x019645ba, 0x531bc9b6, 0x1e29e4a7, 0x2cb63fe8, 0x3c34ff74,
  1960:     0x45e57b7c, 0x131273c5, 0x24ab0a65, 0x4683a26a, 0x2f7d5a42, 0x0c8e8918, 0x68b0e425, 0x2ede222c, 0x1fffc690, 0x1951ff6c,
  1961:     0x390fa5f7, 0x72db49bf, 0x1a472a23, 0x3edb35f5, 0x2c822c06, 0x7b751e95, 0x20b4c1e8, 0x7201c30a, 0x1a568076, 0x3a3229c0,
  1962:     0x0e8de742, 0x11c7a6ac, 0x0108583f, 0x61b495f1, 0x20f7527e, 0x2f65cc0e, 0x412fb7e9, 0x0f43e808, 0x5dc68477, 0x7a9463f7,
  1963:     0x5fc162d6, 0x6949775c, 0x0a355126, 0x3f132edb, 0x7166ef0a, 0x4d1d3a6f, 0x61ad61d1, 0x4fdab592, 0x71a3b69c, 0x35df937d,
  1964:     0x137af459, 0x4a907aed, 0x3ac1d542, 0x18e3e8d7, 0x5e8fac78, 0x14a4ae49, 0x6aabefb6, 0x77e37c4c, 0x3e4f0dde, 0x7ed7dccf,
  1965:     0x3bac1d8a, 0x758937b9, 0x773b8d06, 0x44928857, 0x36123085, 0x6cfe74b3, 0x542cde0f, 0x75489536, 0x0bed8292, 0x2413fd2b,
  1966:     0x5a2b596b, 0x5802b312, 0x1466722c, 0x5fd5e188, 0x2cfc3e6c, 0x457efa07, 0x7ca7008b, 0x30042951, 0x4d63ead1, 0x1dd4a4df,
  1967:     0x3fb0dc1e, 0x49a31414, 0x4325445a, 0x5d3b0f83, 0x33285b53, 0x22a6d56b, 0x60ce333d, 0x261489f9, 0x206fdd19, 0x0473cf16,
  1968:     0x12aff801, 0x3afc227c, 0x60cb396d, 0x71adb49d, 0x24f0aed6, 0x60dec1f8, 0x74bbf1d8, 0x6317b251, 0x7ddc3bf1, 0x39715e5c,
  1969:     0x5dd12bf8, 0x0b70339b, 0x1751f725, 0x25cf2702, 0x66ad9d94, 0x5c36fbf7, 0x2cd904e7, 0x1705954c, 0x6522c5ae, 0x34701d5f,
  1970:     0x1d1f3539, 0x4e5ac6f3, 0x58b21a8d, 0x5604296f, 0x59f20834, 0x71553e1c, 0x645dcd7a, 0x75f00a6f, 0x2dd36c8a, 0x2b16683e,
  1971:     0x5217a178, 0x14afab5a, 0x78298160, 0x1561f22d, 0x44c17ce8, 0x7de4db61, 0x50910214, 0x513bc866, 0x478f0860, 0x5bea3878,
  1972:     0x2001c11d, 0x1c94c363, 0x4f10f050, 0x4c8e924f, 0x4e6ce03d, 0x5d1db956, 0x796b4a2b, 0x76bbf110, 0x6f4060ad, 0x209f4870,
  1973:     0x020eed54, 0x0003cfb4, 0x01b409a1, 0x1cd56a51, 0x5e1a1f1b, 0x0ad47bed, 0x0cc38b4a, 0x5bd71ce4, 0x76b45f98, 0x2f10a374,
  1974:     0x345d3ab0, 0x6d3f6a7c, 0x7d00e32a, 0x5790fb34, 0x6a007a58, 0x2631f0a8, 0x53537781, 0x47e6d0a0, 0x1ef295fa, 0x12cb2e53,
  1975:     0x1cc6f20c, 0x1f08d6aa, 0x4e0bd445, 0x0107ab02, 0x7692436d, 0x3c67f4e8, 0x04a2717c, 0x270b82ce, 0x284fedd0, 0x5856f438,
  1976:     0x2dd7e754, 0x54aa2e82, 0x009d1952, 0x433b5bf8, 0x79923e89, 0x6e4a9f6e, 0x4173ab12, 0x06c14fa3, 0x1a1800a9, 0x04e69bb2,
  1977:     0x56165d57, 0x432db958, 0x7e07141f, 0x15435c6f, 0x52777a77, 0x33496069, 0x3c48a10c, 0x0cd25a95, 0x0a91f166, 0x265bc1be,
  1978:     0x67f67d7a, 0x719c9e48, 0x3e44fddd, 0x292e3d83, 0x46297725, 0x55068553, 0x3e829c3a, 0x02de9ef9, 0x2f4cf771, 0x0f7af4b0,
  1979:     0x2a4a6256, 0x2c1f745d, 0x1b3c5c63, 0x415065a9, 0x144eec3f, 0x10adfef5, 0x7a8dd087, 0x5ba28ec9, 0x1e715b24, 0x2e781501,
  1980:     0x196aafdb, 0x6ddc0ff5, 0x6a7db0b8, 0x2922c055, 0x1769411c, 0x7434d29c, 0x557218d4, 0x4d8688d7, 0x1fbe0ab7, 0x4e7d4e64,
  1981:     0x2d3d2515, 0x7780f9d5, 0x701dfb6b, 0x4d9b6fed, 0x010dfebe, 0x7fecdbf5, 0x4882d11f, 0x276ba7ec, 0x7bb0cd6c, 0x259938b0,
  1982:   };
  1983: 
  1984:   //------------------------------------------------------------------------
  1985:   //log
  1986:   //  echo read("efp.gp");eval("f(x)=log((1+x)/(1-x))");efpchebyshev("LOG_C",f,2*sqrt(2)-3,3-2*sqrt(2),27) | gp -q
  1987:   public final EFP       LOG_C1 = new EFP (P,      1, 0x8000000000000000L, 0x0000000L << 36);  //=2.00000000000000000000000000000
  1988:   public final EFP       LOG_C3 = new EFP (P,     -1, 0xaaaaaaaaaaaaaaaaL, 0xaaaaafaL << 36);  //=0.666666666666666666666666682688
  1989:   public final EFP       LOG_C5 = new EFP (P,     -2, 0xccccccccccccccccL, 0xcc9635cL << 36);  //=0.399999999999999999999977422089
  1990:   public final EFP       LOG_C7 = new EFP (P,     -2, 0x9249249249249249L, 0xb11c709L << 36);  //=0.285714285714285714300594501439
  1991:   public final EFP       LOG_C9 = new EFP (P,     -3, 0xe38e38e38e38e1f4L, 0xa08ab7fL << 36);  //=0.222222222222222216671173431320
  1992:   public final EFP      LOG_C11 = new EFP (P,     -3, 0xba2e8ba2e8bba550L, 0x957b4b0L << 36);  //=0.181818181818183118424115217462
  1993:   public final EFP      LOG_C13 = new EFP (P,     -3, 0x9d89d89d88f3a6b4L, 0xb83ee9bL << 36);  //=0.153846153845950485101802426447
  1994:   public final EFP      LOG_C15 = new EFP (P,     -3, 0x88888888e97610a0L, 0x018bbc5L << 36);  //=0.133333333355372176624252479880
  1995:   public final EFP      LOG_C17 = new EFP (P,     -4, 0xf0f0f0b6e98b6c2fL, 0x176ec78L << 36);  //=0.117647057134666354102829804155
  1996:   public final EFP      LOG_C19 = new EFP (P,     -4, 0xd79442422528c14bL, 0xdacdc08L << 36);  //=0.105263250011052968996816802164
  1997:   public final EFP      LOG_C21 = new EFP (P,     -4, 0xc30a54423d395d6dL, 0xa2f5188L << 36);  //=0.0952345450129114490041764123058
  1998:   public final EFP      LOG_C23 = new EFP (P,     -4, 0xb247b3a940a7a020L, 0x5cb7483L << 36);  //=0.0870508228327542823405094334272
  1999:   public final EFP      LOG_C25 = new EFP (P,     -4, 0xa07d6fb3e1085165L, 0x68590abL << 36);  //=0.0783642508287167052010634682520
  2000:   public final EFP      LOG_C27 = new EFP (P,     -4, 0xb976c8a2f3029b2dL, 0xa0b471bL << 36);  //=0.0905585932472388526925818403382
  2001:   //  98.60bit
  2002: 
  2003:   //------------------------------------------------------------------------
  2004:   //log10
  2005:   //  echo read("efp.gp");eval("f(x)=log((1+x)/(1-x))/log(10)");efpchebyshev("LOG10_C",f,2*sqrt(2)-3,3-2*sqrt(2),27) | gp -q
  2006:   public final EFP     LOG10_C1 = new EFP (P,     -1, 0xde5bd8a937287195L, 0x355baabL << 36);  //=0.868588963806503655302257837837
  2007:   public final EFP     LOG10_C3 = new EFP (P,     -2, 0x943d3b1b7a1af663L, 0x78e7cb7L << 36);  //=0.289529654602167885100752619580
  2008:   public final EFP     LOG10_C5 = new EFP (P,     -3, 0xb1e313ba9286c144L, 0x2a80513L << 36);  //=0.173717792761300731060441762115
  2009:   public final EFP     LOG10_C7 = new EFP (P,     -4, 0xfe1fd30a882e38abL, 0x7a44130L << 36);  //=0.124084137686643379335356372423
  2010:   public final EFP     LOG10_C9 = new EFP (P,     -4, 0xc5a6f979f823f1cbL, 0x86cedb8L << 36);  //=0.0965098848673892926227943455482
  2011:   public final EFP    LOG10_C11 = new EFP (P,     -4, 0xa1b729353f6480daL, 0x7d9f583L << 36);  //=0.0789626330733190788064418159654
  2012:   public final EFP    LOG10_C13 = new EFP (P,     -4, 0x88d60f2d0d7965b3L, 0x533de4bL << 36);  //=0.0668145356773350395174370490118
  2013:   public final EFP    LOG10_C15 = new EFP (P,     -5, 0xed2ec4f96bbfdbfdL, 0xfddb370L << 36);  //=0.0579059309300049250489272107676
  2014:   public final EFP    LOG10_C17 = new EFP (P,     -5, 0xd147624ebd9efe71L, 0xccd7fdfL << 36);  //=0.0510934677257421907379148609296
  2015:   public final EFP    LOG10_C19 = new EFP (P,     -5, 0xbb3fe99c80f7032eL, 0x107f05cL << 36);  //=0.0457152486270027163909629543765
  2016:   public final EFP    LOG10_C21 = new EFP (P,     -5, 0xa968eecf07930e0cL, 0xbd58cd0L << 36);  //=0.0413598373856742928826627330520
  2017:   public final EFP    LOG10_C23 = new EFP (P,     -5, 0x9ada242bfa9153a2L, 0x1833fc8L << 36);  //=0.0378056920014027856718189387863
  2018:   public final EFP    LOG10_C25 = new EFP (P,     -5, 0x8b665b489db905f7L, 0x74ec677L << 36);  //=0.0340331617133939941648757175539
  2019:   public final EFP    LOG10_C27 = new EFP (P,     -5, 0xa1178c2d7152670fL, 0x3d41c7cL << 36);  //=0.0393290973361969170732439582255
  2020:   //  96.83bit
  2021:   public final EFP[] ACCURATE_LOG10_BASE = {
  2022:     //  echo read("efp.gp");p=0;for(n=0,39,q=floor(log(10)/log(2)*n);for(i=p+1,q-1,print("    null,  //",i));p=q;efpmem([Str("10^",n)])) | gp -q
  2023:     new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36),  //=10^0=1.00000000000000000000000000000
  2024:     null,  //1
  2025:     null,  //2
  2026:     new EFP (P,      3, 0xa000000000000000L, 0x0000000L << 36),  //=10^1=10.0000000000000000000000000000
  2027:     null,  //4
  2028:     null,  //5
  2029:     new EFP (P,      6, 0xc800000000000000L, 0x0000000L << 36),  //=10^2=100.000000000000000000000000000
  2030:     null,  //7
  2031:     null,  //8
  2032:     new EFP (P,      9, 0xfa00000000000000L, 0x0000000L << 36),  //=10^3=1000.00000000000000000000000000
  2033:     null,  //10
  2034:     null,  //11
  2035:     null,  //12
  2036:     new EFP (P,     13, 0x9c40000000000000L, 0x0000000L << 36),  //=10^4=10000.0000000000000000000000000
  2037:     null,  //14
  2038:     null,  //15
  2039:     new EFP (P,     16, 0xc350000000000000L, 0x0000000L << 36),  //=10^5=100000.000000000000000000000000
  2040:     null,  //17
  2041:     null,  //18
  2042:     new EFP (P,     19, 0xf424000000000000L, 0x0000000L << 36),  //=10^6=1000000.00000000000000000000000
  2043:     null,  //20
  2044:     null,  //21
  2045:     null,  //22
  2046:     new EFP (P,     23, 0x9896800000000000L, 0x0000000L << 36),  //=10^7=10000000.0000000000000000000000
  2047:     null,  //24
  2048:     null,  //25
  2049:     new EFP (P,     26, 0xbebc200000000000L, 0x0000000L << 36),  //=10^8=100000000.000000000000000000000
  2050:     null,  //27
  2051:     null,  //28
  2052:     new EFP (P,     29, 0xee6b280000000000L, 0x0000000L << 36),  //=10^9=1000000000.00000000000000000000
  2053:     null,  //30
  2054:     null,  //31
  2055:     null,  //32
  2056:     new EFP (P,     33, 0x9502f90000000000L, 0x0000000L << 36),  //=10^10=10000000000.0000000000000000000
  2057:     null,  //34
  2058:     null,  //35
  2059:     new EFP (P,     36, 0xba43b74000000000L, 0x0000000L << 36),  //=10^11=100000000000.000000000000000000
  2060:     null,  //37
  2061:     null,  //38
  2062:     new EFP (P,     39, 0xe8d4a51000000000L, 0x0000000L << 36),  //=10^12=1000000000000.00000000000000000
  2063:     null,  //40
  2064:     null,  //41
  2065:     null,  //42
  2066:     new EFP (P,     43, 0x9184e72a00000000L, 0x0000000L << 36),  //=10^13=10000000000000.0000000000000000
  2067:     null,  //44
  2068:     null,  //45
  2069:     new EFP (P,     46, 0xb5e620f480000000L, 0x0000000L << 36),  //=10^14=100000000000000.000000000000000
  2070:     null,  //47
  2071:     null,  //48
  2072:     new EFP (P,     49, 0xe35fa931a0000000L, 0x0000000L << 36),  //=10^15=1000000000000000.00000000000000
  2073:     null,  //50
  2074:     null,  //51
  2075:     null,  //52
  2076:     new EFP (P,     53, 0x8e1bc9bf04000000L, 0x0000000L << 36),  //=10^16=10000000000000000.0000000000000
  2077:     null,  //54
  2078:     null,  //55
  2079:     new EFP (P,     56, 0xb1a2bc2ec5000000L, 0x0000000L << 36),  //=10^17=100000000000000000.000000000000
  2080:     null,  //57
  2081:     null,  //58
  2082:     new EFP (P,     59, 0xde0b6b3a76400000L, 0x0000000L << 36),  //=10^18=1000000000000000000.00000000000
  2083:     null,  //60
  2084:     null,  //61
  2085:     null,  //62
  2086:     new EFP (P,     63, 0x8ac7230489e80000L, 0x0000000L << 36),  //=10^19=10000000000000000000.0000000000
  2087:     null,  //64
  2088:     null,  //65
  2089:     new EFP (P,     66, 0xad78ebc5ac620000L, 0x0000000L << 36),  //=10^20=100000000000000000000.000000000
  2090:     null,  //67
  2091:     null,  //68
  2092:     new EFP (P,     69, 0xd8d726b7177a8000L, 0x0000000L << 36),  //=10^21=1000000000000000000000.00000000
  2093:     null,  //70
  2094:     null,  //71
  2095:     null,  //72
  2096:     new EFP (P,     73, 0x878678326eac9000L, 0x0000000L << 36),  //=10^22=10000000000000000000000.0000000
  2097:     null,  //74
  2098:     null,  //75
  2099:     new EFP (P,     76, 0xa968163f0a57b400L, 0x0000000L << 36),  //=10^23=100000000000000000000000.000000
  2100:     null,  //77
  2101:     null,  //78
  2102:     new EFP (P,     79, 0xd3c21bcecceda100L, 0x0000000L << 36),  //=10^24=1000000000000000000000000.00000
  2103:     null,  //80
  2104:     null,  //81
  2105:     null,  //82
  2106:     new EFP (P,     83, 0x84595161401484a0L, 0x0000000L << 36),  //=10^25=10000000000000000000000000.0000
  2107:     null,  //84
  2108:     null,  //85
  2109:     new EFP (P,     86, 0xa56fa5b99019a5c8L, 0x0000000L << 36),  //=10^26=100000000000000000000000000.000
  2110:     null,  //87
  2111:     null,  //88
  2112:     new EFP (P,     89, 0xcecb8f27f4200f3aL, 0x0000000L << 36),  //=10^27=1000000000000000000000000000.00
  2113:     null,  //90
  2114:     null,  //91
  2115:     null,  //92
  2116:     new EFP (P,     93, 0x813f3978f8940984L, 0x4000000L << 36),  //=10^28=10000000000000000000000000000.0
  2117:     null,  //94
  2118:     null,  //95
  2119:     new EFP (P,     96, 0xa18f07d736b90be5L, 0x5000000L << 36),  //=10^29=100000000000000000000000000000
  2120:     null,  //97
  2121:     null,  //98
  2122:     new EFP (P,     99, 0xc9f2c9cd04674edeL, 0xa400000L << 36),  //=10^30=1.00000000000000000000000000000e+30
  2123:     null,  //100
  2124:     null,  //101
  2125:     new EFP (P,    102, 0xfc6f7c4045812296L, 0x4d00000L << 36),  //=10^31=1.00000000000000000000000000000e+31
  2126:     null,  //103
  2127:     null,  //104
  2128:     null,  //105
  2129:     new EFP (P,    106, 0x9dc5ada82b70b59dL, 0xf020000L << 36),  //=10^32=1.00000000000000000000000000000e+32
  2130:     null,  //107
  2131:     null,  //108
  2132:     new EFP (P,    109, 0xc5371912364ce305L, 0x6c28000L << 36),  //=10^33=1.00000000000000000000000000000e+33
  2133:     null,  //110
  2134:     null,  //111
  2135:     new EFP (P,    112, 0xf684df56c3e01bc6L, 0xc732000L << 36),  //=10^34=1.00000000000000000000000000000e+34
  2136:     null,  //113
  2137:     null,  //114
  2138:     null,  //115
  2139:     new EFP (P,    116, 0x9a130b963a6c115cL, 0x3c7f400L << 36),  //=10^35=1.00000000000000000000000000000e+35
  2140:     null,  //117
  2141:     null,  //118
  2142:     new EFP (P,    119, 0xc097ce7bc90715b3L, 0x4b9f100L << 36),  //=10^36=1.00000000000000000000000000000e+36
  2143:     null,  //120
  2144:     null,  //121
  2145:     new EFP (P,    122, 0xf0bdc21abb48db20L, 0x1e86d40L << 36),  //=10^37=1.00000000000000000000000000000e+37
  2146:     null,  //123
  2147:     null,  //124
  2148:     null,  //125
  2149:     new EFP (P,    126, 0x96769950b50d88f4L, 0x1314448L << 36),  //=10^38=1.00000000000000000000000000000e+38
  2150:     null,  //127
  2151:     null,  //128
  2152:     new EFP (P,    129, 0xbc143fa4e250eb31L, 0x17d955aL << 36),  //=10^39=1.00000000000000000000000000000e+39
  2153:   };
  2154: 
  2155:   //------------------------------------------------------------------------
  2156:   //log1p
  2157:   //  echo read("efp.gp");efppub(["LOG1P_A","sqrt(2)/2-1"],["LOG1P_B","sqrt(2)-1"]) | gp -q
  2158:   public final EFP      LOG1P_A = new EFP (M,     -2, 0x95f619980c4336f7L, 0x4d04ecaL << 36);  //<sqrt(2)/2-1=-0.292893218813452475599155637895
  2159:   public final EFP      LOG1P_B = new EFP (P,     -2, 0xd413cccfe7799211L, 0x65f626dL << 36);  //>sqrt(2)-1=0.414213562373095048801688724210
  2160: 
  2161:   //------------------------------------------------------------------------
  2162:   //log2
  2163:   //  echo read("efp.gp");eval("f(x)=log((1+x)/(1-x))/log(2)");efpchebyshev("LOG2_C",f,2*sqrt(2)-3,3-2*sqrt(2),27) | gp -q
  2164:   public final EFP      LOG2_C1 = new EFP (P,      1, 0xb8aa3b295c17f0bbL, 0xbe87fedL << 36);  //=2.88539008177792681471984936198
  2165:   public final EFP      LOG2_C3 = new EFP (P,     -1, 0xf6384ee1d01feba4L, 0xfe0ab04L << 36);  //=0.961796693925975604906616477151
  2166:   public final EFP      LOG2_C5 = new EFP (P,     -1, 0x93bb62877cdff3c9L, 0x651237dL << 36);  //=0.577078016355585362943937299454
  2167:   public final EFP      LOG2_C7 = new EFP (P,     -2, 0xd30bb153d6f6c9fbL, 0xeda6121L << 36);  //=0.412198583111132402124303236615
  2168:   public final EFP      LOG2_C9 = new EFP (P,     -2, 0xa42589ebe015469bL, 0xde296e2L << 36);  //=0.320598897975325193627068255683
  2169:   public final EFP     LOG2_C11 = new EFP (P,     -2, 0x864d424ca0127799L, 0x7cdb742L << 36);  //=0.262308189252540677191282011266
  2170:   public final EFP     LOG2_C13 = new EFP (P,     -3, 0xe347ab469770ad93L, 0x0c89676L << 36);  //=0.221953083213393290074079579936
  2171:   public final EFP     LOG2_C15 = new EFP (P,     -3, 0xc4f9d8b532564b9eL, 0x7d50b7aL << 36);  //=0.192359338816990450904061345775
  2172:   public final EFP     LOG2_C17 = new EFP (P,     -3, 0xadcd64b1c6112030L, 0x2abb956L << 36);  //=0.169728825903363689895336947859
  2173:   public final EFP     LOG2_C19 = new EFP (P,     -3, 0x9b81e9e58a334402L, 0x0adf93dL << 36);  //=0.151862768778801240948586652949
  2174:   public final EFP     LOG2_C21 = new EFP (P,     -3, 0x8cb11e7e743a9994L, 0xf74da62L << 36);  //=0.137394405811444109070588133256
  2175:   public final EFP     LOG2_C23 = new EFP (P,     -3, 0x809a15f248e3a311L, 0x83d14aaL << 36);  //=0.125587790406118348750302928355
  2176:   public final EFP     LOG2_C25 = new EFP (P,     -4, 0xe789c1589b85b20fL, 0xbe84fc9L << 36);  //=0.113055716053568431590620272062
  2177:   public final EFP     LOG2_C27 = new EFP (P,     -3, 0x85c8b3f2b1daf78cL, 0x52db8eeL << 36);  //=0.130648433387672262093665382456
  2178:   //  96.81bit
  2179: 
  2180:   //------------------------------------------------------------------------
  2181:   //lgamma
  2182:   //  echo read("efp.gp");n=14;c=vector(n,k,bernfrac(2*k)/(2*k*(2*k-1)));for(k=1,n,efppub([Str("LGAMMA_C",k),Str(c[k])]));efpclose(lngamma,"(x-1/2)*log(x)-x+log(2*Pi)/2+sum(k=1,n,c[k]/x^(2*k-1))",13,100) | gp -q
  2183:   public final EFP    LGAMMA_C1 = new EFP (P,     -4, 0xaaaaaaaaaaaaaaaaL, 0xaaaaaabL << 36);  //>1/12=0.0833333333333333333333333333333
  2184:   public final EFP    LGAMMA_C2 = new EFP (M,     -9, 0xb60b60b60b60b60bL, 0x60b60b6L << 36);  //>-1/360=-0.00277777777777777777777777777778
  2185:   public final EFP    LGAMMA_C3 = new EFP (P,    -11, 0xd00d00d00d00d00dL, 0x00d00d0L << 36);  //<1/1260=7.93650793650793650793650793651e-4
  2186:   public final EFP    LGAMMA_C4 = new EFP (M,    -11, 0x9c09c09c09c09c09L, 0xc09c09cL << 36);  //>-1/1680=-5.95238095238095238095238095238e-4
  2187:   public final EFP    LGAMMA_C5 = new EFP (P,    -11, 0xdca8f158c7f91ab8L, 0x7539c03L << 36);  //<1/1188=8.41750841750841750841750841751e-4
  2188:   public final EFP    LGAMMA_C6 = new EFP (M,    -10, 0xfb5586ccc9e3e40fL, 0xb5586cdL << 36);  //<-691/360360=-0.00191752691752691752691752691753
  2189:   public final EFP    LGAMMA_C7 = new EFP (P,     -8, 0xd20d20d20d20d20dL, 0x20d20d2L << 36);  //<1/156=0.00641025641025641025641025641026
  2190:   public final EFP    LGAMMA_C8 = new EFP (M,     -6, 0xf21436587a9cbee1L, 0x0325477L << 36);  //<-3617/122400=-0.0295506535947712418300653594771
  2191:   public final EFP    LGAMMA_C9 = new EFP (P,     -3, 0xb7f4b1c0f033ffd0L, 0xc3b7f4bL << 36);  //<43867/244188=0.179644372368830573164938490016
  2192:   public final EFP   LGAMMA_C10 = new EFP (M,      0, 0xb23b3808c0f9cf6dL, 0xedce731L << 36);  //>-174611/125400=-1.39243221690590111642743221691
  2193:   public final EFP   LGAMMA_C11 = new EFP (P,      3, 0xd672219167002d3aL, 0x7a9c886L << 36);  //<77683/5796=13.4028640441683919944789510007
  2194:   public final EFP   LGAMMA_C12 = new EFP (M,      7, 0x9cd9292e6660d55bL, 0x3f712ecL << 36);  //<-236364091/1506960=-156.848284626002017306365132452
  2195:   public final EFP   LGAMMA_C13 = new EFP (P,     11, 0x8911a740da740da7L, 0x40da741L << 36);  //>657931/300=2193.10333333333333333333333333
  2196:   public final EFP   LGAMMA_C14 = new EFP (M,     15, 0x8d0cc570e255bf59L, 0xff6eec2L << 36);  //>-3392780147/93960=-36108.7712537249893571732652192
  2197:   //  92.41bit
  2198:   //  echo read("efp.gp");efppub(["LOGTWOPI_2",log(2*Pi)/2]) | gp -q
  2199:   public final EFP   LOGTWOPI_2 = new EFP (P,     -1, 0xeb3f8e4325f5a534L, 0x94bc900L << 36);  //<0.918938533204672741780329736406
  2200: 
  2201:   //------------------------------------------------------------------------
  2202:   //setapery
  2203:   public final EFP[] ROUNDED_APERY = {
  2204:     //  echo read("efp.gp");for(rm=RN,RP,efpmem([zeta(3),rm,strrmf(rm,"ζ(3)")])) | gp -q
  2205:     new EFP (P,      0, 0x99dd0027803109c1L, 0xb8b8ae3L << 36),  //>RN(ζ(3))=1.20205690315959428539973816151
  2206:     new EFP (P,      0, 0x99dd0027803109c1L, 0xb8b8ae2L << 36),  //<RZ(ζ(3))=1.20205690315959428539973816151
  2207:     new EFP (P,      0, 0x99dd0027803109c1L, 0xb8b8ae2L << 36),  //<RM(ζ(3))=1.20205690315959428539973816151
  2208:     new EFP (P,      0, 0x99dd0027803109c1L, 0xb8b8ae3L << 36),  //>RP(ζ(3))=1.20205690315959428539973816151
  2209:   };
  2210: 
  2211:   //------------------------------------------------------------------------
  2212:   //setcatalan
  2213:   public final EFP[] ROUNDED_CATALAN = {
  2214:     //  echo read("efp.gp");for(rm=RN,RP,efpmem([Catalan,rm,strrmf(rm,"G")])) | gp -q
  2215:     new EFP (P,     -1, 0xea7cb89f409ae845L, 0x215822eL << 36),  //<RN(G)=0.915965594177219015054603514932
  2216:     new EFP (P,     -1, 0xea7cb89f409ae845L, 0x215822eL << 36),  //<RZ(G)=0.915965594177219015054603514932
  2217:     new EFP (P,     -1, 0xea7cb89f409ae845L, 0x215822eL << 36),  //<RM(G)=0.915965594177219015054603514932
  2218:     new EFP (P,     -1, 0xea7cb89f409ae845L, 0x215822fL << 36),  //>RP(G)=0.915965594177219015054603514932
  2219:   };
  2220: 
  2221:   //------------------------------------------------------------------------
  2222:   //seteuler
  2223:   public final EFP[] ROUNDED_EULER = {
  2224:     //  echo read("efp.gp");for(rm=RN,RP,efpmem([Euler,rm,strrmf(rm,"γ")])) | gp -q
  2225:     new EFP (P,     -1, 0x93c467e37db0c7a4L, 0xd1be3f8L << 36),  //<RN(γ)=0.577215664901532860606512090082
  2226:     new EFP (P,     -1, 0x93c467e37db0c7a4L, 0xd1be3f8L << 36),  //<RZ(γ)=0.577215664901532860606512090082
  2227:     new EFP (P,     -1, 0x93c467e37db0c7a4L, 0xd1be3f8L << 36),  //<RM(γ)=0.577215664901532860606512090082
  2228:     new EFP (P,     -1, 0x93c467e37db0c7a4L, 0xd1be3f9L << 36),  //>RP(γ)=0.577215664901532860606512090082
  2229:   };
  2230: 
  2231:   //------------------------------------------------------------------------
  2232:   //setnapier
  2233:   public final EFP[] ROUNDED_NAPIER = {
  2234:     //  echo read("efp.gp");for(rm=RN,RP,efpmem([exp(1),rm,strrmf(rm,"e")])) | gp -q
  2235:     new EFP (P,      1, 0xadf85458a2bb4a9aL, 0xafdc562L << 36),  //<RN(e)=2.71828182845904523536028747135
  2236:     new EFP (P,      1, 0xadf85458a2bb4a9aL, 0xafdc562L << 36),  //<RZ(e)=2.71828182845904523536028747135
  2237:     new EFP (P,      1, 0xadf85458a2bb4a9aL, 0xafdc562L << 36),  //<RM(e)=2.71828182845904523536028747135
  2238:     new EFP (P,      1, 0xadf85458a2bb4a9aL, 0xafdc563L << 36),  //>RP(e)=2.71828182845904523536028747135
  2239:   };
  2240: 
  2241:   //------------------------------------------------------------------------
  2242:   //setpi
  2243:   public final EFP[] ROUNDED_PI = {
  2244:     //  echo read("efp.gp");for(rm=RN,RP,efpmem([Pi,rm,strrmf(rm,"π")])) | gp -q
  2245:     new EFP (P,      1, 0xc90fdaa22168c234L, 0xc4c6629L << 36),  //>RN(π)=3.14159265358979323846264338328
  2246:     new EFP (P,      1, 0xc90fdaa22168c234L, 0xc4c6628L << 36),  //<RZ(π)=3.14159265358979323846264338328
  2247:     new EFP (P,      1, 0xc90fdaa22168c234L, 0xc4c6628L << 36),  //<RM(π)=3.14159265358979323846264338328
  2248:     new EFP (P,      1, 0xc90fdaa22168c234L, 0xc4c6629L << 36),  //>RP(π)=3.14159265358979323846264338328
  2249:   };
  2250:   public final EFP[] ROUNDED_NEGPI = {
  2251:     //  echo read("efp.gp");for(rm=RN,RP,efpmem([-Pi,rm,strrmf(rm,"-π")])) | gp -q
  2252:     new EFP (M,      1, 0xc90fdaa22168c234L, 0xc4c6629L << 36),  //<RN(-π)=-3.14159265358979323846264338328
  2253:     new EFP (M,      1, 0xc90fdaa22168c234L, 0xc4c6628L << 36),  //>RZ(-π)=-3.14159265358979323846264338328
  2254:     new EFP (M,      1, 0xc90fdaa22168c234L, 0xc4c6629L << 36),  //<RM(-π)=-3.14159265358979323846264338328
  2255:     new EFP (M,      1, 0xc90fdaa22168c234L, 0xc4c6628L << 36),  //>RP(-π)=-3.14159265358979323846264338328
  2256:   };
  2257:   public final EFP[] ROUNDED_PI_2 = {
  2258:     //  echo read("efp.gp");for(rm=RN,RP,efpmem([Pi/2,rm,strrmf(rm,"π/2")])) | gp -q
  2259:     new EFP (P,      0, 0xc90fdaa22168c234L, 0xc4c6629L << 36),  //>RN(π/2)=1.57079632679489661923132169164
  2260:     new EFP (P,      0, 0xc90fdaa22168c234L, 0xc4c6628L << 36),  //<RZ(π/2)=1.57079632679489661923132169164
  2261:     new EFP (P,      0, 0xc90fdaa22168c234L, 0xc4c6628L << 36),  //<RM(π/2)=1.57079632679489661923132169164
  2262:     new EFP (P,      0, 0xc90fdaa22168c234L, 0xc4c6629L << 36),  //>RP(π/2)=1.57079632679489661923132169164
  2263:   };
  2264:   public final EFP[] ROUNDED_NEGPI_2 = {
  2265:     //  echo read("efp.gp");for(rm=RN,RP,efpmem([-Pi/2,rm,strrmf(rm,"-π/2")])) | gp -q
  2266:     new EFP (M,      0, 0xc90fdaa22168c234L, 0xc4c6629L << 36),  //<RN(-π/2)=-1.57079632679489661923132169164
  2267:     new EFP (M,      0, 0xc90fdaa22168c234L, 0xc4c6628L << 36),  //>RZ(-π/2)=-1.57079632679489661923132169164
  2268:     new EFP (M,      0, 0xc90fdaa22168c234L, 0xc4c6629L << 36),  //<RM(-π/2)=-1.57079632679489661923132169164
  2269:     new EFP (M,      0, 0xc90fdaa22168c234L, 0xc4c6628L << 36),  //>RP(-π/2)=-1.57079632679489661923132169164
  2270:   };
  2271: 
  2272:   //------------------------------------------------------------------------
  2273:   //sinh
  2274:   //  echo read("efp.gp");efpchebyshev("SINH_C",sinh,-1/8,1/8,13) | gp -q
  2275:   public final EFP      SINH_C1 = new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36);  //=1.00000000000000000000000000000
  2276:   public final EFP      SINH_C3 = new EFP (P,     -3, 0xaaaaaaaaaaaaaaaaL, 0xaaa8d3bL << 36);  //=0.166666666666666666666666286213
  2277:   public final EFP      SINH_C5 = new EFP (P,     -7, 0x8888888888888888L, 0xd801ef0L << 36);  //=0.00833333333333333333359629146849
  2278:   public final EFP      SINH_C7 = new EFP (P,    -13, 0xd00d00d00d00b865L, 0xe08a011L << 36);  //=1.98412698412698332559486447243e-4
  2279:   public final EFP      SINH_C9 = new EFP (P,    -19, 0xb8ef1d2ab9d6b01dL, 0x54d1cf9L << 36);  //=2.75573192241112619181294637312e-6
  2280:   public final EFP     SINH_C11 = new EFP (P,    -26, 0xd7322aa84ab102a5L, 0xf1b3e2aL << 36);  //=2.50521073350812546986376674718e-8
  2281:   public final EFP     SINH_C13 = new EFP (P,    -33, 0xb09ecdc339d62e71L, 0x8115862L << 36);  //=1.60635251803005018933289429222e-10
  2282:   //  92.06bit
  2283: 
  2284:   //------------------------------------------------------------------------
  2285:   //sqrt1pm1
  2286:   //  echo read("efp.gp");eval("sqrt1pm1(x)=sqrt(1+x)-1");efppoly("SQRT1PM1_C",sqrt1pm1,sum(n=1,11,eval("efp((-1)^(n-1)/2^(2*n-1)*factorial(2*n-2)/factorial(n-1)/factorial(n))*x^n")),-1/256,1/256) | gp -q
  2287:   public final EFP  SQRT1PM1_C1 = new EFP (P,     -1, 0x8000000000000000L, 0x0000000L << 36);  //=0.500000000000000000000000000000
  2288:   public final EFP  SQRT1PM1_C2 = new EFP (M,     -3, 0x8000000000000000L, 0x0000000L << 36);  //=-0.125000000000000000000000000000
  2289:   public final EFP  SQRT1PM1_C3 = new EFP (P,     -4, 0x8000000000000000L, 0x0000000L << 36);  //=0.0625000000000000000000000000000
  2290:   public final EFP  SQRT1PM1_C4 = new EFP (M,     -5, 0xa000000000000000L, 0x0000000L << 36);  //=-0.0390625000000000000000000000000
  2291:   public final EFP  SQRT1PM1_C5 = new EFP (P,     -6, 0xe000000000000000L, 0x0000000L << 36);  //=0.0273437500000000000000000000000
  2292:   public final EFP  SQRT1PM1_C6 = new EFP (M,     -6, 0xa800000000000000L, 0x0000000L << 36);  //=-0.0205078125000000000000000000000
  2293:   public final EFP  SQRT1PM1_C7 = new EFP (P,     -6, 0x8400000000000000L, 0x0000000L << 36);  //=0.0161132812500000000000000000000
  2294:   public final EFP  SQRT1PM1_C8 = new EFP (M,     -7, 0xd680000000000000L, 0x0000000L << 36);  //=-0.0130920410156250000000000000000
  2295:   public final EFP  SQRT1PM1_C9 = new EFP (P,     -7, 0xb2c0000000000000L, 0x0000000L << 36);  //=0.0109100341796875000000000000000
  2296:   public final EFP SQRT1PM1_C10 = new EFP (M,     -7, 0x97f0000000000000L, 0x0000000L << 36);  //=-0.00927352905273437500000000000000
  2297:   public final EFP SQRT1PM1_C11 = new EFP (P,     -7, 0x8338000000000000L, 0x0000000L << 36);  //=0.00800895690917968750000000000000
  2298:   //  94.15bit
  2299: 
  2300:   //------------------------------------------------------------------------
  2301:   //tan
  2302:   //  echo read("efp.gp");efpchebyshev("TAN_C",tan,-Pi/8,Pi/8,33) | gp -q
  2303:   public final EFP       TAN_C1 = new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36);  //=1.00000000000000000000000000000
  2304:   public final EFP       TAN_C3 = new EFP (P,     -2, 0xaaaaaaaaaaaaaaaaL, 0xaaaaa29L << 36);  //=0.333333333333333333333333320240
  2305:   public final EFP       TAN_C5 = new EFP (P,     -3, 0x8888888888888888L, 0x88a184aL << 36);  //=0.133333333333333333333338500055
  2306:   public final EFP       TAN_C7 = new EFP (P,     -5, 0xdd0dd0dd0dd0dd0dL, 0x88b7614L << 36);  //=0.0539682539682539682530133941980
  2307:   public final EFP       TAN_C9 = new EFP (P,     -6, 0xb327a4416087cfd4L, 0xf296a40L << 36);  //=0.0218694885361552029227142001132
  2308:   public final EFP      TAN_C11 = new EFP (P,     -7, 0x91371aaf3611c538L, 0x2426582L << 36);  //=0.00886323552990218979030206294531
  2309:   public final EFP      TAN_C13 = new EFP (P,     -9, 0xeb69e870ac055209L, 0xe907d72L << 36);  //=0.00359212803657279090096708386671
  2310:   public final EFP      TAN_C15 = new EFP (P,    -10, 0xbed1b229560565dcL, 0x00f1ae8L << 36);  //=0.00145583438704125904461672464275
  2311:   public final EFP      TAN_C17 = new EFP (P,    -11, 0x9aac124127c7ff13L, 0xd521318L << 36);  //=5.90027441184109978354508200940e-4
  2312:   public final EFP      TAN_C19 = new EFP (P,    -13, 0xfabebb506d37becdL, 0x7712cf3L << 36);  //=2.39129110038142690434570082910e-4
  2313:   public final EFP      TAN_C21 = new EFP (P,    -14, 0xcb3f13fd9e491aeeL, 0xb4ecd04L << 36);  //=9.69154352110963087881307906904e-5
  2314:   public final EFP      TAN_C23 = new EFP (P,    -15, 0xa4be2f633cfa3709L, 0x2c90e93L << 36);  //=3.92777706570966668331421947349e-5
  2315:   public final EFP      TAN_C25 = new EFP (P,    -16, 0x859266daac37850cL, 0xcb7028bL << 36);  //=1.59230091488831402827144234198e-5
  2316:   public final EFP      TAN_C27 = new EFP (P,    -18, 0xd7bbef57337218a7L, 0x4e73cafL << 36);  //=6.42937781805301206613497744639e-6
  2317:   public final EFP      TAN_C29 = new EFP (P,    -19, 0xb53ca49c91cc2ce0L, 0x289f9c2L << 36);  //=2.70064006408567688822953124006e-6
  2318:   public final EFP      TAN_C31 = new EFP (P,    -21, 0xe1a12ebdc4e0aba8L, 0x6c3a02cL << 36);  //=8.40535832440159769242845888336e-7
  2319:   public final EFP      TAN_C33 = new EFP (P,    -21, 0xc9eb997dffc9ad78L, 0x01e7a8fL << 36);  //=7.52211775090032809509059318805e-7
  2320:   //  96.07bit
  2321:   //  echo read("efp.gp");efpchebyshev("TAN7_C",tan,-Pi/256,Pi/256,11) | gp -q
  2322:   public final EFP      TAN7_C1 = new EFP (P,     -1, 0xffffffffffffffffL, 0xfffffffL << 36);  //=0.999999999999999999999999999798
  2323:   public final EFP      TAN7_C3 = new EFP (P,     -2, 0xaaaaaaaaaaaaaaaaL, 0xaae677dL << 36);  //=0.333333333333333333333358066592
  2324:   public final EFP      TAN7_C5 = new EFP (P,     -3, 0x8888888888888827L, 0x9679788L << 36);  //=0.133333333333333332019476238145
  2325:   public final EFP      TAN7_C7 = new EFP (P,     -5, 0xdd0dd0dd0e579281L, 0x2b6ed88L << 36);  //=0.0539682539682838796143366171397
  2326:   public final EFP      TAN7_C9 = new EFP (P,     -6, 0xb327a413e1bf5c5dL, 0x5ebd854L << 36);  //=0.0218694882051337203598644737927
  2327:   public final EFP     TAN7_C11 = new EFP (P,     -7, 0x913e7ab6529ea4edL, 0x6ea7f3bL << 36);  //=0.00886499389279463946555596271447
  2328:   //  92.00bit
  2329:   public final EFP[] TAN7_T = {
  2330:     //  echo read("efp.gp");for(n=0,63,efpmem([Str("tan(",n,"*Pi/128)")])) | gp -q
  2331:     new EFP (),  //=tan(0*Pi/128)=0.00000000000000000000000000000
  2332:     new EFP (P,     -6, 0xc91a3123d48f7fddL, 0x894dd4bL << 36),  //>tan(1*Pi/128)=0.0245486221089254441045797539609
  2333:     new EFP (P,     -5, 0xc9393c51d88b101aL, 0xda13cefL << 36),  //>tan(2*Pi/128)=0.0491268497694672541053433212713
  2334:     new EFP (P,     -4, 0x9711ce67f9c18b0fL, 0x459611fL << 36),  //<tan(3*Pi/128)=0.0737644315224492888923977217788
  2335:     new EFP (P,     -4, 0xc9b5dc62d96d130fL, 0xa0a9ed1L << 36),  //<tan(4*Pi/128)=0.0984914033571642530771975212913
  2336:     new EFP (P,     -4, 0xfc98c1d46dcf46edL, 0xdf92d54L << 36),  //>tan(5*Pi/128)=0.123338236136738677947004130613
  2337:     new EFP (P,     -3, 0x97e5639d3032012cL, 0xfb5a747L << 36),  //>tan(6*Pi/128)=0.148335987538347428753676511487
  2338:     new EFP (P,     -3, 0xb1ae4c867069ae62L, 0x1454a67L << 36),  //<tan(7*Pi/128)=0.173516460137855760223211669841
  2339:     new EFP (P,     -3, 0xcbafaf02a98ac03dL, 0xeba6ce9L << 36),  //>tan(8*Pi/128)=0.198912367379658006911597622645
  2340:     new EFP (P,     -3, 0xe5f2675a5a679294L, 0xb7c658cL << 36),  //<tan(9*Pi/128)=0.224557509317129320242538359449
  2341:     new EFP (P,     -2, 0x803fd3ac3135715aL, 0x6d6c3c9L << 36),  //>tan(10*Pi/128)=0.250486960191305461595702160125
  2342:     new EFP (P,     -2, 0x8db081e9acbf49cbL, 0xda4f636L << 36),  //<tan(11*Pi/128)=0.276737270140414338944617036500
  2343:     new EFP (P,     -2, 0x9b5041aae31ede28L, 0xfb2e402L << 36),  //<tan(12*Pi/128)=0.303346683607342391675883946941
  2344:     new EFP (P,     -2, 0xa924570b80d8bb7dL, 0x2ec70f1L << 36),  //>tan(13*Pi/128)=0.330355377344333924545492908196
  2345:     new EFP (P,     -2, 0xb7324fbebc324978L, 0xe945dc4L << 36),  //>tan(14*Pi/128)=0.357805721314524104672487743774
  2346:     new EFP (P,     -2, 0xc5800cb59e810e8cL, 0xd859b1fL << 36),  //>tan(15*Pi/128)=0.385742566271121235453424624094
  2347:     new EFP (P,     -2, 0xd413cccfe7799211L, 0x65f626dL << 36),  //>tan(16*Pi/128)=0.414213562373095048801688724210
  2348:     new EFP (P,     -2, 0xe2f438c2f33db07fL, 0xd5fe854L << 36),  //>tan(17*Pi/128)=0.443269513890864334105794704813
  2349:     new EFP (P,     -2, 0xf228706939f3d282L, 0xa45e2bdL << 36),  //>tan(18*Pi/128)=0.472964775891319928124438237973
  2350:     new EFP (P,     -1, 0x80dc0cdad3e7ba17L, 0xf9dd77dL << 36),  //<tan(19*Pi/128)=0.503357699799294262733245622354
  2351:     new EFP (P,     -1, 0x88d5b8c841a75c35L, 0x36865c3L << 36),  //<tan(20*Pi/128)=0.534511135950791641089685961295
  2352:     new EFP (P,     -1, 0x9105af7823c1286bL, 0xb5bee4cL << 36),  //<tan(21*Pi/128)=0.566493002730343981076271533491
  2353:     new EFP (P,     -1, 0x9970c44823ffe5deL, 0x977bc33L << 36),  //>tan(22*Pi/128)=0.599376933681923766271389869014
  2354:     new EFP (P,     -1, 0xa21c36dce72ed4b0L, 0x5750623L << 36),  //<tan(23*Pi/128)=0.633243016177569127534323438301
  2355:     new EFP (P,     -1, 0xab0dc155bfcc82f5L, 0x18a42e5L << 36),  //<tan(24*Pi/128)=0.668178637919298919997757686523
  2356:     new EFP (P,     -1, 0xb44ba8a3a8edb143L, 0x9bc2d44L << 36),  //>tan(25*Pi/128)=0.704279460865044244278980120940
  2357:     new EFP (P,     -1, 0xbddccf694c8674abL, 0x158e376L << 36),  //<tan(26*Pi/128)=0.741650546272035369581266691172
  2358:     new EFP (P,     -1, 0xc7c8cbdfc2f75687L, 0x408e56bL << 36),  //>tan(27*Pi/128)=0.780407659653943632354200451174
  2359:     new EFP (P,     -1, 0xd218015721427e59L, 0x247f018L << 36),  //<tan(28*Pi/128)=0.820678790828660330972281985331
  2360:     new EFP (P,     -1, 0xdcd3be0c60d7916fL, 0xc7e578dL << 36),  //<tan(29*Pi/128)=0.862605932256739891215212659727
  2361:     new EFP (P,     -1, 0xe8065e39c269718dL, 0xcad85e6L << 36),  //<tan(30*Pi/128)=0.906347169019147157946142717269
  2362:     new EFP (P,     -1, 0xf3bb757e48b83322L, 0xbd576feL << 36),  //<tan(31*Pi/128)=0.952079146700925348585664892261
  2363:     new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36),  //=tan(32*Pi/128)=1.00000000000000000000000000000
  2364:     new EFP (P,      0, 0x86714e8441e4ca93L, 0x0c4cf4eL << 36),  //<tan(33*Pi/128)=1.05033284623985985679635153480
  2365:     new EFP (P,      0, 0x8d39eaa93c625b28L, 0xd9816cdL << 36),  //<tan(34*Pi/128)=1.10332997573347566410053775985
  2366:     new EFP (P,      0, 0x946337ed7c784903L, 0x22c9598L << 36),  //<tan(35*Pi/128)=1.15927790733343474872256568270
  2367:     new EFP (P,      0, 0x9bf7ec6c3b03ef3cL, 0x0d29346L << 36),  //<tan(36*Pi/128)=1.21850352558797634479547723062
  2368:     new EFP (P,      0, 0xa4044fc5fa1663f0L, 0xd6fd49aL << 36),  //>tan(37*Pi/128)=1.28138158003655455554560477142
  2369:     new EFP (P,      0, 0xac96888a17d2a96aL, 0x085e3bcL << 36),  //<tan(38*Pi/128)=1.34834391348672015293303458505
  2370:     new EFP (P,      0, 0xb5befc31328ffd5eL, 0x4284584L << 36),  //>tan(39*Pi/128)=1.41989090349409245362395560849
  2371:     new EFP (P,      0, 0xbf90c712d3a30a83L, 0x3f4d2a9L << 36),  //<tan(40*Pi/128)=1.49660576266548901760113513494
  2372:     new EFP (P,      0, 0xca2253a310915399L, 0x7dd7470L << 36),  //<tan(41*Pi/128)=1.57917256796020898378319991425
  2373:     new EFP (P,      0, 0xd58e1aec53a74f24L, 0x82443ddL << 36),  //>tan(42*Pi/128)=1.66839920558350704845076179161
  2374:     new EFP (P,      0, 0xe1f39c0435e07a14L, 0x725b359L << 36),  //>tan(43*Pi/128)=1.76524687009419151361905127152
  2375:     new EFP (P,      0, 0xef789db9e0a0310fL, 0xb3e75c7L << 36),  //<tan(44*Pi/128)=1.87086841178938948108520133434
  2376:     new EFP (P,      0, 0xfe4ad5d6b67a51b7L, 0x127cf35L << 36),  //>tan(45*Pi/128)=1.98665879234336500189577900470
  2377:     new EFP (P,      1, 0x87510eb8b7dfb97cL, 0xe6cb464L << 36),  //>tan(46*Pi/128)=2.11432235754864059006900220864
  2378:     new EFP (P,      1, 0x9061b6353f9c6ed6L, 0xe02bffdL << 36),  //<tan(47*Pi/128)=2.25596385192915864999808013935
  2379:     new EFP (P,      1, 0x9a827999fcef3242L, 0x2cbec4eL << 36),  //>tan(48*Pi/128)=2.41421356237309504880168872421
  2380:     new EFP (P,      1, 0xa5e9ec3ff0327cfaL, 0x748ca31L << 36),  //<tan(49*Pi/128)=2.59240251773807256365450014380
  2381:     new EFP (P,      1, 0xb2de3664128a386bL, 0x2a51effL << 36),  //>tan(50*Pi/128)=2.79481277249047679426344220502
  2382:     new EFP (P,      1, 0xc1bb136b87edc0d9L, 0xae371daL << 36),  //<tan(51*Pi/128)=3.02704320431777423041156207831
  2383:     new EFP (P,      1, 0xd2facf483006e648L, 0x5eb2f29L << 36),  //<tan(52*Pi/128)=3.29655820893832042687815421683
  2384:     new EFP (P,      1, 0xe7442b29893f385dL, 0xfd8e2a3L << 36),  //<tan(53*Pi/128)=3.61353568130742843584614061971
  2385:     new EFP (P,      1, 0xff80982f66c6df3bL, 0x0194e40L << 36),  //<tan(54*Pi/128)=3.99222378377008442376610482881
  2386:     new EFP (P,      2, 0x8e80a1f38ab2f611L, 0x8c89790L << 36),  //<tan(55*Pi/128)=4.45320222441441050038054277672
  2387:     new EFP (P,      2, 0xa0dff712123b8844L, 0x1c1bfb5L << 36),  //>tan(56*Pi/128)=5.02733949212584810451497507106
  2388:     new EFP (P,      2, 0xb86ba8c8460d85deL, 0x3af4952L << 36),  //<tan(57*Pi/128)=5.76314200511880934875009607987
  2389:     new EFP (P,      2, 0xd7b9fa6519887651L, 0xc68dc64L << 36),  //>tan(58*Pi/128)=6.74145240541498828250998494514
  2390:     new EFP (P,      3, 0x81b97d9b5c3f0e2bL, 0x5c8997bL << 36),  //>tan(59*Pi/128)=8.10778580367690752547921378823
  2391:     new EFP (P,      3, 0xa27362cad7ee626aL, 0x3b5d4f3L << 36),  //>tan(60*Pi/128)=10.1531703876088604621071476634
  2392:     new EFP (P,      3, 0xd8e81e01e97bf967L, 0xe518f26L << 36),  //>tan(61*Pi/128)=13.5566692423524258539123676121
  2393:     new EFP (P,      4, 0xa2d7ff6900daa7f2L, 0x48ca591L << 36),  //>tan(62*Pi/128)=20.3554676249871881783196386481
  2394:     new EFP (P,      5, 0xa2f122af255539e2L, 0x447b82dL << 36),  //>tan(63*Pi/128)=40.7354838720833018007438570502
  2395:   };  //TAN7_T
  2396:   //  echo read("efp.gp");efppub(["TAN7_X",Pi/256],["TAN7_Y",128/Pi]) | gp -q
  2397:   public final EFP       TAN7_X = new EFP (P,     -7, 0xc90fdaa22168c234L, 0xc4c6629L << 36);  //>0.0122718463030851298377447007159
  2398:   public final EFP       TAN7_Y = new EFP (P,      5, 0xa2f9836e4e441529L, 0xfc2757dL << 36);  //<40.7436654315252059568342434234
  2399:   //  echo read("efp.gp");efppub2(["TAN7_Z",Pi/128]) | gp -q
  2400:   public final EFP       TAN7_Z = new EFP (P,     -6, 0xc90fdaa22168c234L, 0xc4c6629L << 36);  //>0.0245436926061702596754894014319
  2401:   public final EFP      TAN7_ZA = new EFP (M,    -99, 0x8fe47c65dadfb63eL, 0xeeb3067L << 36);  //>-1.77361228242534392160702072478e-30
  2402:   //  echo read("efp.gp");efpchebyshev("TAN8_C",tan,-1/8,1/8,21) | gp -q
  2403:   public final EFP      TAN8_C1 = new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36);  //=1.00000000000000000000000000000
  2404:   public final EFP      TAN8_C3 = new EFP (P,     -2, 0xaaaaaaaaaaaaaaaaL, 0xaaaaa02L << 36);  //=0.333333333333333333333333316302
  2405:   public final EFP      TAN8_C5 = new EFP (P,     -3, 0x8888888888888888L, 0x8911d7aL << 36);  //=0.133333333333333333333361728159
  2406:   public final EFP      TAN8_C7 = new EFP (P,     -5, 0xdd0dd0dd0dd0dd07L, 0x61e9558L << 36);  //=0.0539682539682539682321710253282
  2407:   public final EFP      TAN8_C9 = new EFP (P,     -6, 0xb327a4416087e508L, 0x1c05687L << 36);  //=0.0218694885361552121166839881208
  2408:   public final EFP     TAN8_C11 = new EFP (P,     -7, 0x91371aaf35e647d2L, 0x9bd741cL << 36);  //=0.00886323552989977561974347061451
  2409:   public final EFP     TAN8_C13 = new EFP (P,     -9, 0xeb69e8711de22b89L, 0x087ca38L << 36);  //=0.00359212803697731245050214719004
  2410:   public final EFP     TAN8_C15 = new EFP (P,    -10, 0xbed1b1c7d2310830L, 0x871a5a7L << 36);  //=0.00145583434269658967823487137542
  2411:   public final EFP     TAN8_C17 = new EFP (P,    -11, 0x9aac48a4e5208639L, 0x1e07899L << 36);  //=5.90030607075966038694572991909e-4
  2412:   public final EFP     TAN8_C19 = new EFP (P,    -13, 0xfa98b158590773f4L, 0xfa72a4eL << 36);  //=2.38987403937913425869285486804e-4
  2413:   public final EFP     TAN8_C21 = new EFP (P,    -14, 0xd2cd5a371c03b30eL, 0x42cac1cL << 36);  //=1.00518301880738120215681257530e-4
  2414:   //  97.78bit
  2415: 
  2416:   //------------------------------------------------------------------------
  2417:   //tanh
  2418:   //  echo read("efp.gp");efpchebyshev("TANH_C",tanh,-1/4,1/4,27) | gp -q
  2419:   public final EFP      TANH_C1 = new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36);  //=1.00000000000000000000000000000
  2420:   public final EFP      TANH_C3 = new EFP (M,     -2, 0xaaaaaaaaaaaaaaaaL, 0xaaaaa63L << 36);  //=-0.333333333333333333333333326097
  2421:   public final EFP      TANH_C5 = new EFP (P,     -3, 0x8888888888888888L, 0x88710efL << 36);  //=0.133333333333333333333328478820
  2422:   public final EFP      TANH_C7 = new EFP (M,     -5, 0xdd0dd0dd0dd0dd0dL, 0x5eb1c0fL << 36);  //=-0.0539682539682539682524572379576
  2423:   public final EFP      TANH_C9 = new EFP (P,     -6, 0xb327a4416087cefcL, 0x3226807L << 36);  //=0.0218694885361552025555225187555
  2424:   public final EFP     TANH_C11 = new EFP (M,     -7, 0x91371aaf36115c72L, 0x1057753L << 36);  //=-0.00886323552990216707111881201890
  2425:   public final EFP     TANH_C13 = new EFP (P,     -9, 0xeb69e870ab51ac87L, 0xbc93275L << 36);  //=0.00359212803657029780471621830554
  2426:   public final EFP     TANH_C15 = new EFP (M,    -10, 0xbed1b2291c9448e3L, 0x025162cL << 36);  //=-0.00145583438693922182445491583494
  2427:   public final EFP     TANH_C17 = new EFP (P,    -11, 0x9aac122e2d563679L, 0x7f53bd9L << 36);  //=5.90027436868944449269862181218e-4
  2428:   public final EFP     TANH_C19 = new EFP (M,    -13, 0xfabeb45554b7f61dL, 0xed9a4e5L << 36);  //=-2.39129008453513280762151644074e-4
  2429:   public final EFP     TANH_C21 = new EFP (P,    -14, 0xcb3e00a83f1f1703L, 0x594e12fL << 36);  //=9.69134318963417667915644434482e-5
  2430:   public final EFP     TANH_C23 = new EFP (M,    -15, 0xa4a40e3c50e76340L, 0x922c2ccL << 36);  //=-3.92534356637388369814427537735e-5
  2431:   public final EFP     TANH_C25 = new EFP (P,    -16, 0x83c53e40035eb57fL, 0x80a5513L << 36);  //=1.57082654369358742080398893111e-5
  2432:   public final EFP     TANH_C27 = new EFP (M,    -18, 0xb47b24ce1d988d76L, 0xa0271b7L << 36);  //=-5.37875385140937293082445934922e-6
  2433:   //  97.70bit
  2434: 
  2435:   //------------------------------------------------------------------------
  2436:   //toString
  2437:   public final EFP[] EFP_TEN_P16QR = {
  2438:     //  echo read("efp.gp");for(i=0,50,q=eval("i>>4");r=bitand(i,15);efpmem([Str("10^(16^",q,"*",r,")")])) | gp -q
  2439:     new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36),  //=10^(16^0*0)=1.00000000000000000000000000000
  2440:     new EFP (P,      3, 0xa000000000000000L, 0x0000000L << 36),  //=10^(16^0*1)=10.0000000000000000000000000000
  2441:     new EFP (P,      6, 0xc800000000000000L, 0x0000000L << 36),  //=10^(16^0*2)=100.000000000000000000000000000
  2442:     new EFP (P,      9, 0xfa00000000000000L, 0x0000000L << 36),  //=10^(16^0*3)=1000.00000000000000000000000000
  2443:     new EFP (P,     13, 0x9c40000000000000L, 0x0000000L << 36),  //=10^(16^0*4)=10000.0000000000000000000000000
  2444:     new EFP (P,     16, 0xc350000000000000L, 0x0000000L << 36),  //=10^(16^0*5)=100000.000000000000000000000000
  2445:     new EFP (P,     19, 0xf424000000000000L, 0x0000000L << 36),  //=10^(16^0*6)=1000000.00000000000000000000000
  2446:     new EFP (P,     23, 0x9896800000000000L, 0x0000000L << 36),  //=10^(16^0*7)=10000000.0000000000000000000000
  2447:     new EFP (P,     26, 0xbebc200000000000L, 0x0000000L << 36),  //=10^(16^0*8)=100000000.000000000000000000000
  2448:     new EFP (P,     29, 0xee6b280000000000L, 0x0000000L << 36),  //=10^(16^0*9)=1000000000.00000000000000000000
  2449:     new EFP (P,     33, 0x9502f90000000000L, 0x0000000L << 36),  //=10^(16^0*10)=10000000000.0000000000000000000
  2450:     new EFP (P,     36, 0xba43b74000000000L, 0x0000000L << 36),  //=10^(16^0*11)=100000000000.000000000000000000
  2451:     new EFP (P,     39, 0xe8d4a51000000000L, 0x0000000L << 36),  //=10^(16^0*12)=1000000000000.00000000000000000
  2452:     new EFP (P,     43, 0x9184e72a00000000L, 0x0000000L << 36),  //=10^(16^0*13)=10000000000000.0000000000000000
  2453:     new EFP (P,     46, 0xb5e620f480000000L, 0x0000000L << 36),  //=10^(16^0*14)=100000000000000.000000000000000
  2454:     new EFP (P,     49, 0xe35fa931a0000000L, 0x0000000L << 36),  //=10^(16^0*15)=1000000000000000.00000000000000
  2455:     new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36),  //=10^(16^1*0)=1.00000000000000000000000000000
  2456:     new EFP (P,     53, 0x8e1bc9bf04000000L, 0x0000000L << 36),  //=10^(16^1*1)=10000000000000000.0000000000000
  2457:     new EFP (P,    106, 0x9dc5ada82b70b59dL, 0xf020000L << 36),  //=10^(16^1*2)=1.00000000000000000000000000000e+32
  2458:     new EFP (P,    159, 0xaf298d050e4395d6L, 0x9670b13L << 36),  //>10^(16^1*3)=1.00000000000000000000000000000e+48
  2459:     new EFP (P,    212, 0xc2781f49ffcfa6d5L, 0x3cbf6b7L << 36),  //<10^(16^1*4)=1.00000000000000000000000000000e+64
  2460:     new EFP (P,    265, 0xd7e77a8f87daf7fbL, 0xdc33746L << 36),  //>10^(16^1*5)=1.00000000000000000000000000000e+80
  2461:     new EFP (P,    318, 0xefb3ab16c59b14a2L, 0xc5cfe95L << 36),  //>10^(16^1*6)=1.00000000000000000000000000000e+96
  2462:     new EFP (P,    372, 0x850fadc09923329eL, 0x03e2cf7L << 36),  //>10^(16^1*7)=1.00000000000000000000000000000e+112
  2463:     new EFP (P,    425, 0x93ba47c980e98cdfL, 0xc66f337L << 36),  //>10^(16^1*8)=1.00000000000000000000000000000e+128
  2464:     new EFP (P,    478, 0xa402b9c5a8d3a6e7L, 0x5f16207L << 36),  //>10^(16^1*9)=1.00000000000000000000000000000e+144
  2465:     new EFP (P,    531, 0xb616a12b7fe617aaL, 0x577b987L << 36),  //>10^(16^1*10)=1.00000000000000000000000000000e+160
  2466:     new EFP (P,    584, 0xca28a291859bbf93L, 0x7d7b8f7L << 36),  //<10^(16^1*11)=1.00000000000000000000000000000e+176
  2467:     new EFP (P,    637, 0xe070f78d3927556aL, 0x85bbe25L << 36),  //<10^(16^1*12)=1.00000000000000000000000000000e+192
  2468:     new EFP (P,    690, 0xf92e0c3537826145L, 0xa7709a5L << 36),  //<10^(16^1*13)=1.00000000000000000000000000000e+208
  2469:     new EFP (P,    744, 0x8a5296ffe33cc92fL, 0x82bd6b7L << 36),  //<10^(16^1*14)=1.00000000000000000000000000000e+224
  2470:     new EFP (P,    797, 0x9991a6f3d6bf1765L, 0xacca6daL << 36),  //<10^(16^1*15)=1.00000000000000000000000000000e+240
  2471:     new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36),  //=10^(16^2*0)=1.00000000000000000000000000000
  2472:     new EFP (P,    850, 0xaa7eebfb9df9de8dL, 0xddbb902L << 36),  //>10^(16^2*1)=1.00000000000000000000000000000e+256
  2473:     new EFP (P,   1700, 0xe319a0aea60e91c6L, 0xcc655c5L << 36),  //<10^(16^2*2)=1.00000000000000000000000000000e+512
  2474:     new EFP (P,   2551, 0x973f9ca8cd00a68cL, 0x6c8d3fdL << 36),  //>10^(16^2*3)=1.00000000000000000000000000000e+768
  2475:     new EFP (P,   3401, 0xc976758681750c17L, 0x650d3d3L << 36),  //>10^(16^2*4)=1.00000000000000000000000000000e+1024
  2476:     new EFP (P,   4252, 0x862c8c0eeb856ecbL, 0x085bccdL << 36),  //<10^(16^2*5)=1.00000000000000000000000000000e+1280
  2477:     new EFP (P,   5102, 0xb2b8353b3993a7e4L, 0x4257ac4L << 36),  //>10^(16^2*6)=1.00000000000000000000000000000e+1536
  2478:     new EFP (P,   5952, 0xee0ddd84924ab88cL, 0x2d4070fL << 36),  //<10^(16^2*7)=1.00000000000000000000000000000e+1792
  2479:     new EFP (P,   6803, 0x9e8b3b5dc53d5de4L, 0xa74d28dL << 36),  //>10^(16^2*8)=1.00000000000000000000000000000e+2048
  2480:     new EFP (P,   7653, 0xd32e203241f4806fL, 0x3f50c80L << 36),  //<10^(16^2*9)=1.00000000000000000000000000000e+2304
  2481:     new EFP (P,   8504, 0x8ca554c020a1f0a6L, 0x5dfed0aL << 36),  //>10^(16^2*10)=1.00000000000000000000000000000e+2560
  2482:     new EFP (P,   9354, 0xbb570a9a9bd977ccL, 0x4c80875L << 36),  //<10^(16^2*11)=1.00000000000000000000000000000e+2816
  2483:     new EFP (P,  10204, 0xf9895d25d88b5a8aL, 0xfdd08c5L << 36),  //>10^(16^2*12)=1.00000000000000000000000000000e+3072
  2484:     new EFP (P,  11055, 0xa630ef7d5699fe45L, 0x50e3660L << 36),  //<10^(16^2*13)=1.00000000000000000000000000000e+3328
  2485:     new EFP (P,  11905, 0xdd5dc8a2bf27f3f7L, 0x95aa119L << 36),  //>10^(16^2*14)=1.00000000000000000000000000000e+3584
  2486:     new EFP (P,  12756, 0x936e07737dc64f6dL, 0x8c474bbL << 36),  //<10^(16^2*15)=1.00000000000000000000000000000e+3840
  2487:     new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36),  //=10^(16^3*0)=1.00000000000000000000000000000
  2488:     new EFP (P,  13606, 0xc46052028a20979aL, 0xc94c154L << 36),  //>10^(16^3*1)=1.00000000000000000000000000000e+4096
  2489:     new EFP (P,  27213, 0x96a3a1d17faf211aL, 0x0c7c289L << 36),  //<10^(16^3*2)=1.00000000000000000000000000000e+8192
  2490:   };
  2491:   public final EFP[] EFP_TEN_M16QR = {
  2492:     //  echo read("efp.gp");for(i=0,50,q=eval("i>>4");r=bitand(i,15);efpmem([Str("10^(-16^",q,"*",r,")")])) | gp -q
  2493:     new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36),  //=10^(-16^0*0)=1.00000000000000000000000000000
  2494:     new EFP (P,     -4, 0xccccccccccccccccL, 0xccccccdL << 36),  //>10^(-16^0*1)=0.100000000000000000000000000000
  2495:     new EFP (P,     -7, 0xa3d70a3d70a3d70aL, 0x3d70a3dL << 36),  //<10^(-16^0*2)=0.0100000000000000000000000000000
  2496:     new EFP (P,    -10, 0x83126e978d4fdf3bL, 0x645a1cbL << 36),  //>10^(-16^0*3)=0.00100000000000000000000000000000
  2497:     new EFP (P,    -14, 0xd1b71758e219652bL, 0xd3c3611L << 36),  //<10^(-16^0*4)=1.00000000000000000000000000000e-4
  2498:     new EFP (P,    -17, 0xa7c5ac471b478423L, 0x0fcf80eL << 36),  //>10^(-16^0*5)=1.00000000000000000000000000000e-5
  2499:     new EFP (P,    -20, 0x8637bd05af6c69b5L, 0xa63f9a5L << 36),  //>10^(-16^0*6)=1.00000000000000000000000000000e-6
  2500:     new EFP (P,    -24, 0xd6bf94d5e57a42bcL, 0x3d32907L << 36),  //<10^(-16^0*7)=1.00000000000000000000000000000e-7
  2501:     new EFP (P,    -27, 0xabcc77118461cefcL, 0xfdc20d3L << 36),  //>10^(-16^0*8)=1.00000000000000000000000000000e-8
  2502:     new EFP (P,    -30, 0x89705f4136b4a597L, 0x31680a9L << 36),  //>10^(-16^0*9)=1.00000000000000000000000000000e-9
  2503:     new EFP (P,    -34, 0xdbe6fecebdedd5beL, 0xb573441L << 36),  //>10^(-16^0*10)=1.00000000000000000000000000000e-10
  2504:     new EFP (P,    -37, 0xafebff0bcb24aafeL, 0xf78f69aL << 36),  //<10^(-16^0*11)=1.00000000000000000000000000000e-11
  2505:     new EFP (P,    -40, 0x8cbccc096f5088cbL, 0xf93f87bL << 36),  //<10^(-16^0*12)=1.00000000000000000000000000000e-12
  2506:     new EFP (P,    -44, 0xe12e13424bb40e13L, 0x2865a5fL << 36),  //<10^(-16^0*13)=1.00000000000000000000000000000e-13
  2507:     new EFP (P,    -47, 0xb424dc35095cd80fL, 0x538484cL << 36),  //<10^(-16^0*14)=1.00000000000000000000000000000e-14
  2508:     new EFP (P,    -50, 0x901d7cf73ab0acd9L, 0x0f9d370L << 36),  //<10^(-16^0*15)=1.00000000000000000000000000000e-15
  2509:     new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36),  //=10^(-16^1*0)=1.00000000000000000000000000000
  2510:     new EFP (P,    -54, 0xe69594bec44de15bL, 0x4c2ebe7L << 36),  //>10^(-16^1*1)=1.00000000000000000000000000000e-16
  2511:     new EFP (P,   -107, 0xcfb11ead453994baL, 0x67de18fL << 36),  //>10^(-16^1*2)=1.00000000000000000000000000000e-32
  2512:     new EFP (P,   -160, 0xbb127c53b17ec159L, 0x5560c02L << 36),  //>10^(-16^1*3)=1.00000000000000000000000000000e-48
  2513:     new EFP (P,   -213, 0xa87fea27a539e9a5L, 0x3f2398dL << 36),  //<10^(-16^1*4)=1.00000000000000000000000000000e-64
  2514:     new EFP (P,   -266, 0x97c560ba6b0919a5L, 0xdccd87aL << 36),  //>10^(-16^1*5)=1.00000000000000000000000000000e-80
  2515:     new EFP (P,   -319, 0x88b402f7fd75539bL, 0x11dbcb0L << 36),  //<10^(-16^1*6)=1.00000000000000000000000000000e-96
  2516:     new EFP (P,   -373, 0xf64335bcf065d37dL, 0x4d4617bL << 36),  //<10^(-16^1*7)=1.00000000000000000000000000000e-112
  2517:     new EFP (P,   -426, 0xddd0467c64bce4a0L, 0xac7cb3fL << 36),  //<10^(-16^1*8)=1.00000000000000000000000000000e-128
  2518:     new EFP (P,   -479, 0xc7caba6e7c5382c8L, 0xfe64a53L << 36),  //>10^(-16^1*9)=1.00000000000000000000000000000e-144
  2519:     new EFP (P,   -532, 0xb3f4e093db73a093L, 0x59ed216L << 36),  //<10^(-16^1*10)=1.00000000000000000000000000000e-160
  2520:     new EFP (P,   -585, 0xa21727db38cb002fL, 0xb8ada01L << 36),  //>10^(-16^1*11)=1.00000000000000000000000000000e-176
  2521:     new EFP (P,   -638, 0x91ff83775423cc06L, 0x7b6306aL << 36),  //<10^(-16^1*12)=1.00000000000000000000000000000e-192
  2522:     new EFP (P,   -691, 0x8380dea93da4bc60L, 0x4247cbaL << 36),  //>10^(-16^1*13)=1.00000000000000000000000000000e-208
  2523:     new EFP (P,   -745, 0xece53cec4a314ebdL, 0xa4f8bf5L << 36),  //<10^(-16^1*14)=1.00000000000000000000000000000e-224
  2524:     new EFP (P,   -798, 0xd5605fcdcf32e1d6L, 0xfb1e4aaL << 36),  //>10^(-16^1*15)=1.00000000000000000000000000000e-240
  2525:     new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36),  //=10^(-16^2*0)=1.00000000000000000000000000000
  2526:     new EFP (P,   -851, 0xc0314325637a1939L, 0xfa91115L << 36),  //<10^(-16^2*1)=1.00000000000000000000000000000e-256
  2527:     new EFP (P,  -1701, 0x9049ee32db23d21cL, 0x7132d33L << 36),  //<10^(-16^2*2)=1.00000000000000000000000000000e-512
  2528:     new EFP (P,  -2552, 0xd8a66d4a505de96bL, 0x5ae1b26L << 36),  //>10^(-16^2*3)=1.00000000000000000000000000000e-768
  2529:     new EFP (P,  -3402, 0xa2a682a5da57c0bdL, 0x87a6016L << 36),  //>10^(-16^2*4)=1.00000000000000000000000000000e-1024
  2530:     new EFP (P,  -4253, 0xf4385d0975edbabeL, 0x1f4bf66L << 36),  //<10^(-16^2*5)=1.00000000000000000000000000000e-1280
  2531:     new EFP (P,  -5103, 0xb759449f52a711b2L, 0x68e1eb7L << 36),  //<10^(-16^2*6)=1.00000000000000000000000000000e-1536
  2532:     new EFP (P,  -5953, 0x89a63ba4c497b50eL, 0x6c83ad1L << 36),  //<10^(-16^2*7)=1.00000000000000000000000000000e-1792
  2533:     new EFP (P,  -6804, 0xceae534f34362de4L, 0x492512dL << 36),  //<10^(-16^2*8)=1.00000000000000000000000000000e-2048
  2534:     new EFP (P,  -7654, 0x9b2a840f28a1638fL, 0xe393a9cL << 36),  //<10^(-16^2*9)=1.00000000000000000000000000000e-2304
  2535:     new EFP (P,  -8505, 0xe8fb7dc2dec0a404L, 0x598eec8L << 36),  //>10^(-16^2*10)=1.00000000000000000000000000000e-2560
  2536:     new EFP (P,  -9355, 0xaee973911228abcaL, 0xe3187c3L << 36),  //<10^(-16^2*11)=1.00000000000000000000000000000e-2816
  2537:     new EFP (P, -10205, 0x8350bf3c91575a87L, 0xe79e237L << 36),  //>10^(-16^2*12)=1.00000000000000000000000000000e-3072
  2538:     new EFP (P, -11056, 0xc52ba8a6aeb15d92L, 0x9e98cbaL << 36),  //>10^(-16^2*13)=1.00000000000000000000000000000e-3328
  2539:     new EFP (P, -11906, 0x9406af8f83fd6265L, 0x4b4de35L << 36),  //>10^(-16^2*14)=1.00000000000000000000000000000e-3584
  2540:     new EFP (P, -12757, 0xde42ff8d37cad87fL, 0x1463ef5L << 36),  //>10^(-16^2*15)=1.00000000000000000000000000000e-3840
  2541:     new EFP (P,      0, 0x8000000000000000L, 0x0000000L << 36),  //=10^(-16^3*0)=1.00000000000000000000000000000
  2542:     new EFP (P, -13607, 0xa6dd04c8d2ce9fdeL, 0x2de3812L << 36),  //<10^(-16^3*1)=1.00000000000000000000000000000e-4096
  2543:     new EFP (P, -27214, 0xd986c20b686da869L, 0x5d1d4feL << 36),  //>10^(-16^3*2)=1.00000000000000000000000000000e-8192
  2544:   };
  2545:   //  echo read("efp.gp");efppub(["TENTO28","10^28"]) | gp -q
  2546:   public final EFP      TENTO28 = new EFP (P,     93, 0x813f3978f8940984L, 0x4000000L << 36);  //=10^28=10000000000000000000000000000.0
  2547: 
  2548: 
  2549: 
  2550:   //========================================================================
  2551:   //$$EFP 92bit浮動小数点数
  2552:   //  class EFP
  2553:   //
  2554:   //  フラグ flg
  2555:   //    bit31  M  -
  2556:   //    bit30  Z  ±0
  2557:   //    bit29  I  ±Inf
  2558:   //    bit28  N  NaN
  2559:   //      flg==P      +x
  2560:   //      flg==M      -x
  2561:   //      flg==(P|Z)  +0
  2562:   //      flg==(M|Z)  -0
  2563:   //      flg==(P|I)  +Inf
  2564:   //      flg==(M|I)  -Inf
  2565:   //      flg==N      NaN
  2566:   //      flg==0      +x
  2567:   //      flg!=0      -x,±0,±Inf,NaN
  2568:   //      flg>=0      +x,+0,+Inf,NaN
  2569:   //      flg<0       -x,-0,-Inf
  2570:   //      flg<<1==0   ±x
  2571:   //      flg<<1!=0   ±0,±Inf,NaN
  2572:   //      flg<<1>=0   ±x,±Inf,NaN
  2573:   //      flg<<1<0    ±0
  2574:   //      flg<<2==0   ±x,±0
  2575:   //      flg<<2!=0   ±Inf,NaN
  2576:   //      flg<<2>=0   ±x,±0,NaN
  2577:   //      flg<<2<0    ±Inf
  2578:   //      flg<<3==0   ±x,±0,±Inf
  2579:   //      flg<<3!=0   NaN
  2580:   //      flg<<3>=0   ±x,±0,±Inf
  2581:   //      flg<<3<0    NaN
  2582:   //    インスタンスのフラグがコンディションコードを兼ねる
  2583:   //    ±0,±Inf,NaNの表現を仮数部に組み込まない理由
  2584:   //      ±0,±Inf,NaNをflg<<1!=0でまとめて分離することで±0,±Inf,NaN以外の処理のオーバーヘッドを減らす
  2585:   //      ±0,±Inf,NaNの仮数部を不定にすることで±0,±Inf,NaNを返す処理を短くする
  2586:   //    -NaNを設けない理由
  2587:   //      例外的な値のためにコードを冗長にしたくない
  2588:   //      doubleの場合
  2589:   //        負符号でNaNの符号が反転しない場合と反転する場合がある
  2590:   //        System.out.printf("%016x\n",Double.doubleToRawLongBits(Double.NaN));
  2591:   //        7ff8000000000000
  2592:   //        System.out.printf("%016x\n",Double.doubleToRawLongBits(-Double.NaN));
  2593:   //        7ff8000000000000
  2594:   //        System.out.printf("%016x\n",Double.doubleToRawLongBits(-Double.longBitsToDouble(0x7ff8000000000000L)));
  2595:   //        fff8000000000000
  2596:   //        加算で片方がNaNのときはその符号が使用される
  2597:   //        System.out.printf("%016x\n",Double.doubleToRawLongBits(Double.longBitsToDouble(0xfff8000000000000L)+0.0));
  2598:   //        fff8000000000000
  2599:   //        System.out.printf("%016x\n",Double.doubleToRawLongBits(0.0+Double.longBitsToDouble(0xfff8000000000000L)));
  2600:   //        fff8000000000000
  2601:   //        加算で両方がNaNのときは後者の符号が使用される
  2602:   //        System.out.printf("%016x\n",Double.doubleToRawLongBits(Double.NaN+Double.longBitsToDouble(0xfff8000000000000L)));
  2603:   //        fff8000000000000
  2604:   //        System.out.printf("%016x\n",Double.doubleToRawLongBits(Double.longBitsToDouble(0xfff8000000000000L)+Double.NaN));
  2605:   //        7ff8000000000000
  2606:   //
  2607:   //  指数部 epp
  2608:   //    符号あり16bit(-32768～32767)
  2609:   //    内部32bit
  2610:   //      高速化のため内部では指数部が符号あり16bitに収まっているかどうかを確認せずに処理を進める
  2611:   //    浮動小数点数の値が1のとき指数部は0
  2612:   //    ±0,±Inf,NaNのときは不定
  2613:   //    下駄履き16bitゼロ拡張ではなくて16bit符号拡張にする理由
  2614:   //      乗算、除算、累乗などで下駄が邪魔にならない
  2615:   //      オーバーフローまたはアンダーフローの判定は(short)epp!=eppでできる
  2616:   //        下駄履き16bitゼロ拡張のときのepp>>16!=0または(char)epp!=eppと比較しても大きく遅くなることはない
  2617:   //
  2618:   //  仮数部 dvl,cvl
  2619:   //    LEN=92bit
  2620:   //      (92bitに限定する必要がない場所では65bit<=LEN<=95bitの範囲で調整できるようにする)
  2621:   //      整数部は1bitで常に1
  2622:   //        ±0,±Inf,NaN以外はすべて正規化数であり、仮数部について非正規化数は存在しない
  2623:   //      小数部は91bit
  2624:   //      2個のlongに左詰めで格納する
  2625:   //      余った領域は0で埋める
  2626:   //      表現できる正規化数の範囲は2^-32768から(2-2^(1-LEN))*2^32767まで
  2627:   //                    2^-32768 = 10^-9864.1508979173358047637961023321875012
  2628:   //        (2-2^(1-92))*2^32767 = 10^9864.1508979173358047637961023320997960
  2629:   //      連続して正確に表現できる整数の範囲は-2^92から2^92まで。10進数で27桁まで
  2630:   //        2^92 = 4951760157141521099596496896
  2631:   //             = 10^27.694759601086269959663978314653358463
  2632:   //      26桁まで出力する
  2633:   //        単一の演算では26桁までは正確であることを期待できる
  2634:   //    ±0,±Inf,NaNのときは不定
  2635:   //    65bit以上にする理由
  2636:   //      64bit以下では超越関数などでextendedの精度を確保できない
  2637:   //    92bit以下にする理由
  2638:   //      乗算を効率よく行える
  2639:   //        32bit,30bit,30bitに3分割して掛けると中間の加算が最大で62bit*2+60bit*3となって64bitに収まるのでキャリーの処理が簡単になる
  2640:   //    91bit以下にする理由
  2641:   //      除算を効率よく行える
  2642:   //        91bitの被除数を右に1bitずらしてから基数2^31で3分割して割ると
  2643:   //        2^29<=被除数の1桁目(30bit)<2^30<=除数の1桁目(31bit)<2^31
  2644:   //        なので3回の操作で92bitまたは93bitの商が得られる
  2645:   //        商に92bit目のguard bitが含まれるので丸めの処理が簡単になる
  2646:   //    整数部を1に固定する(非正規化数を設けない)理由
  2647:   //      非正規化数を設けないことで正規化数の処理のオーバーヘッドを減らす
  2648:   //      float,double,extendedの非正規化数はEFPでは正規化数として表現できる
  2649:   //        extendedの指数部は15bit
  2650:   //
  2651:   //  丸めの処理
  2652:   //    演算結果を最も近い表現可能な値に丸める
  2653:   //    演算結果に最も近い表現可能な値が2つあるときはLSBが0の方(最近接偶数)に丸める
  2654:   //      他の丸めはfloat,double,extendedへ変換するときだけ用いる
  2655:   //    最近接偶数への丸めにする理由
  2656:   //      最近接偶数への丸めは符号を考慮する必要がないので高速
  2657:   //      丸めてから符号反転したときと符号反転してから丸めたときの結果が異なるのは気持ち悪い
  2658:   //    条件
  2659:   //      65bit<=LEN<=95bitであること
  2660:   //      演算結果がze,zd,zc,zbに入っているとする
  2661:   //        ze  指数部
  2662:   //        zd  仮数部の上位(64bit)
  2663:   //        zc  仮数部の下位(1～31bit),guard bit(1bit),round bit(1bit),sticky bit(61～31bit)
  2664:   //        zb  sticky bit(64bit)
  2665:   //    手順
  2666:   //      guard bitが0またはLSBとround bitとsticky bitがすべて0のときは切り捨てる
  2667:   //      guard bitが1かつLSBとround bitとsticky bitのいずれかが0でないときは切り上げて、溢れたときはMSBだけセットして指数部を1増やす
  2668:   //    コード
  2669:   //      if ((zc << LEN - 64 | zb) != 0L) {  //端数が0でないとき
  2670:   //        this.epbFpsr |= X2;  //不正確な結果
  2671:   //        if (zc << LEN - 64 >= 0L || (zc & (LSB | RBM | SBM) | zb) == 0L) {  //guard bitが0またはLSBとround bitとsticky bitがすべて0のとき
  2672:   //          zc &= -LSB;  //切り捨てる
  2673:   //        } else if ((zc = zc + LSB & -LSB) == 0L && ++zd == 0L) {  //切り上げて、溢れたとき
  2674:   //          zd = MSB;  //MSBだけセットして
  2675:   //          ze++;  //指数部を1増やす
  2676:   //        }
  2677:   //      }
  2678:   //
  2679:   //  超越関数の多項式展開
  2680:   //    テイラー展開
  2681:   //        f(x) = sum[n=0..∞]{f'n(a)/n!*(x-a)^n}
  2682:   //      a=0のとき(マクローリン展開)
  2683:   //        f(x) = sum[n=0..∞]{f'n(0)/n!*x^n}
  2684:   //        偶関数の奇数次の係数と奇関数の偶数次の係数は自動的に0になる
  2685:   //    cosの多倍角の公式
  2686:   //        cos(0*t) = 1
  2687:   //        cos(1*t) = cos(t)
  2688:   //        cos(n*t) = 2*cos(t)*cos((n-1)*t)-cos((n-2)*t)
  2689:   //    チェビシェフ多項式
  2690:   //        T(0,x) = 1
  2691:   //        T(1,x) = x
  2692:   //        T(n,x) = 2*x*T(n-1,x)-T(n-2,x)
  2693:   //               = ((x-sqrt(x^2-1))^n+(x+sqrt(x^2-1))^n)/2
  2694:   //      echo for(n=0,10,printf("T(%d,x) = %s\n",n,polchebyshev(n))) | gp -q
  2695:   //        T(0,x) = 1
  2696:   //        T(1,x) = x
  2697:   //        T(2,x) = 2*x^2 - 1
  2698:   //        T(3,x) = 4*x^3 - 3*x
  2699:   //        T(4,x) = 8*x^4 - 8*x^2 + 1
  2700:   //        T(5,x) = 16*x^5 - 20*x^3 + 5*x
  2701:   //        T(6,x) = 32*x^6 - 48*x^4 + 18*x^2 - 1
  2702:   //        T(7,x) = 64*x^7 - 112*x^5 + 56*x^3 - 7*x
  2703:   //        T(8,x) = 128*x^8 - 256*x^6 + 160*x^4 - 32*x^2 + 1
  2704:   //        T(9,x) = 256*x^9 - 576*x^7 + 432*x^5 - 120*x^3 + 9*x
  2705:   //        T(10,x) = 512*x^10 - 1280*x^8 + 1120*x^6 - 400*x^4 + 50*x^2 - 1
  2706:   //    チェビシェフ展開
  2707:   //        f(x) = sum[k=0..∞]{(k==0?1:2)/pi*int[t=0..pi]{cos(k*t)*f(cos(t))}*T(k,x)}
  2708:   //        定義域が[-1,1]なので目的の関数に応じて変数変換を行う
  2709:   //        偶関数の奇数次の係数と奇関数の偶数次の係数は自動的に0になる
  2710:   //      台形積分を用いる場合
  2711:   //        f(x) ≒ sum[k=0..n]{(k==0?1:2)/n*sum[j=0..n]{(j==0||j==n?1/2:1)*cos(pi*j*k/n)*f(cos(pi*j/n))}*T(k,x)}
  2712:   //    テイラー展開vsチェビシェフ展開
  2713:   //      多項式近似の所要時間は項数と各項の次数と係数の有無が同じであれば係数の値は関係ない
  2714:   //      係数の値を調整することで真の値と一致する桁数を増やすことができれば同じ桁数を得るのに必要な項数が少なくて済む分所要時間が短くなる
  2715:   //      無限に続けることが前提のテイラー展開を途中で打ち切った多項式よりも項数を任意に設定できるチェビシェフ展開の方が同じ項数でも真の値と一致する桁数が多くなる
  2716:   //    多項式の次数の選択
  2717:   //      定義域を10000分割して10001箇所すべてで必要なbit数よりも8bit以上余分に求められる最短の多項式を選択する
  2718:   //      ほぼ全域で誤差が129/256ulp未満となる
  2719:   //        全域で誤差を1/2ulp未満にする(常に真の値に最も近い表現可能な値を返す)多項式を構築することは困難である
  2720:   //        真の値の端数が0.5に近くて近似値の端数が0.5を挟んで反対側にあるとそれらの差がどれだけ小さくても真の値から遠い方に丸められてしまう
  2721:   //        例: atan()の23次のチェビシェフ展開の精度は55bitだが53bitに丸めると53bit目が真の値に最も近い表現可能な値と異なってしまう例
  2722:   //        echo read("efp.gp");x=dbltonum(0x3f8cf097f3a42000);y0=atan(x);y1=eval("-2722284370390831588490114173/158456325028528675187087900672*x^23 + 739739927556278187039881021/19807040628566084398385987584*x^21 - 992045672314533323023892321/19807040628566084398385987584*x^19 + 2313610503890582509205873157/39614081257132168796771975168*x^17 - 1319535373237619650487539135/19807040628566084398385987584*x^15 + 3047093318219389825184024421/39614081257132168796771975168*x^13 - 3601272632870709965040963617/39614081257132168796771975168*x^11 + 1100391082127852704923599513/9903520314283042199192993792*x^9 - 2829577229944316543631260919/19807040628566084398385987584*x^7 + 1980704062840506309069283499/9903520314283042199192993792*x^5 - 3301173438094258430826284729/9903520314283042199192993792*x^3 + 154742504910672532084711661/154742504910672534362390528*x")*1.0;printf("%.30g,%016x",y0,floor(y0*eval("2^59")+0.5));print();printf("%.30g,%016x",y1,floor(y1*eval("2^59")+0.5));print();printf("%.30g",log(abs((y1-y0)/y0))/log(2));print() | gp -q
  2723:   //        0.0141298303751989210010080821653,001cf019bae04517  真の値
  2724:   //        0.0141298303751989208174624059843,001cf019bae04516  近似値
  2725:   //        -56.0953826306895581110391156901  精度
  2726:   //        真の値の端数は0.10010…なので本来は切り上げなければならないが近似値の端数が0.01110…なので切り捨てられてしまっている
  2727:   //
  2728:   //    多項式の計算
  2729:   //      多項式の計算にはホーナー法(Horner's method)を用いる
  2730:   //        c(n)*x^n+c(n-1)*x^(n-1)+...+c1*x+c0 = ((c(n)*x+c(n-1))*x+...+c1)*x+c0
  2731:   //        c(n)*x+c(n-1)が0に近いときすなわちxが-c(n-1)/c(n)に近いとき桁落ち誤差が大きくなることに注意する
  2732:   //
  2733:   //  余談
  2734:   //    SPARC64 VIIIfx(京のプロセッサ)の三角関数補助演算命令は[-π/4,π/4]の範囲のsinを7項、cosを8項の多項式で近似している
  2735:   //    特にsinは53bitの係数×7項で57bitまで一致させるという超絶技巧が使われており、この係数をどうやって選択したのか興味深い
  2736:   //      sin(x)=1.0000000000000000000*x-0.16666666666666615781*x^3+0.0083333333333200018678*x^5-0.00019841269828402128715*x^7
  2737:   //            +2.7557313299015053950e-6*x^9-2.5050705846378874749e-8*x^11+1.5894136371952154456e-10*x^13
  2738:   //      echo read("efp.gp");printf("%.4f%c",closeness(sin,((((((dbltonum(0X3DE5D8408868552F)*x*x+dbltonum(0XBE5AE5E2B60F7B91))*x*x+dbltonum(0X3EC71DE351F3D22B))*x*x+dbltonum(0xBF2A01A019B92FC6))*x*x+dbltonum(0x3F8111111110F30C))*x*x+dbltonum(0xBFC5555555555543))*x*x+dbltonum(0x3FF0000000000000))*x,-Pi/4,Pi/4,10000),10) | gp -q
  2739:   //      57.0852
  2740:   //      cos(x)=1.0000000000000000000-0.50000000000000000000*x^2+0.041666666666666449248*x^4-0.0013888888888861107822*x^6
  2741:   //            +2.4801587283886826962e-5*x^8-2.7557313099139499305e-7*x^10+2.0875582539758721897e-9*x^12-1.1353387007200546080e-11*x^14
  2742:   //      echo read("efp.gp");printf("%.4f%c",closeness(cos,((((((dbltonum(0xBDA8F76380FBB401)*x*x+dbltonum(0x3E21EE96D2641B13))*x*x+dbltonum(0xBE927E4F7282F468))*x*x+dbltonum(0x3EFA01A019B1E8D8))*x*x+dbltonum(0xBF56C16C16C13A0B))*x*x+dbltonum(0x3FA5555555555536))*x*x+dbltonum(0xBFE0000000000000))*x*x+dbltonum(0x3FF0000000000000),-Pi/4,Pi/4,10000),10) | gp -q
  2743:   //      56.9315
  2744:   //
  2745:   //  参考
  2746:   //    http://repository.dl.itc.u-tokyo.ac.jp/dspace/handle/2261/31404
  2747:   //      研究解説 : チェビシェフ多項式による関数近似について
  2748:   //    http://www.made.gifu-u.ac.jp/~tanaka/LectureNote/numerical_analysis.pdf
  2749:   //      基礎数値解析‐偏微分方程式の数値シミュレーション技法入門‐
  2750:   //    http://www.fujitsu.com/jp/solutions/business-technology/tc/catalog/
  2751:   //      SPARC64(TM) VIIIfx Extensions 日本語版
  2752:   //
  2753:   //  メモ
  2754:   //    インスタンスを格納する変数がfinalでもフィールドは読み書き自由なので定数インスタンスのフィールドを間違って書き換えないように注意する
  2755:   //    使用頻度が低い処理のための条件分岐(下位が0かどうかの場合分けなど)を使用頻度が高い場所に書くことは極力避ける
  2756:   //
  2757:   //  逆三角関数と逆双曲線関数の名前
  2758:   //    逆三角関数と逆双曲線関数の接頭辞は1文字のa、呼び方はinverse(逆)に統一する
  2759:   //      ISO 80000-2:2009では逆三角関数の接頭辞はarc、逆双曲線関数の接頭辞はar
  2760:   //    Google Ngram Viewerによると、2008年までの逆双曲線関数の接頭辞の使用頻度はa>arc>arである
  2761:   //        https
  2762:   //        ://books.google.com/ngrams/graph?content=acosh%2Casinh%2Catanh%2Carcosh%2Carsinh%2Cartanh%2Carccosh%2Carcsinh%2Carctanh&case_insensitive=on&year_start=1840&year_end=2008&corpus=15&smoothing=6
  2763:   //      ただし、ソースコードの中のasinhと数式の中のarsinhが同程度に満遍なくカウントできているのかどうかは定かではない
  2764:   //    意味的に逆三角関数の返却値はarc(弧)だが逆双曲線関数の返却値はarea(面積)なのだから逆双曲線関数の接頭辞にarcを使うのは誤りということらしい
  2765:   //    コンピュータの関数名は双曲線関数の先頭にarcを付けたのではなく逆三角関数の末尾にhを付けたらarcが付いてきたというパターンも多いと思われる
  2766:   //      Mathematicaの関数名はArcTanhである
  2767:   //        http://reference.wolfram.com/language/ref/ArcTanh.html
  2768:   //      PHPのマニュアル(日本語版)のatanhの説明にカタカナでアークハイパボリックタンジェントと書かれている
  2769:   //        http://php.net/manual/ja/function.atanh.php
  2770:   //        英語版はinverseとしか書かれていない
  2771:   //        http://php.net/manual/en/function.atanh.php
  2772:   //      MC68881UMのFATANHのページにはhyperbolic arc tangentと書かれている
  2773:   //        http://cache.freescale.com/files/32bit/doc/ref_manual/MC68881UM.pdf
  2774:   //      MZ-1500用のHuBASIC Ver2.0のマニュアルにもarc-hyperbolic tangentと書かれていた
  2775:   //      Wikipediaのノートにいろいろな意見がある
  2776:   //        https://en.wikipedia.org/wiki/Talk:Inverse_hyperbolic_function
  2777:   //
  2778:   //  累乗は冪乗またはべき乗とも書くがここでは累乗とする
  2779:   //
  2780:   public class EFP implements Comparable<EFP> {
  2781: 
  2782:     //------------------------------------------------------------------------
  2783:     //定数
  2784:     //  サイズ
  2785:     public static final int LEN = 92;  //仮数部のbit数。65<=LEN<=95
  2786:     public static final long MSB = 1L << 63;  //dの最上位bit。整数部
  2787:     public static final long LSB = 1L << 128 - LEN;  //cの最下位bit。ulp
  2788:     public static final long GBM = LSB >>> 1;  //cのguard bit。1/2*ulp。丸めの処理で使う
  2789:     public static final long RBM = GBM >>> 1;  //cのround bit。1/4*ulp。指数部が異なる数の減算で1bit減ったときにguard bitになる
  2790:     public static final long SBM = RBM - 1L;  //cのsticky bitのマスク。1/4*ulp未満が0か0でないかを示す
  2791: 
  2792:     public static final int EFP_DECIMAL_PREC = 26;  //toStringの出力桁数
  2793: 
  2794:     public static final int EFP_COTH_EPP_MAX = 5;  //floor(log(log(sqrt(2^(LEN+1)+1)))/log(2))
  2795: 
  2796:     //  JavaのNaN            FPCPのNaN
  2797:     //  0x7ff8000000000000L  0x7fffffffffffffffL
  2798:     //  0x7fc00000           0x7fffffff
  2799:     public static final boolean EFP_FPCP_NAN = true;  //doubleまたはfloatで取り出すときNaNをJavaのNaNではなくFPCPのNaNに変換する
  2800: 
  2801:     //------------------------------------------------------------------------
  2802:     //インスタンスフィールド
  2803:     //                  6666555555555544 4444444433333333 3322222222221111 1111110000000000
  2804:     //                  3210987654321098 7654321098765432 1098765432109876 5432109876543210
  2805:     public int flg;   //                                  MZIN000000000000 0000000000000000  f フラグ
  2806:     public int epp;   //                                  ssssssssssssssss seeeeeeeeeeeeeee  e 指数部
  2807:     public long dvl;  //1ddddddddddddddd dddddddddddddddd dddddddddddddddd dddddddddddddddd  d 仮数部の上位64bit
  2808:     //                  └e==0のときの小数点の位置
  2809:     public long cvl;  //cccccccccccccccc cccccccccccc0000 0000000000000000 0000000000000000  c 仮数部の下位LEN-64bit
  2810:     //                                                GRSS SSSSSSSSSSSSSSSS SSSSSSSSSSSSSSSS  guard bit,round bit,sticky bit
  2811: 
  2812:     //------------------------------------------------------------------------
  2813:     //公開コンストラクタ
  2814:     //  丸めの処理が入るので定数の構築には使用できない
  2815:     //y = epb.new EFP ()
  2816:     //y = epb.new EFP (d)
  2817:     //y = epb.new EFP (f)
  2818:     //y = epb.new EFP (i)
  2819:     //y = epb.new EFP (l)
  2820:     //y = epb.new EFP (s)
  2821:     //y = epb.new EFP (e)
  2822:     public EFP () {
  2823:       this.set0 ();
  2824:     }  //EFP()
  2825:     public EFP (double d) {
  2826:       this.setd (d);
  2827:     }  //EFP(double)
  2828:     public EFP (float f) {
  2829:       this.setf (f);
  2830:     }  //EFP(float)
  2831:     public EFP (int i) {
  2832:       this.seti (i);
  2833:     }  //EFP(int)
  2834:     public EFP (long l) {
  2835:       this.setl (l);
  2836:     }  //EFP(long)
  2837:     public EFP (String s) {
  2838:       this.parse (s);
  2839:     }  //EFP(String)
  2840:     public EFP (EFP x) {
  2841:       this.sete (x);
  2842:     }  //EFP(EFP)
  2843: 
  2844:     //------------------------------------------------------------------------
  2845:     //内部コンストラクタ
  2846:     //  定数の構築に使用するので丸めの処理を行ってはならない
  2847:     //  丸めの処理が必要な場所で使う場合は後から丸めの処理を行う必要がある
  2848:     public EFP (int xf, int xe, long xd, long xc) {
  2849:       this.flg = xf;
  2850:       this.epp = xe;
  2851:       this.dvl = xd;
  2852:       this.cvl = xc;
  2853:     }  //EFP(int,int,long,long)
  2854: 
  2855:     //------------------------------------------------------------------------
  2856:     //丸めの処理
  2857: 
  2858:     //efp = efp.inner ()
  2859:     //  一時的に、丸め桁数を92bitに、丸めモードをRNに変更する
  2860:     //  関数が内部で他の関数を複数回呼び出すとき、最初の子を呼び出す『前に』実行する
  2861:     //    最初の子から最大精度で丸めさせる
  2862:     //  EFPBoxの機能だがメソッドチェーンに挟めるようにEFPのメソッドにしてある
  2863:     //    EFPBoxのインスタンスが同じならばどのEFPのインスタンスで呼び出しても同じ
  2864:     //  inner()とouter()の数がずれないように注意すること
  2865:     public final EFP inner () {
  2866:       if (epbRoundingDepth++ == 0) {
  2867:         epbRoundingOuterPrec = epbRoundingPrec;  //丸め桁数を保存する
  2868:         epbRoundingPrec = EPB_PREC_EFP;  //丸め桁数を92bitに変更する
  2869:         epbRoundingOuterMode = epbRoundingMode;  //丸めモードを保存する
  2870:         epbRoundingMode = EPB_MODE_RN;  //丸めモードをRNに変更する
  2871:       }
  2872:       if (false) {
  2873:         if (epbRoundingDepth == 10) {
  2874:           System.out.println ("too many EFP.inner()\n");
  2875:         }
  2876:       }
  2877:       return this;
  2878:     }  //efp.inner()
  2879: 
  2880:     //efp = efp.outer ()
  2881:     //  丸め桁数と丸めモードを元に戻す
  2882:     //  関数が内部で他の関数を複数回呼び出すとき、最後の子を呼び出す『前に』実行する
  2883:     //    最後の子に本来の精度で丸めさせる
  2884:     //  EFPBoxの機能だがメソッドチェーンに挟めるようにEFPのメソッドにしてある
  2885:     //    EFPBoxのインスタンスが同じならばどのEFPのインスタンスで呼び出しても同じ
  2886:     //  inner()とouter()の数がずれないように注意すること
  2887:     public final EFP outer () {
  2888:       if (--epbRoundingDepth == 0) {
  2889:         epbRoundingPrec = epbRoundingOuterPrec;  //丸め桁数を復元する
  2890:         epbRoundingMode = epbRoundingOuterMode;  //丸めモードを復元する
  2891:       }
  2892:       if (false) {
  2893:         if (epbRoundingDepth == -1) {
  2894:           System.out.println ("too many EFP.outer()\n");
  2895:         }
  2896:       }
  2897:       return this;
  2898:     }  //efp.outer()
  2899: 
  2900:     //efp = efp.finish ()
  2901:     //efp = efp.finish (zf, ze, zd, zc, zb)
  2902:     //  丸めの処理とオーバーフローとアンダーフローのチェックを行ってからインスタンスフィールドを設定する
  2903:     //  原則としてすべての関数に設置する
  2904:     //  関数が内部で他の関数を複数回呼び出すときは、最初の子を呼び出す前にinner()を、最後の子を呼び出す前にouter()を実行する
  2905:     public final EFP finish () {
  2906:       int zf = this.flg;
  2907:       if (zf << 1 != 0) {  //±0,±Inf,NaN
  2908:         return this;
  2909:       }
  2910:       switch (epbRoundingPrec) {
  2911:       case EPB_PREC_EXD:
  2912:         return this.roundx (epbRoundingMode);
  2913:       case EPB_PREC_SGL:
  2914:         return this.roundf (epbRoundingMode);
  2915:       case EPB_PREC_DBL:
  2916:       case EPB_PREC_DBL3:
  2917:         return this.roundd (epbRoundingMode);
  2918:       case EPB_PREC_TPL:
  2919:         return this.roundy (epbRoundingMode);
  2920:       case EPB_PREC_XSG:
  2921:         return this.roundg (epbRoundingMode);
  2922:       case EPB_PREC_EFP:
  2923:       default:
  2924:         int ze = this.epp;
  2925:         long zd = this.dvl;
  2926:         long zc = this.cvl;
  2927:         switch (epbRoundingMode) {
  2928:         case EPB_MODE_RN:
  2929:           if (zc << 28 != 0L) {  //端数が0でないとき
  2930:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  2931:             if (zc << 28 < 0L && (zc & 0x00000017ffffffffL) != 0L &&  //guard bitが1かつLSBまたはguard bit以外の端数が0ではないとき
  2932:                 (zc += 1L << 36) >>> 36 == 0L && ++zd == 0L) {  //切り上げて溢れたとき
  2933:               zd = MSB;
  2934:               ze++;
  2935:             }
  2936:             zc &= 0xfffffff000000000L;  //端数を切り捨てる
  2937:           }
  2938:           break;
  2939:         case EPB_MODE_RZ:
  2940:           if (zc << 28 != 0L) {  //端数が0でないとき
  2941:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  2942:             zc &= 0xfffffff000000000L;  //端数を切り捨てる
  2943:           }
  2944:           break;
  2945:         case EPB_MODE_RM:
  2946:           if (zc << 28 != 0L) {  //端数が0でないとき
  2947:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  2948:             if (zf < 0 &&  //-のとき
  2949:                 (zc += 1L << 36) >>> 36 == 0L && ++zd == 0L) {  //切り上げて溢れたとき
  2950:               zd = MSB;
  2951:               ze++;
  2952:             }
  2953:             zc &= 0xfffffff000000000L;  //端数を切り捨てる
  2954:           }
  2955:           break;
  2956:         case EPB_MODE_RP:
  2957:         default:
  2958:           if (zc << 28 != 0L) {  //端数が0でないとき
  2959:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  2960:             if (0 <= zf &&  //+のとき
  2961:                 (zc += 1L << 36) >>> 36 == 0L && ++zd == 0L) {  //切り上げて溢れたとき
  2962:               zd = MSB;
  2963:               ze++;
  2964:             }
  2965:             zc &= 0xfffffff000000000L;  //端数を切り捨てる
  2966:           }
  2967:           break;
  2968:         }
  2969:         if ((short) ze != ze) {  //オーバーフローまたはアンダーフロー
  2970:           if (0 <= ze) {  //オーバーフロー
  2971:             epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
  2972:             epbExceptionOperandExponent = zf;
  2973:             epbExceptionOperandMantissa = zd;
  2974:             return this.sete (OVFL_RESULTS[EPB_PREC_EFP << 3 | EPB_MODE_RP << 1 | zf >>> 31]);  //±Inf
  2975:           } else {  //アンダーフロー
  2976:             epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
  2977:             epbExceptionOperandExponent = zf;
  2978:             epbExceptionOperandMantissa = zd;
  2979:             return this.sete (UNFL_RESULTS[EPB_PREC_EFP << 3 | EPB_MODE_RP << 1 | zf >>> 31]);  //±0
  2980:           }
  2981:         }
  2982:         this.flg = zf;
  2983:         this.epp = ze;
  2984:         this.dvl = zd;
  2985:         this.cvl = zc;
  2986:         return this;
  2987:       }  //switch epbRoundingMode
  2988:     }  //efp.finish()
  2989:     public final EFP finish (int zf, int ze, long zd, long zc, long zb) {
  2990:       if (zf << 1 != 0) {  //±0,±Inf,NaN
  2991:         this.flg = zf;
  2992:         return this;
  2993:       }
  2994:       switch (epbRoundingPrec) {
  2995:       case EPB_PREC_EXD:
  2996:         this.flg = zf;
  2997:         this.epp = ze;
  2998:         this.dvl = zd;
  2999:         this.cvl = zc | zb >>> 32 | zb & 0xffffffffL;
  3000:         return this.roundx (epbRoundingMode);
  3001:       case EPB_PREC_SGL:
  3002:         this.flg = zf;
  3003:         this.epp = ze;
  3004:         this.dvl = zd;
  3005:         this.cvl = zc | zb >>> 32 | zb & 0xffffffffL;
  3006:         return this.roundf (epbRoundingMode);
  3007:       case EPB_PREC_DBL:
  3008:       case EPB_PREC_DBL3:
  3009:         this.flg = zf;
  3010:         this.epp = ze;
  3011:         this.dvl = zd;
  3012:         this.cvl = zc | zb >>> 32 | zb & 0xffffffffL;
  3013:         return this.roundd (epbRoundingMode);
  3014:       case EPB_PREC_TPL:
  3015:         this.flg = zf;
  3016:         this.epp = ze;
  3017:         this.dvl = zd;
  3018:         this.cvl = zc | zb >>> 32 | zb & 0xffffffffL;
  3019:         return this.roundy (epbRoundingMode);
  3020:       case EPB_PREC_XSG:
  3021:         this.flg = zf;
  3022:         this.epp = ze;
  3023:         this.dvl = zd;
  3024:         this.cvl = zc | zb >>> 32 | zb & 0xffffffffL;
  3025:         return this.roundg (epbRoundingMode);
  3026:       case EPB_PREC_EFP:
  3027:       default:
  3028:         switch (epbRoundingMode) {
  3029:         case EPB_MODE_RN:
  3030:           if ((zc << 28 | zb) != 0L) {  //端数が0でないとき
  3031:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  3032:             if (zc << 28 < 0L && ((zc & 0x00000017ffffffffL) | zb) != 0L &&  //guard bitが1かつLSBまたはguard bit以外の端数が0ではないとき
  3033:                 (zc += 1L << 36) >>> 36 == 0L && ++zd == 0L) {  //切り上げて溢れたとき
  3034:               zd = MSB;
  3035:               ze++;
  3036:             }
  3037:             zc &= 0xfffffff000000000L;  //端数を切り捨てる
  3038:           }
  3039:           break;
  3040:         case EPB_MODE_RZ:
  3041:           if ((zc << 28 | zb) != 0L) {  //端数が0でないとき
  3042:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  3043:             zc &= 0xfffffff000000000L;  //端数を切り捨てる
  3044:           }
  3045:           break;
  3046:         case EPB_MODE_RM:
  3047:           if ((zc << 28 | zb) != 0L) {  //端数が0でないとき
  3048:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  3049:             if (zf < 0 &&  //-のとき
  3050:                 (zc += 1L << 36) >>> 36 == 0L && ++zd == 0L) {  //切り上げて溢れたとき
  3051:               zd = MSB;
  3052:               ze++;
  3053:             }
  3054:             zc &= 0xfffffff000000000L;  //端数を切り捨てる
  3055:           }
  3056:           break;
  3057:         case EPB_MODE_RP:
  3058:         default:
  3059:           if ((zc << 28 | zb) != 0L) {  //端数が0でないとき
  3060:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  3061:             if (0 <= zf &&  //+のとき
  3062:                 (zc += 1L << 36) >>> 36 == 0L && ++zd == 0L) {  //切り上げて溢れたとき
  3063:               zd = MSB;
  3064:               ze++;
  3065:             }
  3066:             zc &= 0xfffffff000000000L;  //端数を切り捨てる
  3067:           }
  3068:           break;
  3069:         }
  3070:         if ((short) ze != ze) {  //オーバーフローまたはアンダーフロー
  3071:           if (0 <= ze) {  //オーバーフロー
  3072:             epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
  3073:             epbExceptionOperandExponent = zf;
  3074:             epbExceptionOperandMantissa = zd;
  3075:             return this.sete (OVFL_RESULTS[EPB_PREC_EFP << 3 | EPB_MODE_RP << 1 | zf >>> 31]);  //±Inf
  3076:           } else {  //アンダーフロー
  3077:             epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
  3078:             epbExceptionOperandExponent = zf;
  3079:             epbExceptionOperandMantissa = zd;
  3080:             return this.sete (UNFL_RESULTS[EPB_PREC_EFP << 3 | EPB_MODE_RP << 1 | zf >>> 31]);  //±0
  3081:           }
  3082:         }
  3083:         this.flg = zf;
  3084:         this.epp = ze;
  3085:         this.dvl = zd;
  3086:         this.cvl = zc;
  3087:         return this;
  3088:       }  //switch epbRoundingMode
  3089:     }  //finish(int,int,long,long,long)
  3090:     public final EFP finish2 (int zf, int ze, long zd, long zc, long zb) {
  3091:       if (zf << 1 != 0) {  //±0,±Inf,NaN
  3092:         this.flg = zf;
  3093:         return this;
  3094:       }
  3095:       switch (epbRoundingPrec) {
  3096:       case EPB_PREC_EXD:
  3097:         this.flg = zf;
  3098:         this.epp = ze;
  3099:         this.dvl = zd;
  3100:         this.cvl = zc | zb >>> 32 | zb & 0xffffffffL;
  3101:         return this.roundx2 (epbRoundingMode);
  3102:       case EPB_PREC_SGL:
  3103:         this.flg = zf;
  3104:         this.epp = ze;
  3105:         this.dvl = zd;
  3106:         this.cvl = zc | zb >>> 32 | zb & 0xffffffffL;
  3107:         return this.roundf (epbRoundingMode);
  3108:       case EPB_PREC_DBL:
  3109:       case EPB_PREC_DBL3:
  3110:         this.flg = zf;
  3111:         this.epp = ze;
  3112:         this.dvl = zd;
  3113:         this.cvl = zc | zb >>> 32 | zb & 0xffffffffL;
  3114:         return this.roundd (epbRoundingMode);
  3115:       case EPB_PREC_TPL:
  3116:         this.flg = zf;
  3117:         this.epp = ze;
  3118:         this.dvl = zd;
  3119:         this.cvl = zc | zb >>> 32 | zb & 0xffffffffL;
  3120:         return this.roundy2 (epbRoundingMode);
  3121:       case EPB_PREC_XSG:
  3122:         this.flg = zf;
  3123:         this.epp = ze;
  3124:         this.dvl = zd;
  3125:         this.cvl = zc | zb >>> 32 | zb & 0xffffffffL;
  3126:         return this.roundg (epbRoundingMode);
  3127:       case EPB_PREC_EFP:
  3128:       default:
  3129:         switch (epbRoundingMode) {
  3130:         case EPB_MODE_RN:
  3131:           if ((zc << 28 | zb) != 0L) {  //端数が0でないとき
  3132:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  3133:             if (zc << 28 < 0L && ((zc & 0x00000017ffffffffL) | zb) != 0L &&  //guard bitが1かつLSBまたはguard bit以外の端数が0ではないとき
  3134:                 (zc += 1L << 36) >>> 36 == 0L && ++zd == 0L) {  //切り上げて溢れたとき
  3135:               zd = MSB;
  3136:               ze++;
  3137:             }
  3138:             zc &= 0xfffffff000000000L;  //端数を切り捨てる
  3139:           }
  3140:           break;
  3141:         case EPB_MODE_RZ:
  3142:           if ((zc << 28 | zb) != 0L) {  //端数が0でないとき
  3143:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  3144:             zc &= 0xfffffff000000000L;  //端数を切り捨てる
  3145:           }
  3146:           break;
  3147:         case EPB_MODE_RM:
  3148:           if ((zc << 28 | zb) != 0L) {  //端数が0でないとき
  3149:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  3150:             if (zf < 0 &&  //-のとき
  3151:                 (zc += 1L << 36) >>> 36 == 0L && ++zd == 0L) {  //切り上げて溢れたとき
  3152:               zd = MSB;
  3153:               ze++;
  3154:             }
  3155:             zc &= 0xfffffff000000000L;  //端数を切り捨てる
  3156:           }
  3157:           break;
  3158:         case EPB_MODE_RP:
  3159:         default:
  3160:           if ((zc << 28 | zb) != 0L) {  //端数が0でないとき
  3161:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  3162:             if (0 <= zf &&  //+のとき
  3163:                 (zc += 1L << 36) >>> 36 == 0L && ++zd == 0L) {  //切り上げて溢れたとき
  3164:               zd = MSB;
  3165:               ze++;
  3166:             }
  3167:             zc &= 0xfffffff000000000L;  //端数を切り捨てる
  3168:           }
  3169:           break;
  3170:         }
  3171:         if ((short) ze != ze) {  //オーバーフローまたはアンダーフロー
  3172:           if (0 <= ze) {  //オーバーフロー
  3173:             epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
  3174:             epbExceptionOperandExponent = zf;
  3175:             epbExceptionOperandMantissa = zd;
  3176:             return this.sete (OVFL_RESULTS[EPB_PREC_EFP << 3 | EPB_MODE_RP << 1 | zf >>> 31]);  //±Inf
  3177:           } else {  //アンダーフロー
  3178:             epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
  3179:             epbExceptionOperandExponent = zf;
  3180:             epbExceptionOperandMantissa = zd;
  3181:             return this.sete (UNFL_RESULTS[EPB_PREC_EFP << 3 | EPB_MODE_RP << 1 | zf >>> 31]);  //±0
  3182:           }
  3183:         }
  3184:         this.flg = zf;
  3185:         this.epp = ze;
  3186:         this.dvl = zd;
  3187:         this.cvl = zc;
  3188:         return this;
  3189:       }  //switch epbRoundingMode
  3190:     }  //finish(int,int,long,long,long)
  3191:     public final EFP ifinish (int zf, int ze, long zd, long zc, long zb) {
  3192:       if (zf << 1 == 0 &&  //±0,±Inf,NaN以外で
  3193:           (zc << 28 | zb) != 0L) {  //端数が0でないとき
  3194:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  3195:         if (zc << 28 < 0L && ((zc & 0x00000017ffffffffL) | zb) != 0L &&  //guard bitが1かつLSBまたはguard bit以外の端数が0ではないとき
  3196:             (zc += 1L << 36) >>> 36 == 0L && ++zd == 0L) {  //切り上げて溢れたとき
  3197:           zd = MSB;
  3198:           ze++;
  3199:         }
  3200:         zc &= 0xfffffff000000000L;  //端数を切り捨てる
  3201:       }  //if ±0,±Inf,NaN以外で端数が0でないとき
  3202:       this.flg = zf;
  3203:       this.epp = ze;
  3204:       this.dvl = zd;
  3205:       this.cvl = zc;
  3206:       return this;
  3207:     }  //ifinish(int,int,long,long,long)
  3208: 
  3209:     //this = this.originLowerLower (x)
  3210:     //this = this.originLowerUpper (x)
  3211:     //this = this.originUpperLower (x)
  3212:     //this = this.originUpperUpper (x)
  3213:     //  原点を傾き1で通る関数で原点付近の入力と出力の大小関係に矛盾が生じていたら修正する
  3214:     //  x<0
  3215:     //    x<0でy=xよりも下(y=-Infとy=xの間)にあるもの(asin,atanh,log1p,sinh,tan)
  3216:     //      SGL,DBLでないときはy=xまで下げる
  3217:     //      RMのときはy=xの下まで下げる
  3218:     //    x<0でy=xよりも上(y=0とy=xの間)にあるもの(asinh,atan,expm1,sin,tanh)
  3219:     //      SGL,DBLでないときはy=xまで上げる
  3220:     //      RZ,RPのときはy=xの上まで上げる
  3221:     //  0<x
  3222:     //    0<xでy=xよりも下(y=0とy=xの間)にあるもの(asinh,atan,log1p,sin,tanh)
  3223:     //      SGL,DBLでないときはy=xまで下げる
  3224:     //      RZ,RMのときはy=xの下まで下げる
  3225:     //    0<xでy=xよりも上(y=xとy=+Infの間)にあるもの(asin,atanh,expm1,sinh,tan)
  3226:     //      SGL,DBLでないときはy=xまで上げる
  3227:     //      RPのときはy=xの上まで上げる
  3228:     public final EFP originLowerLower (EFP x) {
  3229:       if (x.flg << 1 == 0 && x.epp < -16) {  //0<|x|<2^-16
  3230:         if (x.flg < 0) {  //x<0でy=xよりも下(y=-Infとy=xの間)にあるもの
  3231:           if (epbRoundingPrec != EPB_PREC_SGL && epbRoundingPrec != EPB_PREC_DBL) {
  3232:             if (this.gt (x)) {
  3233:               //SGL,DBLでないときはy=xまで下げる
  3234:               this.sete (x).finish ();
  3235:             }
  3236:           }
  3237:           if (epbRoundingMode == EPB_MODE_RM) {
  3238:             if (this.ge (x)) {
  3239:               //RMのときはy=xの下まで下げる
  3240:               this.nextdown (x, epbRoundingPrec);
  3241:             }
  3242:           }
  3243:         } else {  //0<xでy=xよりも下(y=0とy=xの間)にあるもの
  3244:           if (epbRoundingPrec != EPB_PREC_SGL && epbRoundingPrec != EPB_PREC_DBL) {
  3245:             if (this.gt (x)) {
  3246:               //SGL,DBLでないときはy=xまで下げる
  3247:               this.sete (x).finish ();
  3248:             }
  3249:           }
  3250:           if (epbRoundingMode == EPB_MODE_RZ || epbRoundingMode == EPB_MODE_RM) {
  3251:             if (this.ge (x)) {
  3252:               //RZ,RMのときはy=xの下まで下げる
  3253:               this.nextdown (x, epbRoundingPrec);
  3254:             }
  3255:           }
  3256:         }
  3257:       }
  3258:       return this;
  3259:     }  //originLowerLower(EFP)
  3260:     public final EFP originLowerUpper (EFP x) {
  3261:       if (x.flg << 1 == 0 && x.epp < -16) {  //0<|x|<2^-16
  3262:         if (x.flg < 0) {  //x<0でy=xよりも下(y=-Infとy=xの間)にあるもの
  3263:           if (epbRoundingPrec != EPB_PREC_SGL && epbRoundingPrec != EPB_PREC_DBL) {
  3264:             if (this.gt (x)) {
  3265:               //SGL,DBLでないときはy=xまで下げる
  3266:               this.sete (x).finish ();
  3267:             }
  3268:           }
  3269:           if (epbRoundingMode == EPB_MODE_RM) {
  3270:             if (this.ge (x)) {
  3271:               //RMのときはy=xの下まで下げる
  3272:               this.nextdown (x, epbRoundingPrec);
  3273:             }
  3274:           }
  3275:         } else {  //0<xでy=xよりも上(y=xとy=+Infの間)にあるもの
  3276:           if (epbRoundingPrec != EPB_PREC_SGL && epbRoundingPrec != EPB_PREC_DBL) {
  3277:             if (this.lt (x)) {
  3278:               //SGL,DBLでないときはy=xまで上げる
  3279:               this.sete (x).finish ();
  3280:             }
  3281:           }
  3282:           if (epbRoundingMode == EPB_MODE_RP) {
  3283:             if (this.le (x)) {
  3284:               //RPのときはy=xの上まで上げる
  3285:               this.nextup (x, epbRoundingPrec);
  3286:             }
  3287:           }
  3288:         }
  3289:       }
  3290:       return this;
  3291:     }  //originLowerUpper(EFP)
  3292:     public final EFP originUpperLower (EFP x) {
  3293:       if (x.flg << 1 == 0 && x.epp < -16) {  //0<|x|<2^-16
  3294:         if (x.flg < 0) {  //x<0でy=xよりも上(y=0とy=xの間)にあるもの
  3295:           if (epbRoundingPrec != EPB_PREC_SGL && epbRoundingPrec != EPB_PREC_DBL) {
  3296:             if (this.lt (x)) {
  3297:               //SGL,DBLでないときはy=xまで上げる
  3298:               this.sete (x).finish ();
  3299:             }
  3300:           }
  3301:           if (epbRoundingMode == EPB_MODE_RZ || epbRoundingMode == EPB_MODE_RP) {
  3302:             if (this.le (x)) {
  3303:               //RZ,RPのときはy=xの上まで上げる
  3304:               this.nextup (x, epbRoundingPrec);
  3305:             }
  3306:           }
  3307:         } else {  //0<xでy=xよりも下(y=0とy=xの間)にあるもの
  3308:           if (epbRoundingPrec != EPB_PREC_SGL && epbRoundingPrec != EPB_PREC_DBL) {
  3309:             if (this.gt (x)) {
  3310:               //SGL,DBLでないときはy=xまで下げる
  3311:               this.sete (x).finish ();
  3312:             }
  3313:           }
  3314:           if (epbRoundingMode == EPB_MODE_RZ || epbRoundingMode == EPB_MODE_RM) {
  3315:             if (this.ge (x)) {
  3316:               //RZ,RMのときはy=xの下まで下げる
  3317:               this.nextdown (x, epbRoundingPrec);
  3318:             }
  3319:           }
  3320:         }
  3321:       }
  3322:       return this;
  3323:     }  //originUpperLower(EFP)
  3324:     public final EFP originUpperUpper (EFP x) {
  3325:       if (x.flg << 1 == 0 && x.epp < -16) {  //0<|x|<2^-16
  3326:         if (x.flg < 0) {  //x<0でy=xよりも上(y=0とy=xの間)にあるもの
  3327:           if (epbRoundingPrec != EPB_PREC_SGL && epbRoundingPrec != EPB_PREC_DBL) {
  3328:             if (this.lt (x)) {
  3329:               //SGL,DBLでないときはy=xまで上げる
  3330:               this.sete (x).finish ();
  3331:             }
  3332:           }
  3333:           if (epbRoundingMode == EPB_MODE_RZ || epbRoundingMode == EPB_MODE_RP) {
  3334:             if (this.le (x)) {
  3335:               //RZ,RPのときはy=xの上まで上げる
  3336:               this.nextup (x, epbRoundingPrec);
  3337:             }
  3338:           }
  3339:         } else {  //0<xでy=xよりも上(y=xとy=+Infの間)にあるもの
  3340:           if (epbRoundingPrec != EPB_PREC_SGL && epbRoundingPrec != EPB_PREC_DBL) {
  3341:             if (this.lt (x)) {
  3342:               //SGL,DBLでないときはy=xまで上げる
  3343:               this.sete (x).finish ();
  3344:             }
  3345:           }
  3346:           if (epbRoundingMode == EPB_MODE_RP) {
  3347:             if (this.le (x)) {
  3348:               //RPのときはy=xの上まで上げる
  3349:               this.nextup (x, epbRoundingPrec);
  3350:             }
  3351:           }
  3352:         }
  3353:       }
  3354:       return this;
  3355:     }  //originUpperUpper(EFP)
  3356: 
  3357:     //this = this.correctUnderflow (savedFpsr)
  3358:     //  非正規化数のときUFをセット、正規化数のときUFをクリアする
  3359:     public final EFP correctUnderflow (int savedFpsr) {
  3360:       if (this.flg << 1 == 0) {
  3361:         if (this.epp < (epbRoundingPrec == EPB_PREC_SGL ? -126 :
  3362:                         epbRoundingPrec == EPB_PREC_DBL || epbRoundingPrec == EPB_PREC_DBL3 ? -1022 :
  3363:                         -16383)) {  //非正規化数のとき
  3364:           epbFpsr |= EPB_FPSR_UF;  //UFをセット
  3365:         } else {  //正規化数のとき
  3366:           epbFpsr = epbFpsr & ~EPB_FPSR_UF | savedFpsr & EPB_FPSR_UF;  //UFをクリア
  3367:         }
  3368:       }
  3369:       return this;
  3370:     }  //correctUnderflow(int)
  3371: 
  3372:     //------------------------------------------------------------------------
  3373:     //x = x.abs ()
  3374:     //  x=|x|
  3375:     //y = y.abs (x)
  3376:     //  y=|x|
  3377:     //  絶対値関数 absolute value function アブソリュートバリューファンクション
  3378:     //
  3379:     //  グラフ
  3380:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{abs($_[0])});print$g"
  3381:     //    echo read("efp.gp");graph(abs) | gp -q
  3382:     //    **--------+---------+---------+---------+---------+---------+---------+--------**
  3383:     //    |***                                    |                                    ***|
  3384:     //    |  ***                                  |                                  ***  |
  3385:     //    |    ***                                |                                ***    |
  3386:     //    |      ***                              |                              ***      |
  3387:     //    +        ***                            +                            ***        +
  3388:     //    |          ***                          |                          ***          |
  3389:     //    |            ***                        |                        ***            |
  3390:     //    |              ***                      |                      ***              |
  3391:     //    |                ***                    |                    ***                |
  3392:     //    +                  ***                  +                  ***                  +
  3393:     //    |                    ***                |                ***                    |
  3394:     //    |                      ***              |              ***                      |
  3395:     //    |                        ***            |            ***                        |
  3396:     //    |                          ***          |          ***                          |
  3397:     //    +                            ***        +        ***                            +
  3398:     //    |                              ***      |      ***                              |
  3399:     //    |                                ***    |    ***                                |
  3400:     //    |                                  ***  |  ***                                  |
  3401:     //    |                                    ***|***                                    |
  3402:     //    +---------+---------+---------+--------***--------+---------+---------+---------+
  3403:     //    |                                       |                                       |
  3404:     //    |                                       |                                       |
  3405:     //    |                                       |                                       |
  3406:     //    |                                       |                                       |
  3407:     //    +                                       +                                       +
  3408:     //    |                                       |                                       |
  3409:     //    |                                       |                                       |
  3410:     //    |                                       |                                       |
  3411:     //    |                                       |                                       |
  3412:     //    +                                       +                                       +
  3413:     //    |                                       |                                       |
  3414:     //    |                                       |                                       |
  3415:     //    |                                       |                                       |
  3416:     //    |                                       |                                       |
  3417:     //    +                                       +                                       +
  3418:     //    |                                       |                                       |
  3419:     //    |                                       |                                       |
  3420:     //    |                                       |                                       |
  3421:     //    |                                       |                                       |
  3422:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  3423:     //
  3424:     //  定義域
  3425:     //    -inf<=x<=inf
  3426:     //
  3427:     //  値域
  3428:     //    0<=y<=inf
  3429:     //
  3430:     public final EFP abs () {
  3431:       return this.finish (this.flg & ~M, this.epp, this.dvl, this.cvl, 0L);
  3432:     }  //efp.abs()
  3433:     public final EFP iabs () {
  3434:       this.flg &= ~M;  //NaNでも問題ない
  3435:       return this;
  3436:     }  //efp.abs()
  3437:     public final EFP abs (EFP x) {
  3438:       return this.finish (x.flg & ~M, x.epp, x.dvl, x.cvl, 0L);
  3439:     }  //efp.abs(EFP)
  3440:     public final EFP iabs (EFP x) {
  3441:       this.flg = x.flg & ~M;  //NaNでも問題ない
  3442:       this.epp = x.epp;
  3443:       this.dvl = x.dvl;
  3444:       this.cvl = x.cvl;
  3445:       return this;
  3446:     }  //efp.abs(EFP)
  3447: 
  3448:     //------------------------------------------------------------------------
  3449:     //x = x.acos ()
  3450:     //  x=acos(x)
  3451:     //y = y.acos (x)
  3452:     //  y=acos(x)
  3453:     //  逆余弦 inverse cosine インバースコサイン
  3454:     //
  3455:     //  グラフ
  3456:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{acos($_[0])});print$g"
  3457:     //    echo read("efp.gp");graph(acos) | gp -q
  3458:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  3459:     //    |                                       |                                       |
  3460:     //    |                                       |                                       |
  3461:     //    |                                       |                                       |
  3462:     //    |                             *         |                                       |
  3463:     //    +                             *         +                                       +
  3464:     //    |                             **        |                                       |
  3465:     //    |                              **       |                                       |
  3466:     //    |                               **      |                                       |
  3467:     //    |                                ***    |                                       |
  3468:     //    +                                  ***  +                                       +
  3469:     //    |                                    ***|                                       |
  3470:     //    |                                      ***                                      |
  3471:     //    |                                       |***                                    |
  3472:     //    |                                       |  ***                                  |
  3473:     //    +                                       +    **                                 +
  3474:     //    |                                       |     ***                               |
  3475:     //    |                                       |       **                              |
  3476:     //    |                                       |        **                             |
  3477:     //    |                                       |         *                             |
  3478:     //    +---------+---------+---------+---------+---------*---------+---------+---------+
  3479:     //    |                                       |                                       |
  3480:     //    |                                       |                                       |
  3481:     //    |                                       |                                       |
  3482:     //    |                                       |                                       |
  3483:     //    +                                       +                                       +
  3484:     //    |                                       |                                       |
  3485:     //    |                                       |                                       |
  3486:     //    |                                       |                                       |
  3487:     //    |                                       |                                       |
  3488:     //    +                                       +                                       +
  3489:     //    |                                       |                                       |
  3490:     //    |                                       |                                       |
  3491:     //    |                                       |                                       |
  3492:     //    |                                       |                                       |
  3493:     //    +                                       +                                       +
  3494:     //    |                                       |                                       |
  3495:     //    |                                       |                                       |
  3496:     //    |                                       |                                       |
  3497:     //    |                                       |                                       |
  3498:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  3499:     //
  3500:     //  定義域
  3501:     //    -1<=x<=1
  3502:     //
  3503:     //  値域
  3504:     //    0<=y<=pi
  3505:     //
  3506:     //  逆三角関数との関係
  3507:     //    acos(x)=atan2(sqrt(1-x^2),x)
  3508:     //           =atan(sqrt(1-x^2)/x)
  3509:     //           =pi/2-asin(x)
  3510:     //           =pi/2-atan2(x,sqrt(1-x^2))
  3511:     //           =pi/2-atan(x/sqrt(1-x^2))
  3512:     //
  3513:     //  テイラー展開
  3514:     //    asinのテイラー展開を参照
  3515:     //    acos(x)=pi/2-asin(x)
  3516:     //           =pi/2-sum[m=0..inf]{prod[k=0..m-1]{2*k+1}/2^m/m!/(2*m+1)*x^(2*m+1)}
  3517:     //           =pi/2-(1/1/1*x^1+(1)/(2)/3*x^3+(1*3)/(2*4)/5*x^5+(1*3*5)/(2*4*6)/7*x^7+(1*3*5*7)/(2*4*6*8)/9*x^9+...)
  3518:     //           =pi/2-x-1/6*x^3-3/40*x^5-5/112*x^7-35/1152*x^9-...
  3519:     //    > coeff(sub(a=0,for n:=0:10 sum sub(x=a,df(acos(x),x,n))/factorial(n)*(x-a)^n),x);
  3520:     //      pi         - 1      - 3      - 5      - 35
  3521:     //    {----,-1,0,------,0,------,0,------,0,-------}
  3522:     //      2          6        40      112      1152
  3523:     //
  3524:     //  pi/2-asin(x)で求める方法
  3525:     //    浮動小数点数の場合、x=1-εで桁落ちが発生して精度が低くなるので工夫が必要
  3526:     //
  3527:     public final EFP acos () {
  3528:       return this.acos (this);
  3529:     }  //efp.acos()
  3530:     public final EFP acos (EFP x) {
  3531:       //return this.asin (x).negsub (PI_2);  //pi/2-asin(x)。x=1-εのとき桁落ちが発生するため精度が低い
  3532:       int xf = x.flg;
  3533:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  3534:         if (xf << 1 < 0) {  //±0
  3535:           epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  3536:           this.sete (ROUNDED_PI_2[epbRoundingMode]).finish ();  //acos(±0)=pi/2
  3537:         } else if (xf << 2 < 0) {  //±Inf
  3538:           epbFpsr |= EPB_FPSR_OE;
  3539:           epbExceptionOperandExponent = xf & M | 0x7fff << 16;
  3540:           epbExceptionOperandMantissa = 0x0000000000000000L;
  3541:           this.flg = N;  //acos(±Inf)=NaN
  3542:         } else {  //NaN
  3543:           this.flg = N;  //acos(NaN)=NaN
  3544:         }
  3545:         return this;
  3546:       }
  3547:       //±0,±Inf,NaN以外
  3548:       int xe = x.epp;
  3549:       if (xe >= 0) {  //|x|>=1
  3550:         if (xe == 0 && x.dvl == MSB && x.cvl == 0L) {  //|x|==1
  3551:           if (xf >= 0) {
  3552:             this.flg = P | Z;  //acos(+1)=+0
  3553:           } else {
  3554:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  3555:             this.sete (ROUNDED_PI[epbRoundingMode]).finish ();  //acos(-1)=pi
  3556:           }
  3557:         } else {  //1<|x|
  3558:           epbFpsr |= EPB_FPSR_OE;
  3559:           epbExceptionOperandExponent = xf | 0x3fff + xe << 16;
  3560:           epbExceptionOperandMantissa = x.dvl;
  3561:           this.flg = N;
  3562:         }
  3563:         return this;
  3564:       }
  3565:       //|x|<1
  3566:       if (this == x) {
  3567:         x = new EFP (x);
  3568:       }
  3569:       return this.inner ().negdec (x).imul (new EFP ().inc (x)).sqrt ().outer ().atan2 (x);  //atan2(sqrt((1-x)*(1+x)),x) [91]
  3570:     }  //efp.acos(EFP)
  3571: 
  3572:     //------------------------------------------------------------------------
  3573:     //x = x.acosh ()
  3574:     //  x=acosh(x)
  3575:     //y = y.acosh (x)
  3576:     //  y=acosh(x)
  3577:     //  逆双曲線余弦 inverse hyperbolic cosine インバースハイパボリックコサイン
  3578:     //
  3579:     //  グラフ
  3580:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{acosh($_[0])});print$g"
  3581:     //    echo read("efp.gp");graph(acosh) | gp -q
  3582:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  3583:     //    |                                       |                                       |
  3584:     //    |                                       |                                       |
  3585:     //    |                                       |                                       |
  3586:     //    |                                       |                                       |
  3587:     //    +                                       +                                       +
  3588:     //    |                                       |                                       |
  3589:     //    |                                       |                                       |
  3590:     //    |                                       |                                       |
  3591:     //    |                                       |                                       |
  3592:     //    +                                       +                                 *******
  3593:     //    |                                       |                           *******     |
  3594:     //    |                                       |                       *****           |
  3595:     //    |                                       |                   *****               |
  3596:     //    |                                       |                ****                   |
  3597:     //    +                                       +             ****                      +
  3598:     //    |                                       |            **                         |
  3599:     //    |                                       |          ***                          |
  3600:     //    |                                       |         **                            |
  3601:     //    |                                       |         *                             |
  3602:     //    +---------+---------+---------+---------+---------*---------+---------+---------+
  3603:     //    |                                       |                                       |
  3604:     //    |                                       |                                       |
  3605:     //    |                                       |                                       |
  3606:     //    |                                       |                                       |
  3607:     //    +                                       +                                       +
  3608:     //    |                                       |                                       |
  3609:     //    |                                       |                                       |
  3610:     //    |                                       |                                       |
  3611:     //    |                                       |                                       |
  3612:     //    +                                       +                                       +
  3613:     //    |                                       |                                       |
  3614:     //    |                                       |                                       |
  3615:     //    |                                       |                                       |
  3616:     //    |                                       |                                       |
  3617:     //    +                                       +                                       +
  3618:     //    |                                       |                                       |
  3619:     //    |                                       |                                       |
  3620:     //    |                                       |                                       |
  3621:     //    |                                       |                                       |
  3622:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  3623:     //
  3624:     //  定義域
  3625:     //    1<=x<=inf
  3626:     //
  3627:     //  値域
  3628:     //    0<=y<=inf
  3629:     //
  3630:     //  対数関数との関係
  3631:     //    acosh(x)=log(x+sqrt(x^2-1))
  3632:     //            =log1p(x-1+sqrt((x-1)*(x+1)))
  3633:     //            =log1p(x-1+sqrt((x-1)^2+2*(x-1)))
  3634:     //      x^2-1=(x-1+1)^2-1
  3635:     //           =(x-1)^2+2*(x-1)+1-1
  3636:     //           =(x-1)^2+2*(x-1)
  3637:     //      acoshの定義域は1<=xなのでx-1で誤差が増えることはない
  3638:     //
  3639:     public final EFP acosh () {
  3640:       return this.acosh (this);
  3641:     }  //efp.acosh()
  3642:     public final EFP acosh (EFP x) {
  3643:       int xf = x.flg;
  3644:       if (xf != 0) {  //-x,±0,±Inf,NaN
  3645:         if (xf < 0 || xf << 1 < 0) {  //-x,±0,-Inf
  3646:           epbFpsr |= EPB_FPSR_OE;
  3647:           if (xf << 1 < 0) {  //±0
  3648:             epbExceptionOperandExponent = xf & M;
  3649:             epbExceptionOperandMantissa = 0x0000000000000000L;
  3650:           } else if (xf == (M | I)) {  //-Inf
  3651:             epbExceptionOperandExponent = M | 0x7fff << 16;
  3652:             epbExceptionOperandMantissa = 0x0000000000000000L;
  3653:           } else {  //-x
  3654:             epbExceptionOperandExponent = M | 0x3fff + x.epp << 16;
  3655:             epbExceptionOperandMantissa = x.dvl;
  3656:           }
  3657:           this.flg = N;  //acosh(-x)=acosh(-Inf)=acosh(±0)=NaN
  3658:         } else {
  3659:           this.flg = xf == (P | I) ? P | I : N;  //acosh(+Inf)=+Inf, acosh(NaN)=NaN
  3660:         }
  3661:         return this;
  3662:       }
  3663:       //±0,±Inf,NaN以外
  3664:       if (x.epp < 0) {  //0<x<1
  3665:         epbFpsr |= EPB_FPSR_OE;
  3666:         epbExceptionOperandExponent = 0x3fff + x.epp << 16;
  3667:         epbExceptionOperandMantissa = x.dvl;
  3668:         this.flg = N;  //acosh(|x|<1)=NaN
  3669:         return this;
  3670:       }
  3671:       //1<=|x|
  3672:       return this.inner ().dec (x).iadd (new EFP ().isqu (this).iadd (new EFP ().imul2 (this)).sqrt ()).outer ().log1p ();  //log1p(x-1+sqrt((x-1)^2+2*(x-1)))
  3673:     }  //efp.acosh(EFP)
  3674: 
  3675:     //------------------------------------------------------------------------
  3676:     //x = x.acot ()
  3677:     //  x=acot(x)
  3678:     //y = y.acot (x)
  3679:     //  y=acot(x)
  3680:     //  逆余接 inverse cotangent インバースコタンジェント
  3681:     //
  3682:     //  グラフ
  3683:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{acot($_[0])});print$g"
  3684:     //    echo read("efp.gp");eval("acot(x)=atan(1/x)");graph(acot) | gp -q
  3685:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  3686:     //    |                                       |                                       |
  3687:     //    |                                       |                                       |
  3688:     //    |                                       |                                       |
  3689:     //    |                                       |                                       |
  3690:     //    +                                       +                                       +
  3691:     //    |                                       |                                       |
  3692:     //    |                                       |                                       |
  3693:     //    |                                       |                                       |
  3694:     //    |                                       |                                       |
  3695:     //    +                                       +                                       +
  3696:     //    |                                       |                                       |
  3697:     //    |                                       **                                      |
  3698:     //    |                                       |***                                    |
  3699:     //    |                                       |  ***                                  |
  3700:     //    +                                       +    ****                               +
  3701:     //    |                                       |       *****                           |
  3702:     //    |                                       |           *******                     |
  3703:     //    |                                       |                 ***************       |
  3704:     //    |                                       |                               *********
  3705:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  3706:     //    *********                               |                                       |
  3707:     //    |       ***************                 |                                       |
  3708:     //    |                     *******           |                                       |
  3709:     //    |                           *****       |                                       |
  3710:     //    +                               ****    +                                       +
  3711:     //    |                                  ***  |                                       |
  3712:     //    |                                    ***|                                       |
  3713:     //    |                                      **                                       |
  3714:     //    |                                       |                                       |
  3715:     //    +                                       +                                       +
  3716:     //    |                                       |                                       |
  3717:     //    |                                       |                                       |
  3718:     //    |                                       |                                       |
  3719:     //    |                                       |                                       |
  3720:     //    +                                       +                                       +
  3721:     //    |                                       |                                       |
  3722:     //    |                                       |                                       |
  3723:     //    |                                       |                                       |
  3724:     //    |                                       |                                       |
  3725:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  3726:     //
  3727:     //  定義域
  3728:     //    inf<=x<0
  3729:     //    0<x<=inf
  3730:     //
  3731:     //  値域
  3732:     //    -pi/2<=y<0
  3733:     //    0<y<=pi/2
  3734:     //
  3735:     //  逆三角関数との関係
  3736:     //    acot(x)=atan2(1/x,1)
  3737:     //           =atan(1/x)
  3738:     //
  3739:     public final EFP acot () {
  3740:       return this.acot (this);
  3741:     }  //efp.acot()
  3742:     public final EFP acot (EFP x) {
  3743:       return this.inner ().rcp (x).outer ().atan ();  //atan(1/x)
  3744:     }  //efp.acot(EFP)
  3745: 
  3746:     //------------------------------------------------------------------------
  3747:     //x = x.acoth ()
  3748:     //  x=acoth(x)
  3749:     //y = y.acoth (x)
  3750:     //  y=acoth(x)
  3751:     //  逆双曲線余接 inverse hyperbolic cotangent インバースハイパボリックコタンジェント
  3752:     //
  3753:     //  グラフ
  3754:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{acoth($_[0])});print$g"
  3755:     //    echo read("efp.gp");eval("acoth(x)=log((x+1)/(x-1))/2");graph(acoth) | gp -q
  3756:     //    +---------+---------+---------+---------+---------*---------+---------+---------+
  3757:     //    |                                       |         *                             |
  3758:     //    |                                       |         *                             |
  3759:     //    |                                       |         *                             |
  3760:     //    |                                       |         *                             |
  3761:     //    +                                       +         *                             +
  3762:     //    |                                       |         *                             |
  3763:     //    |                                       |         *                             |
  3764:     //    |                                       |         *                             |
  3765:     //    |                                       |         *                             |
  3766:     //    +                                       +         *                             +
  3767:     //    |                                       |         **                            |
  3768:     //    |                                       |          *                            |
  3769:     //    |                                       |          **                           |
  3770:     //    |                                       |           *                           |
  3771:     //    +                                       +           ***                         +
  3772:     //    |                                       |             ****                      |
  3773:     //    |                                       |                ******                 |
  3774:     //    |                                       |                     *************     |
  3775:     //    |                                       |                                 *******
  3776:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  3777:     //    *******                                 |                                       |
  3778:     //    |     *************                     |                                       |
  3779:     //    |                 ******                |                                       |
  3780:     //    |                      ****             |                                       |
  3781:     //    +                         ***           +                                       +
  3782:     //    |                           *           |                                       |
  3783:     //    |                           **          |                                       |
  3784:     //    |                            *          |                                       |
  3785:     //    |                            **         |                                       |
  3786:     //    +                             *         +                                       +
  3787:     //    |                             *         |                                       |
  3788:     //    |                             *         |                                       |
  3789:     //    |                             *         |                                       |
  3790:     //    |                             *         |                                       |
  3791:     //    +                             *         +                                       +
  3792:     //    |                             *         |                                       |
  3793:     //    |                             *         |                                       |
  3794:     //    |                             *         |                                       |
  3795:     //    |                             *         |                                       |
  3796:     //    +---------+---------+---------*---------+---------+---------+---------+---------+
  3797:     //
  3798:     //  定義域
  3799:     //    inf<=x<-1
  3800:     //    1<x<=inf
  3801:     //
  3802:     //  値域
  3803:     //    -inf<=y<0
  3804:     //    0<y<=inf
  3805:     //
  3806:     //  対数関数との関係
  3807:     //    acoth(x)=log((x+1)/(x-1))/2
  3808:     //            =log(sqrt((x+1)/(x-1)))
  3809:     //            =log(sqrt(x+1)/sqrt(x-1))
  3810:     //
  3811:     public final EFP acoth () {
  3812:       return this.acoth (this);
  3813:     }  //efp.acoth()
  3814:     public final EFP acoth (EFP x) {
  3815:       int xf = x.flg;
  3816:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  3817:         if (xf << 1 < 0) {  //±0
  3818:           epbFpsr |= EPB_FPSR_OE;
  3819:           epbExceptionOperandExponent = xf & M;
  3820:           epbExceptionOperandMantissa = 0x0000000000000000L;
  3821:           this.flg = N;  //acoth(±0)=NaN
  3822:         } else {
  3823:           this.flg = xf << 2 < 0 ? xf ^ (Z | I) : N;  //acoth(±Inf)=±0, acoth(NaN)=NaN
  3824:         }
  3825:         return this;
  3826:       }
  3827:       //±0,±Inf,NaN以外
  3828:       if (x.epp < 0) {  //|x|<1
  3829:         epbFpsr |= EPB_FPSR_OE;
  3830:         epbExceptionOperandExponent = xf | 0x3fff + x.epp << 16;
  3831:         epbExceptionOperandMantissa = x.dvl;
  3832:         this.flg = N;  //acoth(|x|<1)=NaN
  3833:         return this;
  3834:       }
  3835:       if (x.epp == 0 && x.dvl == MSB && x.cvl == 0L) {  //|x|==1
  3836:         epbFpsr |= EPB_FPSR_DZ;
  3837:         epbExceptionOperandExponent = xf & M | 0x3fff << 16;
  3838:         epbExceptionOperandMantissa = 0x8000000000000000L;
  3839:         this.flg = xf | I;  //acoth(±1)=±Inf
  3840:         return this;
  3841:       }
  3842:       //1<|x|
  3843:       return this.inner ().iabs (x).dec ().rcp ().imul2 ().log1p ().idiv2 ().outer ().neg (xf < 0);  //sgn(x)*log(1+2/(|x|-1))/2
  3844:     }  //efp.acoth(EFP)
  3845: 
  3846:     //------------------------------------------------------------------------
  3847:     //x = x.acsc ()
  3848:     //  x=acsc(x)
  3849:     //y = y.acsc (x)
  3850:     //  y=acsc(x)
  3851:     //  逆余割 inverse cosecant インバースコセカント
  3852:     //
  3853:     //  グラフ
  3854:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{acsc($_[0])});print$g"
  3855:     //    echo read("efp.gp");eval("acsc(x)=sign(x)*atan(1/sqrt((x-1)*(x+1)))");graph(acsc) | gp -q
  3856:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  3857:     //    |                                       |                                       |
  3858:     //    |                                       |                                       |
  3859:     //    |                                       |                                       |
  3860:     //    |                                       |                                       |
  3861:     //    +                                       +                                       +
  3862:     //    |                                       |                                       |
  3863:     //    |                                       |                                       |
  3864:     //    |                                       |                                       |
  3865:     //    |                                       |                                       |
  3866:     //    +                                       +                                       +
  3867:     //    |                                       |                                       |
  3868:     //    |                                       |         *                             |
  3869:     //    |                                       |         *                             |
  3870:     //    |                                       |         **                            |
  3871:     //    +                                       +          ***                          +
  3872:     //    |                                       |            ****                       |
  3873:     //    |                                       |               ******                  |
  3874:     //    |                                       |                    **************     |
  3875:     //    |                                       |                                 *******
  3876:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  3877:     //    *******                                 |                                       |
  3878:     //    |     **************                    |                                       |
  3879:     //    |                  ******               |                                       |
  3880:     //    |                       ****            |                                       |
  3881:     //    +                          ***          +                                       +
  3882:     //    |                            **         |                                       |
  3883:     //    |                             *         |                                       |
  3884:     //    |                             *         |                                       |
  3885:     //    |                                       |                                       |
  3886:     //    +                                       +                                       +
  3887:     //    |                                       |                                       |
  3888:     //    |                                       |                                       |
  3889:     //    |                                       |                                       |
  3890:     //    |                                       |                                       |
  3891:     //    +                                       +                                       +
  3892:     //    |                                       |                                       |
  3893:     //    |                                       |                                       |
  3894:     //    |                                       |                                       |
  3895:     //    |                                       |                                       |
  3896:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  3897:     //
  3898:     //  定義域
  3899:     //    inf<=x<=-1
  3900:     //    1<=x<=inf
  3901:     //
  3902:     //  値域
  3903:     //    -pi/2<=y<0
  3904:     //    0<y<=pi/2
  3905:     //
  3906:     //  逆三角関数との関係
  3907:     //    acsc(x)=atan2(1/x,sqrt(1-1/x^2))
  3908:     //           =atan2(sgn(x),sqrt(x^2-1))
  3909:     //           =sgn(x)*atan2(1,sqrt(x^2-1))
  3910:     //           =sgn(x)*atan(1/sqrt(x^2-1))
  3911:     //           =sgn(x)*atan(1/sqrt((x-1)*(x+1)))
  3912:     //           =asin(1/x)
  3913:     //
  3914:     public final EFP acsc () {
  3915:       return this.acsc (this);
  3916:     }  //efp.acsc()
  3917:     public final EFP acsc (EFP x) {
  3918:       int xf = x.flg;
  3919:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  3920:         if (xf << 1 < 0) {  //±0
  3921:           epbFpsr |= EPB_FPSR_OE;
  3922:           epbExceptionOperandExponent = xf & M;
  3923:           epbExceptionOperandMantissa = 0x0000000000000000L;
  3924:           this.flg = N;  //acsc(±0)=NaN
  3925:         } else {
  3926:           this.flg = xf << 2 < 0 ? xf ^ (Z | I) : N;  //acsc(±Inf)=±0, acsc(NaN)=NaN
  3927:         }
  3928:         return this;
  3929:       }
  3930:       //±0,±Inf,NaN以外
  3931:       if (x.epp < 0) {  //|x|<1
  3932:         epbFpsr |= EPB_FPSR_OE;
  3933:         epbExceptionOperandExponent = xf | 0x3fff + x.epp << 16;
  3934:         epbExceptionOperandMantissa = x.dvl;
  3935:         this.flg = N;  //acsc(|x|<1)=NaN
  3936:         return this;
  3937:       }
  3938:       if (x.epp == 0 && x.dvl == MSB && x.cvl == 0L) {  //|x|==1
  3939:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  3940:         if (xf >= 0) {
  3941:           this.sete (ROUNDED_PI_2[epbRoundingMode]).finish ();  //acsc(1)=pi/2
  3942:         } else {
  3943:           this.sete (ROUNDED_NEGPI_2[epbRoundingMode]).finish ();  //acsc(-1)=-pi/2
  3944:         }
  3945:         return this;
  3946:       }
  3947:       //1<|x|
  3948:       EFP t = new EFP ().inner ().inc (x);
  3949:       return this.dec (x).imul (t).sqrt ().rcp ().atan ().outer ().neg (xf < 0);  //sgn(x)*atan(1/sqrt((x-1)*(x+1)))
  3950:     }  //efp.acsc(EFP)
  3951: 
  3952:     //------------------------------------------------------------------------
  3953:     //x = x.acsch ()
  3954:     //  x=acsch(x)
  3955:     //y = y.acsch (x)
  3956:     //  y=acsch(x)
  3957:     //  逆双曲線余割 inverse hyperbolic cosecant インバースハイパボリックコセカント
  3958:     //
  3959:     //  グラフ
  3960:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{acsch($_[0])});print$g"
  3961:     //    echo read("efp.gp");eval("acsch(x)=log(1/x+sqrt(1/x^2+1))");graph(acsch) | gp -q
  3962:     //    +---------+---------+---------+---------*---------+---------+---------+---------+
  3963:     //    |                                       *                                       |
  3964:     //    |                                       **                                      |
  3965:     //    |                                       |*                                      |
  3966:     //    |                                       |*                                      |
  3967:     //    +                                       +*                                      +
  3968:     //    |                                       |*                                      |
  3969:     //    |                                       |**                                     |
  3970:     //    |                                       | *                                     |
  3971:     //    |                                       | *                                     |
  3972:     //    +                                       + **                                    +
  3973:     //    |                                       |  **                                   |
  3974:     //    |                                       |   **                                  |
  3975:     //    |                                       |    **                                 |
  3976:     //    |                                       |     **                                |
  3977:     //    +                                       +      ****                             +
  3978:     //    |                                       |         ****                          |
  3979:     //    |                                       |            *******                    |
  3980:     //    |                                       |                  ***************      |
  3981:     //    |                                       |                                ********
  3982:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  3983:     //    ********                                |                                       |
  3984:     //    |      ***************                  |                                       |
  3985:     //    |                    *******            |                                       |
  3986:     //    |                          ****         |                                       |
  3987:     //    +                             ****      +                                       +
  3988:     //    |                                **     |                                       |
  3989:     //    |                                 **    |                                       |
  3990:     //    |                                  **   |                                       |
  3991:     //    |                                   **  |                                       |
  3992:     //    +                                    ** +                                       +
  3993:     //    |                                     * |                                       |
  3994:     //    |                                     * |                                       |
  3995:     //    |                                     **|                                       |
  3996:     //    |                                      *|                                       |
  3997:     //    +                                      *+                                       +
  3998:     //    |                                      *|                                       |
  3999:     //    |                                      *|                                       |
  4000:     //    |                                      **                                       |
  4001:     //    |                                       *                                       |
  4002:     //    +---------+---------+---------+---------*---------+---------+---------+---------+
  4003:     //
  4004:     //  定義域
  4005:     //    inf<=x<0
  4006:     //    0<x<=inf
  4007:     //
  4008:     //  値域
  4009:     //    -inf<=y<0
  4010:     //    0<y<=inf
  4011:     //
  4012:     //  逆双曲線関数との関係
  4013:     //    acsch(x)=asinh(1/x)
  4014:     //
  4015:     //  対数関数との関係
  4016:     //    acsch(x)=log(1/x+sqrt(1/x^2+1))
  4017:     //            =log((1+sgn(x)*sqrt(1+x^2))/x)
  4018:     //            =log((sgn(x)+sqrt(1+x^2))/abs(x))
  4019:     //            =log(sgn(x)+sqrt(1+x^2))-log(abs(x))
  4020:     //
  4021:     //  テイラー展開
  4022:     //    http://mathworld.wolfram.com/InverseHyperbolicCosecant.html
  4023:     //    acsch(x)=sum[n=1..inf]{(-1)^n*pochhammer(1/2,n-1)/((2*n-1)*(n-1)!)*x^(1-2*n)}
  4024:     //            =x^-1-1/6*x^-3+3/40*x^-5-5/112*x^-7+...
  4025:     //      pochhammer(x,n)=prod[k=0..n-1]{x+k}  ポッホハマー記号
  4026:     //
  4027:     //  ピュイズー展開
  4028:     //    http://mathworld.wolfram.com/InverseHyperbolicCosecant.html
  4029:     //    acsch(x)=-log(x)+log(2)+sum[n=1..inf]{(-1)^(n+1)*(2*n-1)!!/(2*n*(2*n)!!)*x^(2*n)}
  4030:     //            =-log(x)+log(2)+1!!/(2*2!!)*x^2-3!!/(4*4!!)*x^4+5!!/(6*6!!)*x^6-...
  4031:     //            =-log(x)+log(2)+1/(2*2)*x^2-1*3/(4*2*4)*x^4+1*3*5/(6*2*4*6)*x^6-...
  4032:     //            =-log(x)+log(2)+1/4*x^2-3/32*x^4+5/96*x^6-...
  4033:     //
  4034:     //  1<xのとき
  4035:     //    sqrt(x^2+1)-x=sum[n=0..inf]{(-1)^n*catalan(n)/(2*x)^(2*n+1)}
  4036:     //                 =sum[n=0..inf]{(-1)^n*(2*n)!/(n!*(n+1)!)/(2*x)^(2*n+1)}
  4037:     //                 =1/(2*x)-1/(2*x)^3+2/(2*x)^5-5/(2*x)^7+14/(2*x)^9
  4038:     //                 -42/(2*x)^11+132/(2*x)^13-429/(2*x)^15+1430/(2*x)^17-4862/(2*x)^19
  4039:     //                 +16796/(2*x)^21-58786/(2*x)^23...
  4040:     //
  4041:     //  0<=x<1のとき
  4042:     //    sqrt(1/x^2+1)-1/x=sum[n=0..inf]{(-1)^n*catalan(n)/2^(2*n+1)*x^(2*n+1)}
  4043:     //                     =sum[n=0..inf]{(-1)^n*(2*n)!/(n!*(n+1)!)/2^(2*n+1)*x^(2*n+1)}
  4044:     //                     =1/2*x-1/2^3*x^3+2/2^5*x^5-5/2^7*x^7+14/2^9*x^9
  4045:     //                     -42/2^11*x^11+132/2^13*x^13-429/2^15*x^15+1430/2^17*x^17-4862/2^19*x^19
  4046:     //                     +16796/2^21*x^21-58786/2^23*x^23...
  4047:     //    acsch(x)=log(2/x+sum[n=0..inf]{(-1)^n*catalan(n)/2^(2*n+1)*x^(2*n+1)})
  4048:     //      ピュイズー展開の式に似ている。x→+0でlog(2/x)に近付くのだから当然か
  4049:     //
  4050:     public final EFP acsch () {
  4051:       return this.acsch (this);
  4052:     }  //efp.acsch()
  4053:     public final EFP acsch (EFP x) {
  4054:       int xf = x.flg;
  4055:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  4056:         if (xf << 1 < 0) {  //±0
  4057:           epbFpsr |= EPB_FPSR_OE;
  4058:           epbExceptionOperandExponent = xf & M;
  4059:           epbExceptionOperandMantissa = 0x0000000000000000L;
  4060:           this.flg = N;  //acsch(±0)=NaN
  4061:         } else {
  4062:           this.flg = xf << 2 < 0 ? xf ^ (Z | I) : N;  //acsch(±Inf)=±0, acsc(NaN)=NaN
  4063:         }
  4064:         return this;
  4065:       }
  4066:       //±0,±Inf,NaN以外
  4067:       x = new EFP ().inner ().rcp (x);  //1/x
  4068:       if (x.epp < -1) {  //|x|<0.5
  4069:         EFP x2 = new EFP ().isqu (x);
  4070:         return this.imul (ASINH_C43, x2)
  4071:           .iadd (ASINH_C41).imul (x2)
  4072:             .iadd (ASINH_C39).imul (x2)
  4073:               .iadd (ASINH_C37).imul (x2)
  4074:                 .iadd (ASINH_C35).imul (x2)
  4075:                   .iadd (ASINH_C33).imul (x2)
  4076:                     .iadd (ASINH_C31).imul (x2)
  4077:                       .iadd (ASINH_C29).imul (x2)
  4078:                         .iadd (ASINH_C27).imul (x2)
  4079:                           .iadd (ASINH_C25).imul (x2)
  4080:                             .iadd (ASINH_C23).imul (x2)
  4081:                               .iadd (ASINH_C21).imul (x2)
  4082:                                 .iadd (ASINH_C19).imul (x2)
  4083:                                   .iadd (ASINH_C17).imul (x2)
  4084:                                     .iadd (ASINH_C15).imul (x2)
  4085:                                       .iadd (ASINH_C13).imul (x2)
  4086:                                         .iadd (ASINH_C11).imul (x2)
  4087:                                           .iadd (ASINH_C9).imul (x2)
  4088:                                             .iadd (ASINH_C7).imul (x2)
  4089:                                               .iadd (ASINH_C5).imul (x2)
  4090:                                                 .iadd (ASINH_C3).imul (x2)
  4091:                                                   .iadd (ASINH_C1).outer ().mul (x);
  4092:       }
  4093:       //0.5<=|x|
  4094:       return this.iabs (x).iadd (new EFP ().isqu (this).inc ().sqrt ()).log ().outer ().neg (xf < 0);  //sgn(x)*log(|1/x|+sqrt((|1/x|)^2+1))
  4095:     }  //efp.acsch(EFP)
  4096: 
  4097:     //------------------------------------------------------------------------
  4098:     //x = x.add (y)
  4099:     //  x+=y
  4100:     //z = z.add (x, y)
  4101:     //  z=x+y
  4102:     //  加算
  4103:     //
  4104:     //  (xn/xd)+(yn/yd)
  4105:     //    =((xn*yd)/(xd*yd))+((xd*yn)/(xd*yd))
  4106:     //    =(xn*yd+xd*yn)/(xd*yd)
  4107:     //
  4108:     public final EFP add (EFP y) {
  4109:       int xf = this.flg;
  4110:       int xe = this.epp;
  4111:       long xd = this.dvl;
  4112:       long xc = this.cvl;
  4113:       long xb = 0L;
  4114:       int yf = y.flg;
  4115:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
  4116:         if ((xf | yf) << 3 < 0) {  //どちらかがNaNのときNaN
  4117:           this.flg = N;
  4118:           return this;
  4119:         }
  4120:         if ((xf & yf) << 2 < 0 && xf != yf) {  //両方±Infで符号が逆のときNaN
  4121:           epbFpsr |= EPB_FPSR_OE;
  4122:           epbExceptionOperandExponent = yf & M | 0x7fff << 16;
  4123:           epbExceptionOperandMantissa = 0x0000000000000000L;
  4124:           this.flg = N;
  4125:           return this;
  4126:         }
  4127:         if ((xf & yf) << 1 < 0 && xf != yf) {  //両方±0で符号が逆のとき
  4128:           this.flg = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //RMのとき-0,それ以外は+0
  4129:           return this;
  4130:         }
  4131:         if (xf << 1 < 0 || yf << 2 < 0) {  //xが±0またはyが±Infのときy
  4132:           xf = yf;
  4133:           xe = y.epp;
  4134:           xd = y.dvl;
  4135:           xc = y.cvl;
  4136:         }
  4137:         //xが±Infまたはyが±0のときx
  4138:       } else {  //両方±0,±Inf,NaN以外
  4139:         //加算なのでyの符号はそのまま
  4140:         long yd = y.dvl;
  4141:         long yc = y.cvl;
  4142:         int o = xe - y.epp;
  4143:         if (o < 0 || o == 0 && (xd < yd || xd == yd && xc >>> 1 < yc >>> 1)) {  //yの方が絶対値が大きい
  4144:           //xとyを入れ換える
  4145:           xf = yf;
  4146:           xe += o = -o;  //xe=y.epp
  4147:           xd = yd;
  4148:           xc = yc;
  4149:           yf = this.flg;  //後で符号を比較するときに使う
  4150:           yd = this.dvl;
  4151:           yc = this.cvl;
  4152:         }
  4153:         //xの方が絶対値が大きいか等しい
  4154:         //yを右にずらして小数点の位置を合わせる
  4155:         if (0 < o) {
  4156:           if (o <= 63) {
  4157:             xb = yc << -o;
  4158:             yc = yd << -o | yc >>> o;
  4159:             yd >>>= o;
  4160:           } else if (o == 64) {
  4161:             xb = yc;
  4162:             yc = yd;
  4163:             yd = 0L;
  4164:           } else if (o <= 127) {
  4165:             xb = yd << -o | yc;
  4166:             yc = yd >>> o;
  4167:             yd = 0L;
  4168:           } else {
  4169:             xb = yd | yc;  //絶対値減算を行うとき下位からのボローとして必要
  4170:             yc = 0L;
  4171:             yd = 0L;
  4172:           }
  4173:         }
  4174:         //絶対値加算または絶対値減算を行う
  4175:         if (xf == yf) {  //符号が同じなので絶対値加算を行う
  4176:           //yc[1]とyc[0]をsticky bitに押し出す
  4177:           xb |= yc << 62;
  4178:           //右にずらしてxd[63]を空ける
  4179:           xc = xd << 63 | xc >>> 1;
  4180:           xd >>>= 1;
  4181:           yc = yd << 63 | yc >>> 1;
  4182:           yd >>>= 1;
  4183:           //下位を右にずらしてxc[63]を空ける
  4184:           yc >>>= 1;
  4185:           xc >>>= 1;
  4186:           //足す
  4187:           xc += yc;
  4188:           xd += yd + (xc >>> 63);
  4189:           //下位を左にずらしてxc[63]を詰める
  4190:           xc <<= 1;
  4191:           //溢れの処理
  4192:           if (xd < 0L) {  //溢れたとき
  4193:             xe++;
  4194:           } else {  //溢れなかったとき
  4195:             xd = xd << 1 | xc >>> 63;  //左にずらしてxd[63]を詰める
  4196:             xc <<= 1;
  4197:           }
  4198:         } else {  //符号が異なるので絶対値減算を行う
  4199:           //yc[0]をsticky bitに押し出す
  4200:           xb |= yc << 63;
  4201:           //下位を右にずらしてxc[63]を空ける
  4202:           yc >>>= 1;
  4203:           xc >>>= 1;
  4204:           //引く
  4205:           //  xの方が絶対値が大きいか等しいので負になることはないが0になることがある
  4206:           if (xb != 0L) {
  4207:             xc--;
  4208:           }
  4209:           xc -= yc;
  4210:           xd -= yd + (xc >>> 63);
  4211:           //下位を左にずらしてxc[63]を詰める
  4212:           xc <<= 1;
  4213:           //正規化する
  4214:           if (0L <= xd) {
  4215:             if (xd != 0L) {
  4216:               xe -= o = Long.numberOfLeadingZeros (xd);
  4217:               xd = xd << o | xc >>> -o;
  4218:               xc <<= o;
  4219:             } else if (xc != 0L) {
  4220:               xe -= o = 64 + Long.numberOfLeadingZeros (xc);
  4221:               xd = xc << o;
  4222:               xc = 0L;
  4223:             } else {  //0になった
  4224:               xf = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //RMのとき-0,それ以外は+0
  4225:             }
  4226:           }
  4227:         }  //if 符号が同じなので絶対値加算を行う/符号が異なるので絶対値減算を行う
  4228:       }  //if どちらかが±0,±Inf,NaN/両方±0,±Inf,NaN以外
  4229:       return this.finish (xf, xe, xd, xc, xb);
  4230:     }  //efp.add(EFP)
  4231:     public final EFP iadd (EFP y) {
  4232:       int xf = this.flg;
  4233:       int xe = this.epp;
  4234:       long xd = this.dvl;
  4235:       long xc = this.cvl;
  4236:       long xb = 0L;
  4237:       int yf = y.flg;
  4238:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
  4239:         if ((xf | yf) << 3 < 0) {  //どちらかがNaNのときNaN
  4240:           this.flg = N;
  4241:           return this;
  4242:         }
  4243:         if ((xf & yf) << 2 < 0 && xf != yf) {  //両方±Infで符号が逆のときNaN
  4244:           epbFpsr |= EPB_FPSR_OE;
  4245:           epbExceptionOperandExponent = yf & M | 0x7fff << 16;
  4246:           epbExceptionOperandMantissa = 0x0000000000000000L;
  4247:           this.flg = N;
  4248:           return this;
  4249:         }
  4250:         if ((xf & yf) << 1 < 0 && xf != yf) {  //両方±0で符号が逆のとき
  4251:           this.flg = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //RMのとき-0,それ以外は+0
  4252:           return this;
  4253:         }
  4254:         if (xf << 1 < 0 || yf << 2 < 0) {  //xが±0またはyが±Infのときy
  4255:           xf = yf;
  4256:           xe = y.epp;
  4257:           xd = y.dvl;
  4258:           xc = y.cvl;
  4259:         }
  4260:         //xが±Infまたはyが±0のときx
  4261:       } else {  //両方±0,±Inf,NaN以外
  4262:         //加算なのでyの符号はそのまま
  4263:         long yd = y.dvl;
  4264:         long yc = y.cvl;
  4265:         int o = xe - y.epp;
  4266:         if (o < 0 || o == 0 && (xd < yd || xd == yd && xc >>> 1 < yc >>> 1)) {  //yの方が絶対値が大きい
  4267:           //xとyを入れ換える
  4268:           xf = yf;
  4269:           xe += o = -o;  //xe=y.epp
  4270:           xd = yd;
  4271:           xc = yc;
  4272:           yf = this.flg;  //後で符号を比較するときに使う
  4273:           yd = this.dvl;
  4274:           yc = this.cvl;
  4275:         }
  4276:         //xの方が絶対値が大きいか等しい
  4277:         //yを右にずらして小数点の位置を合わせる
  4278:         if (0 < o) {
  4279:           if (o <= 63) {
  4280:             xb = yc << -o;
  4281:             yc = yd << -o | yc >>> o;
  4282:             yd >>>= o;
  4283:           } else if (o == 64) {
  4284:             xb = yc;
  4285:             yc = yd;
  4286:             yd = 0L;
  4287:           } else if (o <= 127) {
  4288:             xb = yd << -o | yc;
  4289:             yc = yd >>> o;
  4290:             yd = 0L;
  4291:           } else {
  4292:             xb = yd | yc;  //絶対値減算を行うとき下位からのボローとして必要
  4293:             yc = 0L;
  4294:             yd = 0L;
  4295:           }
  4296:         }
  4297:         //絶対値加算または絶対値減算を行う
  4298:         if (xf == yf) {  //符号が同じなので絶対値加算を行う
  4299:           //yc[1]とyc[0]をsticky bitに押し出す
  4300:           xb |= yc << 62;
  4301:           //右にずらしてxd[63]を空ける
  4302:           xc = xd << 63 | xc >>> 1;
  4303:           xd >>>= 1;
  4304:           yc = yd << 63 | yc >>> 1;
  4305:           yd >>>= 1;
  4306:           //下位を右にずらしてxc[63]を空ける
  4307:           yc >>>= 1;
  4308:           xc >>>= 1;
  4309:           //足す
  4310:           xc += yc;
  4311:           xd += yd + (xc >>> 63);
  4312:           //下位を左にずらしてxc[63]を詰める
  4313:           xc <<= 1;
  4314:           //溢れの処理
  4315:           if (xd < 0L) {  //溢れたとき
  4316:             xe++;
  4317:           } else {  //溢れなかったとき
  4318:             xd = xd << 1 | xc >>> 63;  //左にずらしてxd[63]を詰める
  4319:             xc <<= 1;
  4320:           }
  4321:         } else {  //符号が異なるので絶対値減算を行う
  4322:           //yc[0]をsticky bitに押し出す
  4323:           xb |= yc << 63;
  4324:           //下位を右にずらしてxc[63]を空ける
  4325:           yc >>>= 1;
  4326:           xc >>>= 1;
  4327:           //引く
  4328:           //  xの方が絶対値が大きいか等しいので負になることはないが0になることがある
  4329:           if (xb != 0L) {
  4330:             xc--;
  4331:           }
  4332:           xc -= yc;
  4333:           xd -= yd + (xc >>> 63);
  4334:           //下位を左にずらしてxc[63]を詰める
  4335:           xc <<= 1;
  4336:           //正規化する
  4337:           if (0L <= xd) {
  4338:             if (xd != 0L) {
  4339:               xe -= o = Long.numberOfLeadingZeros (xd);
  4340:               xd = xd << o | xc >>> -o;
  4341:               xc <<= o;
  4342:             } else if (xc != 0L) {
  4343:               xe -= o = 64 + Long.numberOfLeadingZeros (xc);
  4344:               xd = xc << o;
  4345:               xc = 0L;
  4346:             } else {  //0になった
  4347:               xf = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //RMのとき-0,それ以外は+0
  4348:             }
  4349:           }
  4350:         }  //if 符号が同じなので絶対値加算を行う/符号が異なるので絶対値減算を行う
  4351:       }  //if どちらかが±0,±Inf,NaN/両方±0,±Inf,NaN以外
  4352:       return this.ifinish (xf, xe, xd, xc, xb);
  4353:     }  //efp.iadd(EFP)
  4354:     public final EFP add (EFP x, EFP y) {
  4355:       int xf = x.flg;
  4356:       int xe = x.epp;
  4357:       long xd = x.dvl;
  4358:       long xc = x.cvl;
  4359:       long xb = 0L;
  4360:       int yf = y.flg;
  4361:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
  4362:         if ((xf | yf) << 3 < 0) {  //どちらかがNaNのときNaN
  4363:           this.flg = N;
  4364:           return this;
  4365:         }
  4366:         if ((xf & yf) << 2 < 0 && xf != yf) {  //両方±Infで符号が逆のときNaN
  4367:           epbFpsr |= EPB_FPSR_OE;
  4368:           epbExceptionOperandExponent = yf & M | 0x7fff << 16;
  4369:           epbExceptionOperandMantissa = 0x0000000000000000L;
  4370:           this.flg = N;
  4371:           return this;
  4372:         }
  4373:         if ((xf & yf) << 1 < 0 && xf != yf) {  //両方±0で符号が逆のとき
  4374:           this.flg = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //RMのとき-0,それ以外は+0
  4375:           return this;
  4376:         }
  4377:         if (xf << 1 < 0 || yf << 2 < 0) {  //xが±0またはyが±Infのときy
  4378:           xf = yf;
  4379:           xe = y.epp;
  4380:           xd = y.dvl;
  4381:           xc = y.cvl;
  4382:         }
  4383:         //xが±Infまたはyが±0のときx
  4384:       } else {  //両方±0,±Inf,NaN以外
  4385:         //加算なのでyの符号はそのまま
  4386:         long yd = y.dvl;
  4387:         long yc = y.cvl;
  4388:         int o = xe - y.epp;
  4389:         if (o < 0 || o == 0 && (xd < yd || xd == yd && xc >>> 1 < yc >>> 1)) {  //yの方が絶対値が大きい
  4390:           //xとyを入れ換える
  4391:           xf = yf;
  4392:           xe += o = -o;  //xe=y.epp
  4393:           xd = yd;
  4394:           xc = yc;
  4395:           yf = x.flg;  //後で符号を比較するときに使う
  4396:           yd = x.dvl;
  4397:           yc = x.cvl;
  4398:         }
  4399:         //xの方が絶対値が大きいか等しい
  4400:         //yを右にずらして小数点の位置を合わせる
  4401:         if (0 < o) {
  4402:           if (o <= 63) {
  4403:             xb = yc << -o;
  4404:             yc = yd << -o | yc >>> o;
  4405:             yd >>>= o;
  4406:           } else if (o == 64) {
  4407:             xb = yc;
  4408:             yc = yd;
  4409:             yd = 0L;
  4410:           } else if (o <= 127) {
  4411:             xb = yd << -o | yc;
  4412:             yc = yd >>> o;
  4413:             yd = 0L;
  4414:           } else {
  4415:             xb = yd | yc;  //絶対値減算を行うとき下位からのボローとして必要
  4416:             yc = 0L;
  4417:             yd = 0L;
  4418:           }
  4419:         }
  4420:         //絶対値加算または絶対値減算を行う
  4421:         if (xf == yf) {  //符号が同じなので絶対値加算を行う
  4422:           //yc[1]とyc[0]をsticky bitに押し出す
  4423:           xb |= yc << 62;
  4424:           //右にずらしてxd[63]を空ける
  4425:           xc = xd << 63 | xc >>> 1;
  4426:           xd >>>= 1;
  4427:           yc = yd << 63 | yc >>> 1;
  4428:           yd >>>= 1;
  4429:           //下位を右にずらしてxc[63]を空ける
  4430:           yc >>>= 1;
  4431:           xc >>>= 1;
  4432:           //足す
  4433:           xc += yc;
  4434:           xd += yd + (xc >>> 63);
  4435:           //下位を左にずらしてxc[63]を詰める
  4436:           xc <<= 1;
  4437:           //溢れの処理
  4438:           if (xd < 0L) {  //溢れたとき
  4439:             xe++;
  4440:           } else {  //溢れなかったとき
  4441:             xd = xd << 1 | xc >>> 63;  //左にずらしてxd[63]を詰める
  4442:             xc <<= 1;
  4443:           }
  4444:         } else {  //符号が異なるので絶対値減算を行う
  4445:           //yc[0]をsticky bitに押し出す
  4446:           xb |= yc << 63;
  4447:           //下位を右にずらしてxc[63]を空ける
  4448:           yc >>>= 1;
  4449:           xc >>>= 1;
  4450:           //引く
  4451:           //  xの方が絶対値が大きいか等しいので負になることはないが0になることがある
  4452:           if (xb != 0L) {
  4453:             xc--;
  4454:           }
  4455:           xc -= yc;
  4456:           xd -= yd + (xc >>> 63);
  4457:           //下位を左にずらしてxc[63]を詰める
  4458:           xc <<= 1;
  4459:           //正規化する
  4460:           if (0L <= xd) {
  4461:             if (xd != 0L) {
  4462:               xe -= o = Long.numberOfLeadingZeros (xd);
  4463:               xd = xd << o | xc >>> -o;
  4464:               xc <<= o;
  4465:             } else if (xc != 0L) {
  4466:               xe -= o = 64 + Long.numberOfLeadingZeros (xc);
  4467:               xd = xc << o;
  4468:               xc = 0L;
  4469:             } else {  //0になった
  4470:               xf = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //RMのとき-0,それ以外は+0
  4471:             }
  4472:           }
  4473:         }  //if 符号が同じなので絶対値加算を行う/符号が異なるので絶対値減算を行う
  4474:       }  //if どちらかが±0,±Inf,NaN/両方±0,±Inf,NaN以外
  4475:       return this.finish (xf, xe, xd, xc, xb);
  4476:     }  //efp.add(EFP,EFP)
  4477:     public final EFP iadd (EFP x, EFP y) {
  4478:       int xf = x.flg;
  4479:       int xe = x.epp;
  4480:       long xd = x.dvl;
  4481:       long xc = x.cvl;
  4482:       long xb = 0L;
  4483:       int yf = y.flg;
  4484:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
  4485:         if ((xf | yf) << 3 < 0) {  //どちらかがNaNのときNaN
  4486:           this.flg = N;
  4487:           return this;
  4488:         }
  4489:         if ((xf & yf) << 2 < 0 && xf != yf) {  //両方±Infで符号が逆のときNaN
  4490:           epbFpsr |= EPB_FPSR_OE;
  4491:           epbExceptionOperandExponent = yf & M | 0x7fff << 16;
  4492:           epbExceptionOperandMantissa = 0x0000000000000000L;
  4493:           this.flg = N;
  4494:           return this;
  4495:         }
  4496:         if ((xf & yf) << 1 < 0 && xf != yf) {  //両方±0で符号が逆のとき
  4497:           this.flg = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //RMのとき-0,それ以外は+0
  4498:           return this;
  4499:         }
  4500:         if (xf << 1 < 0 || yf << 2 < 0) {  //xが±0またはyが±Infのときy
  4501:           xf = yf;
  4502:           xe = y.epp;
  4503:           xd = y.dvl;
  4504:           xc = y.cvl;
  4505:         }
  4506:         //xが±Infまたはyが±0のときx
  4507:       } else {  //両方±0,±Inf,NaN以外
  4508:         //加算なのでyの符号はそのまま
  4509:         long yd = y.dvl;
  4510:         long yc = y.cvl;
  4511:         int o = xe - y.epp;
  4512:         if (o < 0 || o == 0 && (xd < yd || xd == yd && xc >>> 1 < yc >>> 1)) {  //yの方が絶対値が大きい
  4513:           //xとyを入れ換える
  4514:           xf = yf;
  4515:           xe += o = -o;  //xe=y.epp
  4516:           xd = yd;
  4517:           xc = yc;
  4518:           yf = x.flg;  //後で符号を比較するときに使う
  4519:           yd = x.dvl;
  4520:           yc = x.cvl;
  4521:         }
  4522:         //xの方が絶対値が大きいか等しい
  4523:         //yを右にずらして小数点の位置を合わせる
  4524:         if (0 < o) {
  4525:           if (o <= 63) {
  4526:             xb = yc << -o;
  4527:             yc = yd << -o | yc >>> o;
  4528:             yd >>>= o;
  4529:           } else if (o == 64) {
  4530:             xb = yc;
  4531:             yc = yd;
  4532:             yd = 0L;
  4533:           } else if (o <= 127) {
  4534:             xb = yd << -o | yc;
  4535:             yc = yd >>> o;
  4536:             yd = 0L;
  4537:           } else {
  4538:             xb = yd | yc;  //絶対値減算を行うとき下位からのボローとして必要
  4539:             yc = 0L;
  4540:             yd = 0L;
  4541:           }
  4542:         }
  4543:         //絶対値加算または絶対値減算を行う
  4544:         if (xf == yf) {  //符号が同じなので絶対値加算を行う
  4545:           //yc[1]とyc[0]をsticky bitに押し出す
  4546:           xb |= yc << 62;
  4547:           //右にずらしてxd[63]を空ける
  4548:           xc = xd << 63 | xc >>> 1;
  4549:           xd >>>= 1;
  4550:           yc = yd << 63 | yc >>> 1;
  4551:           yd >>>= 1;
  4552:           //下位を右にずらしてxc[63]を空ける
  4553:           yc >>>= 1;
  4554:           xc >>>= 1;
  4555:           //足す
  4556:           xc += yc;
  4557:           xd += yd + (xc >>> 63);
  4558:           //下位を左にずらしてxc[63]を詰める
  4559:           xc <<= 1;
  4560:           //溢れの処理
  4561:           if (xd < 0L) {  //溢れたとき
  4562:             xe++;
  4563:           } else {  //溢れなかったとき
  4564:             xd = xd << 1 | xc >>> 63;  //左にずらしてxd[63]を詰める
  4565:             xc <<= 1;
  4566:           }
  4567:         } else {  //符号が異なるので絶対値減算を行う
  4568:           //yc[0]をsticky bitに押し出す
  4569:           xb |= yc << 63;
  4570:           //下位を右にずらしてxc[63]を空ける
  4571:           yc >>>= 1;
  4572:           xc >>>= 1;
  4573:           //引く
  4574:           //  xの方が絶対値が大きいか等しいので負になることはないが0になることがある
  4575:           if (xb != 0L) {
  4576:             xc--;
  4577:           }
  4578:           xc -= yc;
  4579:           xd -= yd + (xc >>> 63);
  4580:           //下位を左にずらしてxc[63]を詰める
  4581:           xc <<= 1;
  4582:           //正規化する
  4583:           if (0L <= xd) {
  4584:             if (xd != 0L) {
  4585:               xe -= o = Long.numberOfLeadingZeros (xd);
  4586:               xd = xd << o | xc >>> -o;
  4587:               xc <<= o;
  4588:             } else if (xc != 0L) {
  4589:               xe -= o = 64 + Long.numberOfLeadingZeros (xc);
  4590:               xd = xc << o;
  4591:               xc = 0L;
  4592:             } else {  //0になった
  4593:               xf = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //RMのとき-0,それ以外は+0
  4594:             }
  4595:           }
  4596:         }  //if 符号が同じなので絶対値加算を行う/符号が異なるので絶対値減算を行う
  4597:       }  //if どちらかが±0,±Inf,NaN/両方±0,±Inf,NaN以外
  4598:       return this.ifinish (xf, xe, xd, xc, xb);
  4599:     }  //efp.iadd(EFP,EFP)
  4600: 
  4601:     //------------------------------------------------------------------------
  4602:     //a = a.agi (b)
  4603:     //  a=I(a,b)
  4604:     //i = i.agi (a, b)
  4605:     //  i=I(a,b)
  4606:     //  算術幾何平均
  4607:     //
  4608:     //  グラフ
  4609:     //    echo read("efp.gp");eval("f(b)=if(0<b&&b<1,Pi/(2*agm(1,b)),error())");graph(f) | gp -q
  4610:     //    +---------+---------+---------+---------+*--------+---------+---------+---------+
  4611:     //    |                                       |*                                      |
  4612:     //    |                                       |*                                      |
  4613:     //    |                                       |*                                      |
  4614:     //    |                                       |**                                     |
  4615:     //    +                                       + *                                     +
  4616:     //    |                                       | **                                    |
  4617:     //    |                                       |  *                                    |
  4618:     //    |                                       |  **                                   |
  4619:     //    |                                       |   **                                  |
  4620:     //    +                                       +    ***                                +
  4621:     //    |                                       |      ***                              |
  4622:     //    |                                       |        **                             |
  4623:     //    |                                       |                                       |
  4624:     //    |                                       |                                       |
  4625:     //    +                                       +                                       +
  4626:     //    |                                       |                                       |
  4627:     //    |                                       |                                       |
  4628:     //    |                                       |                                       |
  4629:     //    |                                       |                                       |
  4630:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  4631:     //    |                                       |                                       |
  4632:     //    |                                       |                                       |
  4633:     //    |                                       |                                       |
  4634:     //    |                                       |                                       |
  4635:     //    +                                       +                                       +
  4636:     //    |                                       |                                       |
  4637:     //    |                                       |                                       |
  4638:     //    |                                       |                                       |
  4639:     //    |                                       |                                       |
  4640:     //    +                                       +                                       +
  4641:     //    |                                       |                                       |
  4642:     //    |                                       |                                       |
  4643:     //    |                                       |                                       |
  4644:     //    |                                       |                                       |
  4645:     //    +                                       +                                       +
  4646:     //    |                                       |                                       |
  4647:     //    |                                       |                                       |
  4648:     //    |                                       |                                       |
  4649:     //    |                                       |                                       |
  4650:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  4651:     //
  4652:     //  定義域
  4653:     //    0<b<1
  4654:     //
  4655:     //  値域
  4656:     //    pi/2<i<+inf
  4657:     //
  4658:     //  I(a,b)=int[0..pi/2]{dt/sqrt(a^2*cos(t)^2+b^2*sin(t)^2)}
  4659:     //        =1/2*int[-inf..inf]{dt/sqrt((a^2+t^2)*(b^2+t^2))}
  4660:     //        =pi/(2*M(a,b))
  4661:     //
  4662:     public final EFP agi (EFP be) {
  4663:       return this.agi (this, be);
  4664:     }  //efp.agi(EFP)
  4665:     public final EFP agi (EFP ae, EFP be) {
  4666:       return this.agm (ae, be).rcpdiv (PI_2);  //pi/(2*M(a,b))
  4667:     }  //efp.agi(EFP,EFP)
  4668: 
  4669:     //------------------------------------------------------------------------
  4670:     //a = a.agm (b)
  4671:     //  a=M(a,b)
  4672:     //m = m.agm (a, b)
  4673:     //  m=M(a,b)
  4674:     //  算術幾何平均
  4675:     //
  4676:     //  グラフ
  4677:     //    echo read("efp.gp");eval("f(b)=if(0<b&&b<1,agm(1,b),error())");graph(f) | gp -q
  4678:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  4679:     //    |                                       |                                       |
  4680:     //    |                                       |                                       |
  4681:     //    |                                       |                                       |
  4682:     //    |                                       |                                       |
  4683:     //    +                                       +                                       +
  4684:     //    |                                       |                                       |
  4685:     //    |                                       |                                       |
  4686:     //    |                                       |                                       |
  4687:     //    |                                       |                                       |
  4688:     //    +                                       +                                       +
  4689:     //    |                                       |                                       |
  4690:     //    |                                       |                                       |
  4691:     //    |                                       |                                       |
  4692:     //    |                                       |                                       |
  4693:     //    +                                       +       ***                             +
  4694:     //    |                                       |    ****                               |
  4695:     //    |                                       | ****                                  |
  4696:     //    |                                       ***                                     |
  4697:     //    |                                       *                                       |
  4698:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  4699:     //    |                                       |                                       |
  4700:     //    |                                       |                                       |
  4701:     //    |                                       |                                       |
  4702:     //    |                                       |                                       |
  4703:     //    +                                       +                                       +
  4704:     //    |                                       |                                       |
  4705:     //    |                                       |                                       |
  4706:     //    |                                       |                                       |
  4707:     //    |                                       |                                       |
  4708:     //    +                                       +                                       +
  4709:     //    |                                       |                                       |
  4710:     //    |                                       |                                       |
  4711:     //    |                                       |                                       |
  4712:     //    |                                       |                                       |
  4713:     //    +                                       +                                       +
  4714:     //    |                                       |                                       |
  4715:     //    |                                       |                                       |
  4716:     //    |                                       |                                       |
  4717:     //    |                                       |                                       |
  4718:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  4719:     //
  4720:     //  定義域
  4721:     //    0<b<1
  4722:     //
  4723:     //  値域
  4724:     //    0<m<1
  4725:     //
  4726:     //    a[0]=1
  4727:     //    b[0]=b
  4728:     //    a[n+1]=(a[n]+b[n])/2
  4729:     //    b[n+1]=sqrt(a[n]*b[n])
  4730:     //    M(1,b)=lim[n=inf]{a[n]}
  4731:     //          =lim[n=inf]{b[n]}
  4732:     //
  4733:     public final EFP agm (EFP be) {
  4734:       return this.agm (this, be);
  4735:     }  //efp.agm(EFP)
  4736:     public final EFP agm (EFP ae, EFP be) {
  4737:       int af = ae.flg;
  4738:       int bf = be.flg;
  4739:       if ((af | bf) != 0) {  //どちらかが±0,±Inf,NaN,-x
  4740:         this.flg = ((af | bf) << 3 < 0 ||  //agm(NaN,b)=agm(a,NaN)=NaN
  4741:                     ((af | bf) & (Z | I)) == (Z | I) ? N :  //agm(±0,±Inf)=agm(±Inf,±0)=NaN
  4742:                     (af | bf) << 1 < 0 ? P | Z :  //agm(±0,b)=agm(a,±0)=+0
  4743:                     (af | bf) < 0 ? N :  //agm(a<0,b!=0)=agm(a!=0,b<0)=NaN
  4744:                     P | I);  //agm(+Inf,b>0)=agm(a>0,+Inf)=+Inf
  4745:         return this;
  4746:       }
  4747:       //両方±0,±Inf,NaN,-x以外
  4748:       EFP t = new EFP ();
  4749:       EFP u = new EFP ();
  4750:       EFP v = new EFP ();
  4751:       if (ae.ge (be)) {  //b<=a
  4752:         //u.sete (ae);
  4753:         u.flg = ae.flg;
  4754:         u.epp = ae.epp;
  4755:         u.dvl = ae.dvl;
  4756:         u.cvl = ae.cvl;
  4757:         //v.sete (be);
  4758:         v.flg = be.flg;
  4759:         v.epp = be.epp;
  4760:         v.dvl = be.dvl;
  4761:         v.cvl = be.cvl;
  4762:       } else {  //a<b
  4763:         //u.sete (be);
  4764:         u.flg = be.flg;
  4765:         u.epp = be.epp;
  4766:         u.dvl = be.dvl;
  4767:         u.cvl = be.cvl;
  4768:         //v.sete (ae);
  4769:         v.flg = ae.flg;
  4770:         v.epp = ae.epp;
  4771:         v.dvl = ae.dvl;
  4772:         v.cvl = ae.cvl;
  4773:       }
  4774:       //  0<b<=a
  4775:       //  0<sqrt(a*b)<=(a+b)/2
  4776:       this.inner ();
  4777:       for (;;) {
  4778:         //  u=a,v=b
  4779:         t.iadd (u, v).idiv2 ();  //t=(a+b)/2。算術平均
  4780:         if (t.ge (u)) {  //0<b<aのままaとbが近付くのでaが減らなくなったら終了
  4781:           return this.outer ().sete (u).finish ();
  4782:         }
  4783:         v.imul (u).sqrt ();  //b=sqrt(a*b)。幾何平均
  4784:         //  t=a,v=b
  4785:         u.iadd (t, v).idiv2 ();  //u=(a+b)/2。算術平均
  4786:         if (u.ge (t)) {  //0<b<aのままaとbが近付くのでaが減らなくなったら終了
  4787:           return this.outer ().sete (t).finish ();
  4788:         }
  4789:         v.imul (t).sqrt ();  //b=sqrt(a*b)。幾何平均
  4790:       }
  4791:     }  //efp.agm(EFP,EFP)
  4792: 
  4793:     //------------------------------------------------------------------------
  4794:     //x = x.asec ()
  4795:     //  x=asec(x)
  4796:     //y = y.asec (x)
  4797:     //  y=asec(x)
  4798:     //  逆正割 inverse secant インバースセカント
  4799:     //
  4800:     //  グラフ
  4801:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{asec($_[0])});print$g"
  4802:     //    echo read("efp.gp");eval("asec(x)=if(x>=0,atan(sqrt(x^2-1)),Pi-atan(sqrt(x^2-1)))");graph(asec) | gp -q
  4803:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  4804:     //    |                                       |                                       |
  4805:     //    |                                       |                                       |
  4806:     //    |                                       |                                       |
  4807:     //    |                             *         |                                       |
  4808:     //    +                             *         +                                       +
  4809:     //    |                            **         |                                       |
  4810:     //    |                           **          |                                       |
  4811:     //    |                        ****           |                                       |
  4812:     //    |                   ******              |                                       |
  4813:     //    +        ************                   +                                       +
  4814:     //    **********                              |                                       |
  4815:     //    |                                       |                                       |
  4816:     //    |                                       |                                    ****
  4817:     //    |                                       |                     ****************  |
  4818:     //    +                                       +               *******                 +
  4819:     //    |                                       |            ****                       |
  4820:     //    |                                       |          ***                          |
  4821:     //    |                                       |         **                            |
  4822:     //    |                                       |         *                             |
  4823:     //    +---------+---------+---------+---------+---------*---------+---------+---------+
  4824:     //    |                                       |                                       |
  4825:     //    |                                       |                                       |
  4826:     //    |                                       |                                       |
  4827:     //    |                                       |                                       |
  4828:     //    +                                       +                                       +
  4829:     //    |                                       |                                       |
  4830:     //    |                                       |                                       |
  4831:     //    |                                       |                                       |
  4832:     //    |                                       |                                       |
  4833:     //    +                                       +                                       +
  4834:     //    |                                       |                                       |
  4835:     //    |                                       |                                       |
  4836:     //    |                                       |                                       |
  4837:     //    |                                       |                                       |
  4838:     //    +                                       +                                       +
  4839:     //    |                                       |                                       |
  4840:     //    |                                       |                                       |
  4841:     //    |                                       |                                       |
  4842:     //    |                                       |                                       |
  4843:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  4844:     //
  4845:     //  定義域
  4846:     //    inf<=x<=1
  4847:     //    1<=x<=inf
  4848:     //
  4849:     //  値域
  4850:     //    0<=y<=pi
  4851:     //
  4852:     //  逆三角関数との関係
  4853:     //    asec(x)=atan2(sqrt(x^2-1),sgn(x))
  4854:     //           =x>=0?atan(sqrt(x^2-1)):pi-atan(sqrt(x^2-1))
  4855:     //
  4856:     public final EFP asec () {
  4857:       return this.asec (this);
  4858:     }  //efp.asec()
  4859:     public final EFP asec (EFP x) {
  4860:       int xf = x.flg;
  4861:       if (x.cmp1abs () < 0) {  //|x|<1
  4862:         epbFpsr |= EPB_FPSR_OE;
  4863:         if (xf << 1 < 0) {  //±0
  4864:           epbExceptionOperandExponent = xf & M;
  4865:           epbExceptionOperandMantissa = 0x0000000000000000L;
  4866:         } else {  //|±x|<1
  4867:           epbExceptionOperandExponent = xf & M | 0x3fff + x.epp << 16;
  4868:           epbExceptionOperandMantissa = x.dvl;
  4869:         }
  4870:         this.flg = N;
  4871:         return this;
  4872:       }
  4873:       EFP t = new EFP ().inner ().dec (x);
  4874:       this.inc (x).imul (t).sqrt ();
  4875:       return (xf < 0 ?
  4876:               this.atan ().negsub (PI).outer ().add (PIA) :  //pi-atan(sqrt((x-1)*(x+1)))
  4877:               this.outer ().atan ());  //atan(sqrt((x-1)*(x+1)))。x^2-1だと1+εのとき精度が低い
  4878:     }  //efp.asec(EFP)
  4879: 
  4880:     //------------------------------------------------------------------------
  4881:     //x = x.asech ()
  4882:     //  x=asech(x)
  4883:     //y = y.asech (x)
  4884:     //  y=asech(x)
  4885:     //  逆双曲線正割 inverse hyperbolic secant インバースハイパボリックセカント
  4886:     //
  4887:     //  グラフ
  4888:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{asech($_[0])});print$g"
  4889:     //    echo read("efp.gp");eval("asech(x)=log(1/x+sqrt(1/x^2-1))");graph(asech) | gp -q
  4890:     //    +---------+---------+---------+---------*---------+---------+---------+---------+
  4891:     //    |                                       *                                       |
  4892:     //    |                                       **                                      |
  4893:     //    |                                       |*                                      |
  4894:     //    |                                       |*                                      |
  4895:     //    +                                       +*                                      +
  4896:     //    |                                       |*                                      |
  4897:     //    |                                       |**                                     |
  4898:     //    |                                       | *                                     |
  4899:     //    |                                       | *                                     |
  4900:     //    +                                       + **                                    +
  4901:     //    |                                       |  **                                   |
  4902:     //    |                                       |   *                                   |
  4903:     //    |                                       |   **                                  |
  4904:     //    |                                       |    **                                 |
  4905:     //    +                                       +     **                                +
  4906:     //    |                                       |      **                               |
  4907:     //    |                                       |       **                              |
  4908:     //    |                                       |        **                             |
  4909:     //    |                                       |         *                             |
  4910:     //    +---------+---------+---------+---------+---------*---------+---------+---------+
  4911:     //    |                                       |                                       |
  4912:     //    |                                       |                                       |
  4913:     //    |                                       |                                       |
  4914:     //    |                                       |                                       |
  4915:     //    +                                       +                                       +
  4916:     //    |                                       |                                       |
  4917:     //    |                                       |                                       |
  4918:     //    |                                       |                                       |
  4919:     //    |                                       |                                       |
  4920:     //    +                                       +                                       +
  4921:     //    |                                       |                                       |
  4922:     //    |                                       |                                       |
  4923:     //    |                                       |                                       |
  4924:     //    |                                       |                                       |
  4925:     //    +                                       +                                       +
  4926:     //    |                                       |                                       |
  4927:     //    |                                       |                                       |
  4928:     //    |                                       |                                       |
  4929:     //    |                                       |                                       |
  4930:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  4931:     //
  4932:     //  定義域
  4933:     //    0<x<=1
  4934:     //
  4935:     //  値域
  4936:     //    0<=y<=inf
  4937:     //
  4938:     //  逆双曲線関数との関係
  4939:     //    asech(x)=acosh(1/x)
  4940:     //
  4941:     //  対数関数との関係
  4942:     //    asech(x)=log(1/x+sqrt(1/x^2-1))
  4943:     //            =log1p(1/x-1+sqrt((1/x-1)*(1/x+1)))
  4944:     //            =log1p(1/x-1+sqrt((1/x-1)^2+2*(1/x-1)))
  4945:     //            =log1p((1-x)/x+sqrt(((1-x)/x)^2+2*(1-x)/x))
  4946:     //
  4947:     public final EFP asech () {
  4948:       return this.asech (this);
  4949:     }  //efp.asech()
  4950:     public final EFP asech (EFP x) {
  4951:       //return this.rcp (x).acosh ();  //1-εのとき精度が低い
  4952:       int xf = x.flg;
  4953:       if (xf != 0) {  //-x,±0,±Inf,NaN
  4954:         if (xf < 0 || xf << 2 < 0) {  //-x,-0,±Inf
  4955:           epbFpsr |= EPB_FPSR_OE;
  4956:           if (xf == (M | Z)) {  //-0
  4957:             epbExceptionOperandExponent = M;
  4958:             epbExceptionOperandMantissa = 0x0000000000000000L;
  4959:           } else if (xf << 2 < 0) {  //±Inf
  4960:             epbExceptionOperandExponent = xf & M | 0x7fff << 16;
  4961:             epbExceptionOperandMantissa = 0x0000000000000000L;
  4962:           } else {  //-x
  4963:             epbExceptionOperandExponent = M | 0x3fff + x.epp << 16;
  4964:             epbExceptionOperandMantissa = x.dvl;
  4965:           }
  4966:           this.flg = N;  //asech(-x)=NaN, asech(-0)=NaN, asech(±Inf)=NaN
  4967:         } else {  //+0,NaN
  4968:           this.flg = xf << 1 < 0 ? P | I : N;  //asech(+0)=+Inf, asech(NaN)=NaN
  4969:         }
  4970:         return this;
  4971:       }
  4972:       //x<0,±0,±Inf,NaN以外
  4973:       if (0 <= x.epp) {  //1<=|x|
  4974:         if (x.epp == 0 && x.dvl == MSB && x.cvl == 0L) {  //|x|==1
  4975:           this.flg = P | Z;  //+0
  4976:         } else {  //1<|x|
  4977:           epbFpsr |= EPB_FPSR_OE;
  4978:           epbExceptionOperandExponent = xf | 0x3fff + x.epp << 16;
  4979:           epbExceptionOperandMantissa = x.dvl;
  4980:           this.flg = N;  //NaN
  4981:         }
  4982:         return this;
  4983:       }
  4984:       //|x|<1
  4985:       EFP t = new EFP ().inner ().negdec (x).div (x);  //(1-x)/x
  4986:       return this.iadd (t, new EFP ().isqu (t).iadd (new EFP ().imul2 (t)).sqrt ()).outer ().log1p ();  //log1p((1-x)/x+sqrt(((1-x)/x)^2+2*(1-x)/x))
  4987:     }  //efp.asech(EFP)
  4988: 
  4989:     //------------------------------------------------------------------------
  4990:     //x = x.asin ()
  4991:     //  x=asin(x)
  4992:     //y = y.asin (x)
  4993:     //  y=asin(x)
  4994:     //  逆正弦 inverse sine インバースサイン
  4995:     //
  4996:     //  グラフ
  4997:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{asin($_[0])});print$g"
  4998:     //    echo read("efp.gp");graph(asin) | gp -q
  4999:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  5000:     //    |                                       |                                       |
  5001:     //    |                                       |                                       |
  5002:     //    |                                       |                                       |
  5003:     //    |                                       |                                       |
  5004:     //    +                                       +                                       +
  5005:     //    |                                       |                                       |
  5006:     //    |                                       |                                       |
  5007:     //    |                                       |                                       |
  5008:     //    |                                       |                                       |
  5009:     //    +                                       +                                       +
  5010:     //    |                                       |                                       |
  5011:     //    |                                       |         *                             |
  5012:     //    |                                       |         *                             |
  5013:     //    |                                       |        **                             |
  5014:     //    +                                       +       **                              +
  5015:     //    |                                       |     ***                               |
  5016:     //    |                                       |    **                                 |
  5017:     //    |                                       |  ***                                  |
  5018:     //    |                                       |***                                    |
  5019:     //    +---------+---------+---------+--------***--------+---------+---------+---------+
  5020:     //    |                                    ***|                                       |
  5021:     //    |                                  ***  |                                       |
  5022:     //    |                                 **    |                                       |
  5023:     //    |                               ***     |                                       |
  5024:     //    +                              **       +                                       +
  5025:     //    |                             **        |                                       |
  5026:     //    |                             *         |                                       |
  5027:     //    |                             *         |                                       |
  5028:     //    |                                       |                                       |
  5029:     //    +                                       +                                       +
  5030:     //    |                                       |                                       |
  5031:     //    |                                       |                                       |
  5032:     //    |                                       |                                       |
  5033:     //    |                                       |                                       |
  5034:     //    +                                       +                                       +
  5035:     //    |                                       |                                       |
  5036:     //    |                                       |                                       |
  5037:     //    |                                       |                                       |
  5038:     //    |                                       |                                       |
  5039:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  5040:     //
  5041:     //  定義域
  5042:     //    -1<=x<=1
  5043:     //
  5044:     //  値域
  5045:     //    -pi/2<=y<=pi/2
  5046:     //
  5047:     //  逆三角関数との関係
  5048:     //    asin(x)=atan2(x,sqrt(1-x^2))
  5049:     //           =atan2(x,sqrt((1-x)*(1+x)))
  5050:     //           =atan(x/sqrt(1-x^2))
  5051:     //           =atan(x/sqrt((1-x)*(1+x)))
  5052:     //           =pi/2-acos(x)
  5053:     //           =acsc(1/x)
  5054:     //
  5055:     //  微分
  5056:     //    df{asin(x)}=1/sqrt(1-x^2)
  5057:     //
  5058:     //  積分表示
  5059:     //    asin(x)=int[t=0..x]{dt/sqrt(1-t^2)}
  5060:     //
  5061:     //  テイラー展開
  5062:     //    積分表示を二項展開してから項別積分する
  5063:     //      二項展開
  5064:     //        (1+x)^n=sum[m=0..inf]{ncm(n,m)*x^m}
  5065:     //               =sum[m=0..inf]{n!/(m!*(n-m)!)*x^m}
  5066:     //               =sum[m=0..inf]{prod[k=0..m-1]{n-k}/m!*x^m}  (prodで項が1つもないときの値は1とする)
  5067:     //    asin(x)=int[t=0..x]{dt/sqrt(1-t^2)}
  5068:     //           =int[t=0..x]{(1-t^2)^(-1/2)*dt}
  5069:     //      二項展開する
  5070:     //           =int[t=0..x]{sum[m=0..inf]{prod[k=0..m-1]{-1/2-k}/m!*(-t^2)^m}*dt}
  5071:     //           =int[t=0..x]{sum[m=0..inf]{(-1)^m*prod[k=0..m-1]{2*k+1}/2^m/m!*(-1)^m*t^(2*m)}*dt}
  5072:     //           =int[t=0..x]{sum[m=0..inf]{prod[k=0..m-1]{2*k+1}/2^m/m!*t^(2*m)}*dt}
  5073:     //      項別積分する
  5074:     //           =sum[m=0..inf]{prod[k=0..m-1]{2*k+1}/2^m/m!*int[t=0..x]{t^(2*m)*dt}}
  5075:     //           =sum[m=0..inf]{prod[k=0..m-1]{2*k+1}/2^m/m!/(2*m+1)*x^(2*m+1)}
  5076:     //           =1/2^0/1/1*x^1+(1)/2^1/(1)/3*x^3+(1*3)/2^2/(1*2)/5*x^5+(1*3*5)/2^3/(1*2*3)/7*x^7+(1*3*5*7)/2^4/(1*2*3*4)/9*x^9+...
  5077:     //           =1/1/1*x^1+(1)/(2)/3*x^3+(1*3)/(2*4)/5*x^5+(1*3*5)/(2*4*6)/7*x^7+(1*3*5*7)/(2*4*6*8)/9*x^9+...
  5078:     //           =x+1/6*x^3+3/40*x^5+5/112*x^7+35/1152*x^9+...
  5079:     //    > coeff(sub(a=0,for n:=0:10 sum sub(x=a,df(asin(x),x,n))/factorial(n)*(x-a)^n),x);
  5080:     //            1     3       5       35
  5081:     //    {0,1,0,---,0,----,0,-----,0,------}
  5082:     //            6     40     112     1152
  5083:     //    |x|が1に近いとき収束が遅い
  5084:     //
  5085:     //  連分数展開
  5086:     //    asin(x)=x/(1-(1*x)^2/(2*3+(1*x)^2-2*3*(3*x)^2/(4*5+(3*x)^2-4*5*(5*x)^2/(6*7+(5*x)^2-6*7*(7*x)^2/(8*9+(7*x)^2-...)))))
  5087:     //      テイラー展開と同じ
  5088:     //
  5089:     public final EFP asin () {
  5090:       return this.asin (this);
  5091:     }  //efp.asin()
  5092:     public final EFP asin (EFP x) {
  5093:       int xf = x.flg;
  5094:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  5095:         if (xf << 2 < 0) {  //±Inf
  5096:           epbFpsr |= EPB_FPSR_OE;
  5097:           epbExceptionOperandExponent = xf & M | 0x7fff << 16;
  5098:           epbExceptionOperandMantissa = 0x0000000000000000L;
  5099:           this.flg = N;  //asin(±Inf)=NaN
  5100:         } else {  //±0,NaN
  5101:           this.flg = xf;  //asin(±0)=±0, asin(NaN)=NaN
  5102:         }
  5103:         return this;
  5104:       }
  5105:       //±0,±Inf,NaN以外
  5106:       int xe = x.epp;
  5107:       if (0 <= xe) {  //1<=|x|
  5108:         if (xe == 0 && x.dvl == MSB && x.cvl == 0L) {  //|x|==1
  5109:           epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  5110:           epbExceptionOperandExponent = xf | 0x3fff + x.epp << 16;
  5111:           epbExceptionOperandMantissa = x.dvl;
  5112:           if (0 <= xf) {
  5113:             this.sete (ROUNDED_PI_2[epbRoundingMode]).finish ();  //asin(1)=pi/2
  5114:           } else {
  5115:             this.sete (ROUNDED_NEGPI_2[epbRoundingMode]).finish ();  //asin(-1)=-pi/2
  5116:           }
  5117:         } else {  //1<|x|
  5118:           epbFpsr |= EPB_FPSR_OE;
  5119:           epbExceptionOperandExponent = xf | 0x3fff + x.epp << 16;
  5120:           epbExceptionOperandMantissa = x.dvl;
  5121:           this.flg = N;
  5122:         }
  5123:         return this;
  5124:       }
  5125:       //|x|<1
  5126:       epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  5127:       epbExceptionOperandExponent = xf | 0x3fff + x.epp << 16;
  5128:       epbExceptionOperandMantissa = x.dvl;
  5129:       if (x.epp < -4) {  //|x|<1/16
  5130:         //atan2を使う方法はxが±0に近すぎると誤差で|asin(x)|<|x|になってしまうことがある
  5131:         //±0の近くだけチェビシェフ展開を使う
  5132:         int savedFpsr = epbFpsr;
  5133:         this.inner ();
  5134:         if (this == x) {
  5135:           x = new EFP (x);
  5136:         }
  5137:         EFP x2 = new EFP ().isqu (x);  //x^2
  5138:         this.imul (ASIN_C17, x2)
  5139:           .iadd (ASIN_C15).imul (x2)
  5140:             .iadd (ASIN_C13).imul (x2)
  5141:               .iadd (ASIN_C11).imul (x2)
  5142:                 .iadd (ASIN_C9).imul (x2)
  5143:                   .iadd (ASIN_C7).imul (x2)
  5144:                     .iadd (ASIN_C5).imul (x2)
  5145:                       .iadd (ASIN_C3).imul (x2)
  5146:                         .iadd (ASIN_C1).outer ().mul (x);
  5147:         return this.originLowerUpper (x).correctUnderflow (savedFpsr);
  5148:       }
  5149:       //1/16<=|x|<1
  5150:       this.inner ();
  5151:       EFP t = new EFP ().negdec (x).imul (new EFP ().inc (x)).sqrt ();
  5152:       return this.outer ().atan2 (x, t);  //atan2(x,sqrt((1-x)*(1+x))) [90]
  5153:     }  //efp.asin(EFP)
  5154: 
  5155:     //------------------------------------------------------------------------
  5156:     //x = x.asinh ()
  5157:     //  x=asinh(x)
  5158:     //y = y.asinh (x)
  5159:     //  y=asinh(x)
  5160:     //  逆双曲線正弦 inverse hyperbolic sine インバースハイパボリックサイン
  5161:     //
  5162:     //  グラフ
  5163:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{asinh($_[0])});print$g"
  5164:     //    echo read("efp.gp");graph(asinh) | gp -q
  5165:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  5166:     //    |                                       |                                       |
  5167:     //    |                                       |                                       |
  5168:     //    |                                       |                                       |
  5169:     //    |                                       |                                       |
  5170:     //    +                                       +                                       +
  5171:     //    |                                       |                                       |
  5172:     //    |                                       |                                       |
  5173:     //    |                                       |                                       |
  5174:     //    |                                       |                                       |
  5175:     //    +                                       +                                ********
  5176:     //    |                                       |                         ********      |
  5177:     //    |                                       |                    ******             |
  5178:     //    |                                       |                *****                  |
  5179:     //    |                                       |            *****                      |
  5180:     //    +                                       +         ****                          +
  5181:     //    |                                       |       ***                             |
  5182:     //    |                                       |    ****                               |
  5183:     //    |                                       |  ***                                  |
  5184:     //    |                                       |***                                    |
  5185:     //    +---------+---------+---------+--------***--------+---------+---------+---------+
  5186:     //    |                                    ***|                                       |
  5187:     //    |                                  ***  |                                       |
  5188:     //    |                               ****    |                                       |
  5189:     //    |                             ***       |                                       |
  5190:     //    +                          ****         +                                       +
  5191:     //    |                      *****            |                                       |
  5192:     //    |                  *****                |                                       |
  5193:     //    |             ******                    |                                       |
  5194:     //    |      ********                         |                                       |
  5195:     //    ********                                +                                       +
  5196:     //    |                                       |                                       |
  5197:     //    |                                       |                                       |
  5198:     //    |                                       |                                       |
  5199:     //    |                                       |                                       |
  5200:     //    +                                       +                                       +
  5201:     //    |                                       |                                       |
  5202:     //    |                                       |                                       |
  5203:     //    |                                       |                                       |
  5204:     //    |                                       |                                       |
  5205:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  5206:     //
  5207:     //  定義域
  5208:     //    -inf<=x<=inf
  5209:     //
  5210:     //  値域
  5211:     //    -inf<=y<=inf
  5212:     //
  5213:     //  対数関数との関係
  5214:     //    asinh(x)=sgn(x)*log(abs(x)+sqrt(x^2+1))
  5215:     //            =sgn(x)*log(abs(x)+sqrt((abs(x)-1)*(abs(x)+1)+2))
  5216:     //
  5217:     //  マクローリン展開
  5218:     //    http://mathworld.wolfram.com/InverseHyperbolicSine.html
  5219:     //    |x|<1のとき
  5220:     //    asinh(x)=sum[n=0..inf]{(-1)^n*(2*n-1)!!/((2*n+1)*(2*n)!!)*x^(2*n+1)}
  5221:     //            =1!!/(1*0!!)*x^1-1!!/(3*2!!)*x^3+3!!/(5*4!!)*x^5-5!!/(7*6!!)*x^7+7!!/(9*8!!)*x^9-9!!/(11*10!!)*x^11+...
  5222:     //            =x-1/(3*2)*x^3+1*3/(5*2*4)*x^5-1*3*5/(7*2*4*6)*x^7+1*3*5*7/(9*2*4*6*8)*x^9-1*3*5*7*9/(11*2*4*6*8*10)*x^11+...
  5223:     //            =x-1/6*x^3+3/40*x^5-5/112*x^7+35/1152*x^9-63/2816*x^11+...
  5224:     //
  5225:     //  ピュイズー展開
  5226:     //    http://mathworld.wolfram.com/InverseHyperbolicSine.html
  5227:     //    asinh(x)=-log(1/x)+log(2)+sum[n=1..inf]{(-1)^(n-1)*(2*n-1)!!/(2*n*(2*n)!!)*x^(-2*n))}
  5228:     //            =-log(1/x)+log(2)+1/4/x^2-3/32/x^4+5/96/x^6-...
  5229:     //
  5230:     //  チェビシェフ展開
  5231:     //    0の近くだけチェビシェフ展開を使う
  5232:     //    echo read("efp.gp");eval("f(x)=asinh(x)");a=-0.25;b=0.25;nmax=41;print1("    //    ");forstep(n=1,nmax,2,printf("%4d",n));print();print1("    //    ");forstep(n=1,nmax,2,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000))));print() | gp -q
  5233:     //       1   3   5   7   9  11  13  15  17  19  21  23  25  27  29  31  33  35  37  39  41
  5234:     //       7  13  19  26  32  38  44  50  56  62  69  75  81  87  93  99 105 111 117 123 129
  5235:     //
  5236:     public final EFP asinh () {
  5237:       return this.asinh (this);
  5238:     }  //efp.asinh()
  5239:     public final EFP asinh (EFP x) {
  5240:       int xf = x.flg;
  5241:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  5242:         this.flg = xf;  //asinh(±0), asinh(±Inf)=±Inf, asinh(NaN)=NaN
  5243:         return this;
  5244:       }
  5245:       //±0,±Inf,NaN以外
  5246:       if (x.epp < -1) {  //|x|<0.5
  5247:         int savedFpsr = epbFpsr;
  5248:         this.inner ();
  5249:         if (this == x) {
  5250:           x = new EFP (x);
  5251:         }
  5252:         EFP x2 = new EFP ().isqu (x);
  5253:         this.imul (ASINH_C43, x2)
  5254:           .iadd (ASINH_C41).imul (x2)
  5255:             .iadd (ASINH_C39).imul (x2)
  5256:               .iadd (ASINH_C37).imul (x2)
  5257:                 .iadd (ASINH_C35).imul (x2)
  5258:                   .iadd (ASINH_C33).imul (x2)
  5259:                     .iadd (ASINH_C31).imul (x2)
  5260:                       .iadd (ASINH_C29).imul (x2)
  5261:                         .iadd (ASINH_C27).imul (x2)
  5262:                           .iadd (ASINH_C25).imul (x2)
  5263:                             .iadd (ASINH_C23).imul (x2)
  5264:                               .iadd (ASINH_C21).imul (x2)
  5265:                                 .iadd (ASINH_C19).imul (x2)
  5266:                                   .iadd (ASINH_C17).imul (x2)
  5267:                                     .iadd (ASINH_C15).imul (x2)
  5268:                                       .iadd (ASINH_C13).imul (x2)
  5269:                                         .iadd (ASINH_C11).imul (x2)
  5270:                                           .iadd (ASINH_C9).imul (x2)
  5271:                                             .iadd (ASINH_C7).imul (x2)
  5272:                                               .iadd (ASINH_C5).imul (x2)
  5273:                                                 .iadd (ASINH_C3).imul (x2)
  5274:                                                   .iadd (ASINH_C1).outer ().mul (x);
  5275:         return this.originUpperLower (x).correctUnderflow (savedFpsr);
  5276:       }
  5277:       //0.5<=|x|
  5278:       EFP t = new EFP ().inner ().iabs (x);
  5279:       return this.isqu (t).inc ().sqrt ().iadd (t).log ().outer ().neg (xf < 0);  //sgn(x)*log(abs(x)+sqrt(x^2+1))
  5280:     }  //efp.asinh(EFP)
  5281: 
  5282:     //------------------------------------------------------------------------
  5283:     //x = x.atan ()
  5284:     //  x=atan(x)
  5285:     //y = y.atan (x)
  5286:     //  y=atan(x)
  5287:     //  逆正接 inverse tangent インバースタンジェント
  5288:     //
  5289:     //  グラフ
  5290:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{atan($_[0])});print$g"
  5291:     //    echo read("efp.gp");graph(atan) | gp -q
  5292:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  5293:     //    |                                       |                                       |
  5294:     //    |                                       |                                       |
  5295:     //    |                                       |                                       |
  5296:     //    |                                       |                                       |
  5297:     //    +                                       +                                       +
  5298:     //    |                                       |                                       |
  5299:     //    |                                       |                                       |
  5300:     //    |                                       |                                       |
  5301:     //    |                                       |                                       |
  5302:     //    +                                       +                                       +
  5303:     //    |                                       |                                       |
  5304:     //    |                                       |                                       |
  5305:     //    |                                       |                                   *****
  5306:     //    |                                       |                   *****************   |
  5307:     //    +                                       +            ********                   +
  5308:     //    |                                       |       ******                          |
  5309:     //    |                                       |    ****                               |
  5310:     //    |                                       |  ***                                  |
  5311:     //    |                                       |***                                    |
  5312:     //    +---------+---------+---------+--------***--------+---------+---------+---------+
  5313:     //    |                                    ***|                                       |
  5314:     //    |                                  ***  |                                       |
  5315:     //    |                               ****    |                                       |
  5316:     //    |                          ******       |                                       |
  5317:     //    +                   ********            +                                       +
  5318:     //    |   *****************                   |                                       |
  5319:     //    *****                                   |                                       |
  5320:     //    |                                       |                                       |
  5321:     //    |                                       |                                       |
  5322:     //    +                                       +                                       +
  5323:     //    |                                       |                                       |
  5324:     //    |                                       |                                       |
  5325:     //    |                                       |                                       |
  5326:     //    |                                       |                                       |
  5327:     //    +                                       +                                       +
  5328:     //    |                                       |                                       |
  5329:     //    |                                       |                                       |
  5330:     //    |                                       |                                       |
  5331:     //    |                                       |                                       |
  5332:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  5333:     //
  5334:     //  定義域
  5335:     //    -inf<=x<=inf
  5336:     //
  5337:     //  値域
  5338:     //    -pi/2<=atan(x)<=pi/2
  5339:     //    加法定理を用いるときは値域からはみ出さないように注意すること
  5340:     //
  5341:     //  逆三角関数との関係
  5342:     //    asin(x)=atan(x/sqrt(1-x^2))
  5343:     //    acos(x)=pi/2-atan(x/sqrt(1-x^2))
  5344:     //
  5345:     //  加法定理
  5346:     //    atan(a)+atan(b)=atan((a+b)/(1-a*b))  a*b!=1
  5347:     //    atan(a)-atan(b)=atan((a-b)/(1+a*b))  a*b!=-1
  5348:     //    値域が-pi/2<atan(x)<=pi/2に制限されるので左辺の値と右辺の値がpiだけずれる場合があることに注意
  5349:     //    atan(x)+atan((1-x)/(1+x))=atan((x+(1-x)/(1+x))/(1-x*(1-x)/(1+x)))
  5350:     //                             =atan((x*(1+x)+(1-x))/((1+x)-x*(1-x)))
  5351:     //                             =atan((x+x^2+1-x)/(1+x-x+x^2))
  5352:     //                             =atan((1+x^2)/(1+x^2))
  5353:     //                             =atan(1)
  5354:     //                             =pi/4     -1<xのとき
  5355:     //                              -3/4*pi  x<-1のとき
  5356:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{atan($_[0])+atan((1-$_[0])/(1+$_[0]))});print$g"
  5357:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  5358:     //    |                                       |                                       |
  5359:     //    |                                       |                                       |
  5360:     //    |                                       |                                       |
  5361:     //    |                                       |                                       |
  5362:     //    +                                       +                                       +
  5363:     //    |                                       |                                       |
  5364:     //    |                                       |                                       |
  5365:     //    |                                       |                                       |
  5366:     //    |                                       |                                       |
  5367:     //    +                                       +                                       +
  5368:     //    |                                       |                                       |
  5369:     //    |                                       |                                       |
  5370:     //    |                                       |                                       |
  5371:     //    |                                       |                                       |
  5372:     //    +                                       +                                       +
  5373:     //    |                             ***************************************************
  5374:     //    |                                       |                                       |
  5375:     //    |                                       |                                       |
  5376:     //    |                                       |                                       |
  5377:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  5378:     //    |                                       |                                       |
  5379:     //    |                                       |                                       |
  5380:     //    |                                       |                                       |
  5381:     //    |                                       |                                       |
  5382:     //    +                                       +                                       +
  5383:     //    |                                       |                                       |
  5384:     //    |                                       |                                       |
  5385:     //    |                                       |                                       |
  5386:     //    |                                       |                                       |
  5387:     //    +                                       +                                       +
  5388:     //    |                                       |                                       |
  5389:     //    *******************************         |                                       |
  5390:     //    |                                       |                                       |
  5391:     //    |                                       |                                       |
  5392:     //    +                                       +                                       +
  5393:     //    |                                       |                                       |
  5394:     //    |                                       |                                       |
  5395:     //    |                                       |                                       |
  5396:     //    |                                       |                                       |
  5397:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  5398:     //    atan(x)+atan(1/x)=sgn(x)*pi/2
  5399:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{atan($_[0])+atan(1/$_[0])});print$g"
  5400:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  5401:     //    |                                       |                                       |
  5402:     //    |                                       |                                       |
  5403:     //    |                                       |                                       |
  5404:     //    |                                       |                                       |
  5405:     //    +                                       +                                       +
  5406:     //    |                                       |                                       |
  5407:     //    |                                       |                                       |
  5408:     //    |                                       |                                       |
  5409:     //    |                                       |                                       |
  5410:     //    +                                       +                                       +
  5411:     //    |                                       |                                       |
  5412:     //    |                                       *****************************************
  5413:     //    |                                       |                                       |
  5414:     //    |                                       |                                       |
  5415:     //    +                                       +                                       +
  5416:     //    |                                       |                                       |
  5417:     //    |                                       |                                       |
  5418:     //    |                                       |                                       |
  5419:     //    |                                       |                                       |
  5420:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  5421:     //    |                                       |                                       |
  5422:     //    |                                       |                                       |
  5423:     //    |                                       |                                       |
  5424:     //    |                                       |                                       |
  5425:     //    +                                       +                                       +
  5426:     //    |                                       |                                       |
  5427:     //    |                                       |                                       |
  5428:     //    *****************************************                                       |
  5429:     //    |                                       |                                       |
  5430:     //    +                                       +                                       +
  5431:     //    |                                       |                                       |
  5432:     //    |                                       |                                       |
  5433:     //    |                                       |                                       |
  5434:     //    |                                       |                                       |
  5435:     //    +                                       +                                       +
  5436:     //    |                                       |                                       |
  5437:     //    |                                       |                                       |
  5438:     //    |                                       |                                       |
  5439:     //    |                                       |                                       |
  5440:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  5441:     //
  5442:     //  例外
  5443:     //    |x|<=2^(-LEN/2)のときatan(x)=xとみなす
  5444:     //      テイラー展開よりatan(x)=x-1/3*x^3+1/5*x^5-1/7*x^7+...である
  5445:     //      |x|<=2^(-LEN/2)ならば|-1/3*x^3|/|x|=1/3*x^2<=1/3*2^(-LEN)であるから、
  5446:     //      仮数部がLENbitの浮動小数点数では|x|<=2^(-LEN/2)のときatan(x)とxを区別できない
  5447:     //      echo for(n=1,10,x=eval("10^-n");printf("    //      x=%.10f atan(x)=%.10f%c",x,atan(x),10)) | gp -q
  5448:     //      x=0.1000000000 atan(x)=0.0996686525
  5449:     //      x=0.0100000000 atan(x)=0.0099996667
  5450:     //      x=0.0010000000 atan(x)=0.0009999997
  5451:     //      x=0.0001000000 atan(x)=0.0001000000
  5452:     //      x=0.0000100000 atan(x)=0.0000100000
  5453:     //      x=0.0000010000 atan(x)=0.0000010000
  5454:     //      x=0.0000001000 atan(x)=0.0000001000
  5455:     //      x=0.0000000100 atan(x)=0.0000000100
  5456:     //      x=0.0000000010 atan(x)=0.0000000010
  5457:     //      x=0.0000000001 atan(x)=0.0000000001
  5458:     //    |x|>=2^(LEN+1)のときatan(x)=sgn(x)*pi/2とみなす
  5459:     //      atan(x)+atan(1/x)=sgn(x)*pi/2よりatan(x)-sgn(x)*pi/2=atan(1/x)=1/x-1/(3*x^3)+1/(5*x^5)-1/(7*x^7)+...である
  5460:     //      |x|>=2^(LEN+1)ならば|1/x|<=2^(-LEN-1)であるから、
  5461:     //      仮数部がLENbitの浮動小数点数では|x|>=2^(LEN+1)のときatan(x)とsgn(x)*pi/2を区別できない
  5462:     //      echo for(n=1,10,x=eval("10^n");printf("    //      1/x=%.10f pi/2-atan(x)=%.10f%c",1/x,Pi/2-atan(x),10)) | gp -q
  5463:     //      1/x=0.1000000000 pi/2-atan(x)=0.0996686525
  5464:     //      1/x=0.0100000000 pi/2-atan(x)=0.0099996667
  5465:     //      1/x=0.0010000000 pi/2-atan(x)=0.0009999997
  5466:     //      1/x=0.0001000000 pi/2-atan(x)=0.0001000000
  5467:     //      1/x=0.0000100000 pi/2-atan(x)=0.0000100000
  5468:     //      1/x=0.0000010000 pi/2-atan(x)=0.0000010000
  5469:     //      1/x=0.0000001000 pi/2-atan(x)=0.0000001000
  5470:     //      1/x=0.0000000100 pi/2-atan(x)=0.0000000100
  5471:     //      1/x=0.0000000010 pi/2-atan(x)=0.0000000010
  5472:     //      1/x=0.0000000001 pi/2-atan(x)=0.0000000001
  5473:     //
  5474:     //  符号除去
  5475:     //    符号を付けたままだと加法定理が使いにくいので0<=xにする
  5476:     //    atan(x)は奇関数
  5477:     //      atan(x)=-atan(-x)
  5478:     //
  5479:     //  変数変換
  5480:     //    収束を速くするために0<=x<=sqrt(2)-1にする
  5481:     //    0<=x<=sqrt(2)-1のとき
  5482:     //      y=atan(x)
  5483:     //      除算は不要
  5484:     //    sqrt(2)-1<x<1+sqrt(2)のとき
  5485:     //      x'=(1-x)/(1+x)
  5486:     //      y'=atan(x')
  5487:     //      y=pi/4-y'
  5488:     //       =pi/4-atan(x')
  5489:     //       =pi/4-atan((1-x)/(1+x))
  5490:     //        -1<xのときatan(x)+atan((1-x)/(1+x))=pi/4なので
  5491:     //       =atan(x)
  5492:     //      多項式を用いるときは除算が1回必要
  5493:     //    1+sqrt(2)<=xのとき
  5494:     //      x'=1/x
  5495:     //      y'=atan(x')
  5496:     //      y=pi/2-y'
  5497:     //       =pi/2-atan(x')
  5498:     //       =pi/2-atan(1/x)
  5499:     //        0<xのときatan(x)+atan(1/x)=pi/2なので
  5500:     //       =atan(x)
  5501:     //      多項式を用いるときは除算が1回必要
  5502:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{my$a=abs($_[0]);$a<=sqrt(2)-1?$a:$a<1+sqrt(2)?(1-$a)/(1+$a):1/$a});print$g"
  5503:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  5504:     //    |                                       |                                       |
  5505:     //    |                                       |                                       |
  5506:     //    |                                       |                                       |
  5507:     //    |                                       |                                       |
  5508:     //    +                                       +                                       +
  5509:     //    |                                       |                                       |
  5510:     //    |                                       |                                       |
  5511:     //    |                                       |                                       |
  5512:     //    |                                       |                                       |
  5513:     //    +                                       +                                       +
  5514:     //    |                                       |                                       |
  5515:     //    |                                       |                                       |
  5516:     //    |                                       |                                       |
  5517:     //    |                                       |                                       |
  5518:     //    +                                       +                                       +
  5519:     //    |                                       |                                       |
  5520:     //    |                                       |                                       |
  5521:     //    |      **********                  ***  |  ***                  **********      |
  5522:     //    ********                        **** ***|*** ****                        ********
  5523:     //    +---------+---------+-------*****------***------*****-------+---------+---------+
  5524:     //    |                    ********           |           ********                    |
  5525:     //    |               ******                  |                  ******               |
  5526:     //    |                                       |                                       |
  5527:     //    |                                       |                                       |
  5528:     //    +                                       +                                       +
  5529:     //    |                                       |                                       |
  5530:     //    |                                       |                                       |
  5531:     //    |                                       |                                       |
  5532:     //    |                                       |                                       |
  5533:     //    +                                       +                                       +
  5534:     //    |                                       |                                       |
  5535:     //    |                                       |                                       |
  5536:     //    |                                       |                                       |
  5537:     //    |                                       |                                       |
  5538:     //    +                                       +                                       +
  5539:     //    |                                       |                                       |
  5540:     //    |                                       |                                       |
  5541:     //    |                                       |                                       |
  5542:     //    |                                       |                                       |
  5543:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  5544:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$PI=4*atan(1);$g->func(sub{my$x=$_[0];my $a=abs($x);($x<=>0)*($a<=sqrt(2)-1?atan($a):$a<1+sqrt(2)?$PI/4-atan((1-$a)/(1+$a)):$PI/2-atan(1/$a))});print$g"
  5545:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  5546:     //    |                                       |                                       |
  5547:     //    |                                       |                                       |
  5548:     //    |                                       |                                       |
  5549:     //    |                                       |                                       |
  5550:     //    +                                       +                                       +
  5551:     //    |                                       |                                       |
  5552:     //    |                                       |                                       |
  5553:     //    |                                       |                                       |
  5554:     //    |                                       |                                       |
  5555:     //    +                                       +                                       +
  5556:     //    |                                       |                                       |
  5557:     //    |                                       |                                       |
  5558:     //    |                                       |                                   *****
  5559:     //    |                                       |                   *****************   |
  5560:     //    +                                       +            ********                   +
  5561:     //    |                                       |       ******                          |
  5562:     //    |                                       |    ****                               |
  5563:     //    |                                       |  ***                                  |
  5564:     //    |                                       |***                                    |
  5565:     //    +---------+---------+---------+--------***--------+---------+---------+---------+
  5566:     //    |                                    ***|                                       |
  5567:     //    |                                  ***  |                                       |
  5568:     //    |                               ****    |                                       |
  5569:     //    |                          ******       |                                       |
  5570:     //    +                   ********            +                                       +
  5571:     //    |   *****************                   |                                       |
  5572:     //    *****                                   |                                       |
  5573:     //    |                                       |                                       |
  5574:     //    |                                       |                                       |
  5575:     //    +                                       +                                       +
  5576:     //    |                                       |                                       |
  5577:     //    |                                       |                                       |
  5578:     //    |                                       |                                       |
  5579:     //    |                                       |                                       |
  5580:     //    +                                       +                                       +
  5581:     //    |                                       |                                       |
  5582:     //    |                                       |                                       |
  5583:     //    |                                       |                                       |
  5584:     //    |                                       |                                       |
  5585:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  5586:     //
  5587:     //  テイラー展開
  5588:     //      atan(x)=x-1/3*x^3+1/5*x^5-1/7*x^7+...
  5589:     //      f(n,x)=sum(k=0,n,(-1)^k*1/(2*k+1)*x^(2*k+1))
  5590:     //    収束が遅い
  5591:     //    除算は不要
  5592:     //
  5593:     //  連分数展開
  5594:     //      atan(x)=x/(1+x^2/(3+4*x^2/(5+9*x^2/(7+16*x^2/(9+...n^2*x^2/(2*n+1))))))
  5595:     //      g(n,x,k)=k^2*x^2/(2*k+1+if(k<n,g(n,x,k+1),0))
  5596:     //      f(n,x)=x/(1+if(n<1,0,g(n,x,1)))
  5597:     //      echo eval("g(n,x,k)=k^2*x^2/(2*k+1+if(k<n,g(n,x,k+1),0))");eval("f(n,x)=x/(1+if(n<1,0,g(n,x,1)))");for(n=0,10,print("    //      f(",n,",x)=",f(n,x))) | gp -q
  5598:     //      f(0,x)=x
  5599:     //      f(1,x)=3*x/(x^2 + 3)
  5600:     //      f(2,x)=(4*x^3 + 15*x)/(9*x^2 + 15)
  5601:     //      f(3,x)=(55*x^3 + 105*x)/(9*x^4 + 90*x^2 + 105)
  5602:     //      f(4,x)=(64*x^5 + 735*x^3 + 945*x)/(225*x^4 + 1050*x^2 + 945)
  5603:     //      f(5,x)=(231*x^5 + 1190*x^3 + 1155*x)/(25*x^6 + 525*x^4 + 1575*x^2 + 1155)
  5604:     //      f(6,x)=(256*x^7 + 5943*x^5 + 19250*x^3 + 15015*x)/(1225*x^6 + 11025*x^4 + 24255*x^2 + 15015)
  5605:     //      f(7,x)=(15159*x^7 + 147455*x^5 + 345345*x^3 + 225225*x)/(1225*x^8 + 44100*x^6 + 242550*x^4 + 420420*x^2 + 225225)
  5606:     //      f(8,x)=(16384*x^9 + 638055*x^7 + 3738735*x^5 + 6831825*x^3 + 3828825*x)/(99225*x^8 + 1455300*x^6 + 5675670*x^4 + 8108100*x^2 + 3828825)
  5607:     //      f(9,x)=(307835*x^9 + 4813380*x^7 + 19801782*x^5 + 29609580*x^3 + 14549535*x)/(19845*x^10 + 1091475*x^8 + 9459450*x^6 + 28378350*x^4 + 34459425*x^2 + 14549535)
  5608:     //      f(10,x)=(327680*x^11 + 19225635*x^9 + 175855680*x^7 + 552473922*x^5 + 698377680*x^3 + 305540235*x)/(2401245*x^10 + 52026975*x^8 + 312161850*x^6 + 758107350*x^4 + 800224425*x^2 + 305540235)
  5609:     //      分子は(n|1)次(n>>1)項、分母は(n+1&~1)次(n+1>>1)項、合わせてn+2項
  5610:     //    テイラー展開よりも収束が速い
  5611:     //    分母が定数ではないので除算が必要
  5612:     //    1項ずつ除算するのは効率が悪いので通分して分子の多項式と分母の多項式をそれぞれ計算して最後に割ったほうが速い
  5613:     //    それでも除算が1回必要
  5614:     //
  5615:     //  チェビシェフ展開
  5616:     //    テイラー展開よりも収束が速い
  5617:     //    変数変換で|x|<=sqrt(2)-1にしてから展開する
  5618:     //    sqrt(2)-1<|x|のとき変数変換に除算が1回必要
  5619:     //    変数変換の都合で符号を分離していても奇関数のまま展開した方が収束が速い
  5620:     //
  5621:     //  tan(x)を高速に計算できる場合
  5622:     //    組み込み関数を使ってatan(x)の近似値t'を求める
  5623:     //    tan(x)を使ってx'=tan(t')を正確に求める。これは正確なのでatan(x')=t'である
  5624:     //    atan(x)=atan(x')+atan((x-x')/(1+x*x'))
  5625:     //           =t'+atan((x-x')/(1+x*x'))
  5626:     //    (x-x')/(1+x*x')は小さいのでatan((x-x')/(1+x*x'))は速く収束する
  5627:     //
  5628:     //  CORDIC
  5629:     //    基本
  5630:     //      座標(u[k],v[k])を向き+x→+yで角度t[k]だけ回転した座標(u[k+1],v[k+1])は
  5631:     //        u[k+1]=cos(t[k])*u[k]-sin(t[k])*v[k]
  5632:     //        v[k+1]=sin(t[k])*u[k]+cos(t[k])*v[k]
  5633:     //      である
  5634:     //      原点から見た方向だけが必要で原点からの距離は変化しても構わないとき
  5635:     //        cos(t[k])=1
  5636:     //        sin(t[k])=tan(t[k])
  5637:     //      とおけば
  5638:     //        u[k+1]=u[k]-tan(t[k])*v[k]
  5639:     //        v[k+1]=v[k]+tan(t[k])*u[k]
  5640:     //      となる
  5641:     //      向き+y→+xのときは
  5642:     //        v[k+1]=cos(t[k])*v[k]-sin(t[k])*u[k]
  5643:     //        u[k+1]=sin(t[k])*v[k]+cos(t[k])*u[k]
  5644:     //      であるから
  5645:     //        u[k+1]=u[k]+tan(t[k])*v[k]
  5646:     //        v[k+1]=v[k]-tan(t[k])*u[k]
  5647:     //      となる
  5648:     //    準備
  5649:     //      tan(t[k])=1/2^kに固定してt[k]のテーブルを用意する
  5650:     //        t[k]=atan(1/2^k)
  5651:     //    手順
  5652:     //      座標(u[0],v[0])ただしu[0]>0が与えられたとき、
  5653:     //      k=0,1,2,…について
  5654:     //        座標(u[k],v[k])がx軸よりも上にあるとき(v[k]>=0)
  5655:     //          (u[k],v[k])をt[k]だけ右回転した方向にある座標を(u[k+1],v[k+1])とする
  5656:     //            u[k+1]=u[k]-v[k]/2^k
  5657:     //            v[k+1]=v[k]+u[k]/2^k
  5658:     //        座標(u[k],v[k])がx軸よりも下にあるとき(v[k]<0)
  5659:     //          (u[k],v[k])をt[k]だけ左回転した方向にある座標を(u[k+1],v[k+1])とする
  5660:     //            u[k+1]=u[k]+v[k]/2^k
  5661:     //            v[k+1]=v[k]-u[k]/2^k
  5662:     //      を繰り返すと、座標(u[k],v[k])はx軸に近付いてゆく
  5663:     //      座標(u[k],v[k])とx軸のなす角はatan(v[k],u[k])であるから、kが十分に大きくなったとき
  5664:     //        右回転した角度の合計-左回転した角度の合計
  5665:     //      は座標(u[0],v[0])とx軸のなす角、すなわちatan2(v[0],u[0])である
  5666:     //    高速化1
  5667:     //      atan(1/2^1)≒0.463
  5668:     //      |x|<=sqrt(2)-1≒0.414
  5669:     //      atan(1/2^2)≒0.245
  5670:     //      であるから少なくともk=0とk=1は不要
  5671:     //      指数部を見てkの開始位置を決めればよい
  5672:     //      k=8あたりまでと仮数部の先頭4bitくらいをテーブル参照で処理することで固定小数点の上位のビットを排除してビット数を確保する
  5673:     //    高速化2
  5674:     //      x→0のときatan(x)≒x-x^3/3であるから、有効桁数の1/3まで回して結果にv[k]/u[k]を加えてもよい
  5675:     //      しかし、このままだと除算が必要
  5676:     //      t→0のとき1-cos(t)≒t^2/2であるから、u[0]が1などの定数のときは有効桁数の1/2まで回せばu[k]も定数になる
  5677:     //      u==1のときは有効桁数の1/2まで回して結果にv[k]*(1/K)を加えればよい
  5678:     //    乗算の回数は少ないが加減算の回数が多い
  5679:     //    1要素の固定小数点のときは速い
  5680:     //    2要素以上になると固定小数点でもキャリーやボローの処理が加わるため遅くなる
  5681:     //
  5682:     //  ガウス求積
  5683:     //    atan(x)は積分で表されるのでルジャンドル多項式を用いて近似式を構築することができる
  5684:     //    atan(x)=int[t=0..x]{1/(1+t^2)}
  5685:     //           =1/2*int[t=-x..x]{1/(1+t^2)}
  5686:     //           =x/2*int[t=-1..1]{1/(1+x^2*t^2)}
  5687:     //
  5688:     //  AGM
  5689:     //    Fast multiple-precision evaluation of elementary functions (1976)
  5690:     //    http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.98.4721
  5691:     //      S=2^(-n/2)
  5692:     //      V=x/(1+sqrt(1+x^2))
  5693:     //      Q=1
  5694:     //      while 1-S>2^(-n) {
  5695:     //        Q=2*Q/(1+S)
  5696:     //        W=2*S*V/(1+V^2)
  5697:     //        W=W/(1+sqrt(1-W^2))
  5698:     //        W=(V+W)/(1-V*W)
  5699:     //        V=W/(1+sqrt(1+W^2))
  5700:     //        S=2*sqrt(S)/(1+S)
  5701:     //      }
  5702:     //      return Q*log((1+V)/(1-V))
  5703:     //    多倍長演算用。桁数が少ないときは遅い
  5704:     //
  5705:     //  テイラー展開
  5706:     //    echo read("efp.gp");eval("f(n,x)=sum(k=0,n,(-1)^k*1/(2*k+1)*x^(2*k+1))");a=1-sqrt(2);b=sqrt(2)-1;nmax=27;print1("    //    ");for(n=0,nmax,printf("%4d",2*n+1));print();print1("    //    ");for(n=0,nmax,printf("%4d",floor(closeness(atan,f(n,x),a,b,10000))));print() | gp -q
  5707:     //       1   3   5   7   9  11  13  15  17  19  21  23  25  27  29  31  33  35  37  39  41  43  45  47  49  51  53  55
  5708:     //       4   7  10  13  16  19  21  24  27  29  32  35  37  40  43  45  48  51  53  56  58  61  64  66  69  71  74  77
  5709:     //
  5710:     //  連分数展開
  5711:     //    echo read("efp.gp");eval("g(n,x,k)=k^2*x^2/(2*k+1+if(k<n,g(n,x,k+1),0))");eval("f(n,x)=x/(1+if(n<1,0,g(n,x,1)))");a=1-sqrt(2);b=sqrt(2)-1;nmax=27;print1("    //    ");for(n=0,nmax,printf("%4d",2*n+1));print();print1("    //    ");for(n=0,nmax,printf("%4d",floor(closeness(atan,f(n,x),a,b,10000))));print() | gp -q
  5712:     //       1   3   5   7   9  11  13  15  17  19  21  23  25  27  29  31  33  35  37  39  41  43  45  47  49  51  53  55
  5713:     //       4   8  13  18  22  27  31  36  41  45  50  55  59  64  69  73  78  83  87  92  97 101 106 111 115 120 125 129
  5714:     //
  5715:     //  チェビシェフ展開
  5716:     //    echo read("efp.gp");a=1-sqrt(2);b=sqrt(2)-1;nmax=55;print1("    //    ");forstep(n=1,nmax,2,printf("%4d",n));print();print1("    //    ");forstep(n=1,nmax,2,printf("%4d",floor(closeness(atan,chebyshev(atan,a,b,n),a,b,10000))));print() | gp -q
  5717:     //       1   3   5   7   9  11  13  15  17  19  21  23  25  27  29  31  33  35  37  39  41  43  45  47  49  51  53  55
  5718:     //       4   9  13  18  23  27  32  37  41  46  51  55  60  65  69  74  79  83  88  93  97 102 107 111 116 121 125 130
  5719:     //
  5720:     public final EFP atan () {
  5721:       return this.atan (this);
  5722:     }  //efp.atan()
  5723:     public final EFP atan (EFP x) {
  5724:       int xf = x.flg;
  5725:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  5726:         if (xf << 2 >= 0) {  //atan(±0)=±0,atan(NaN)=NaN
  5727:           this.flg = xf;
  5728:         } else {
  5729:           epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  5730:           if (xf >= 0) {
  5731:             this.sete (ROUNDED_PI_2[epbRoundingMode]).finish ();  //atan(+Inf)=pi/2
  5732:           } else {
  5733:             this.sete (ROUNDED_NEGPI_2[epbRoundingMode]).finish ();  //atan(-Inf)=-pi/2
  5734:           }
  5735:         }
  5736:         return this;
  5737:       }
  5738:       //±0,±Inf,NaN以外
  5739:       int xe = x.epp;
  5740:       if (xe <= -LEN / 2) {  //|x|<=2^(-LEN/2) --> atan(x)=x
  5741:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  5742:         int savedFpsr = epbFpsr;
  5743:         //this.sete (x);
  5744:         this.flg = xf;
  5745:         this.epp = xe;
  5746:         this.dvl = x.dvl;
  5747:         this.cvl = x.cvl;
  5748:         if (this.flg < 0) {
  5749:           if (epbRoundingMode == EPB_MODE_RZ || epbRoundingMode == EPB_MODE_RP) {
  5750:             this.nextup (epbRoundingPrec);
  5751:           }
  5752:         } else {
  5753:           if (epbRoundingMode == EPB_MODE_RZ || epbRoundingMode == EPB_MODE_RM) {
  5754:             this.nextdown (epbRoundingPrec);
  5755:           }
  5756:         }
  5757:         return this.finish ().correctUnderflow (savedFpsr);
  5758:       }
  5759:       if (LEN + 1 <= xe) {  //2^(LEN+1)<=|x| --> atan(x)=sgn(x)*pi/2
  5760:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  5761:         return this.sete (ROUNDED_PI_2[epbRoundingMode]).neg (xf < 0);
  5762:       }
  5763:       if (false) {  //[91] 600ns
  5764:         this.inner ();
  5765:         EFP u = new EFP ().iabs (x);  //|x|
  5766:         EFP b;
  5767:         EFP bw;
  5768:         EFP t = new EFP ();
  5769:         if (u.le (DECSQRT2)) {  //0<=x<=sqrt(2)-1
  5770:           b = null;  //y=y'
  5771:           bw = null;
  5772:         } else if (u.lt (INCSQRT2)) {  //sqrt(2)-1<x<1+sqrt(2)
  5773:           //t.inc (u);
  5774:           //u.imul2 ().div (t).negdec ();  //x'=1-(2*x)/(1+x)
  5775:           u.div (t.negdec (u), u.inc ());  //x'=(1-x)/(1+x)
  5776:           b = PI_4;  //y=pi/4-y'
  5777:           bw = PI_4A;
  5778:         } else {  //1+sqrt(2)<=x
  5779:           u.rcp ();  //x'=1/x
  5780:           b = PI_2;  //y=pi/2-y'
  5781:           bw = PI_2A;
  5782:         }
  5783:         if (false) {  //テイラー展開
  5784:           EFP x2 = new EFP (u).isqu ();  //x^2
  5785:           //this.set0 ();  //0
  5786:           this.flg = P | Z;
  5787:           for (int k = 0; ; k++) {
  5788:             t.divi (u, 2 * k + 1);  //1/(2*k+1)*x^(2*k+1)
  5789:             if ((k & 1) == 0) {
  5790:               t.iadd (this, t);  //(-1)^k*1/(2*k+1)*x^(2*k+1)
  5791:             } else {
  5792:               t.sub (this, t);  //(-1)^k*1/(2*k+1)*x^(2*k+1)
  5793:             }
  5794:             if (this.eq (t)) {
  5795:               break;
  5796:             }
  5797:             //this.sete (t);
  5798:             this.flg = t.flg;
  5799:             this.epp = t.epp;
  5800:             this.dvl = t.dvl;
  5801:             this.cvl = t.cvl;
  5802:             u.imul (x2);
  5803:           }
  5804:         } else {  //チェビシェフ展開
  5805:           t.isqu (u);  //u^2
  5806:           this.imul (ATAN_C39, t)
  5807:             .iadd (ATAN_C37).imul (t)
  5808:               .iadd (ATAN_C35).imul (t)
  5809:                 .iadd (ATAN_C33).imul (t)
  5810:                   .iadd (ATAN_C31).imul (t)
  5811:                     .iadd (ATAN_C29).imul (t)
  5812:                       .iadd (ATAN_C27).imul (t)
  5813:                         .iadd (ATAN_C25).imul (t)
  5814:                           .iadd (ATAN_C23).imul (t)
  5815:                             .iadd (ATAN_C21).imul (t)
  5816:                               .iadd (ATAN_C19).imul (t)
  5817:                                 .iadd (ATAN_C17).imul (t)
  5818:                                   .iadd (ATAN_C15).imul (t)
  5819:                                     .iadd (ATAN_C13).imul (t)
  5820:                                       .iadd (ATAN_C11).imul (t)
  5821:                                         .iadd (ATAN_C9).imul (t)
  5822:                                           .iadd (ATAN_C7).imul (t)
  5823:                                             .iadd (ATAN_C5).imul (t)
  5824:                                               .iadd (ATAN_C3).imul (t)
  5825:                                                 .iadd (ATAN_C1).imul (u);
  5826:         }
  5827:         if (b != null) {
  5828:           this.negsub (b).iadd (bw);  //y=pi/4-y'またはy=pi/2-y'
  5829:         }
  5830:         return this.outer ().neg (xf < 0);
  5831:       } else {  //tanを使う。[91] 540ns
  5832:         int savedFpsr = epbFpsr;
  5833:         this.inner ();
  5834:         if (this == x) {
  5835:           x = new EFP (x);  //必要なときだけコピーする
  5836:         }
  5837:         //  指数部が小さすぎる場合と大きすぎる場合は除いてあるのでこのままdoubleに変換する
  5838:         //  Math.atan(double)を使ってatan(x)の近似値t'を求める
  5839:         long s = Double.doubleToLongBits (Math.atan (Double.longBitsToDouble ((long) (1023 + x.epp) << 52 | x.dvl << 1 >>> 12)));
  5840:         EFP tt = new EFP (xf, (int) (s >>> 52) - 1023, MSB | s << 12 >>> 1, 0L);  //atan(x)の近似値t'
  5841:         //  tanを使ってatan(x')=t'を満たすx'を求める
  5842:         EFP xx = new EFP ().tan (tt);  //x'=tan(t')
  5843:         //  atan(x)=atan(x')+atan((x-x')/(1+x*x'))を使ってatan(x)を計算する
  5844:         //  (x-x')/(1+x*x')は小さいので1次の項だけ加える
  5845:         this.imul (x, xx).inc ().rcp ().imul (xx.negsub (x)).outer ().add (tt);  //t'+(x-x')/(1+x*x')
  5846:         return this.originUpperLower (x).correctUnderflow (savedFpsr);
  5847:       }
  5848:     }  //efp.atan(EFP)
  5849: 
  5850:     //------------------------------------------------------------------------
  5851:     //y = y.atan2 (x)
  5852:     //  y=atan2(y,x)
  5853:     //z = z.atan2 (y, x)
  5854:     //  z=atan2(y,x)
  5855:     //  逆正接 inverse tangent インバースタンジェント
  5856:     //
  5857:     //  atan2(y,x)=(isNaN(y)||isNaN(x)?NaN:
  5858:     //              isInfinite(y)&&isInfinite(x)?copySign(x>=+0?pi/4:3*pi/4,y):
  5859:     //              y==0||isInfinite(x)?copySign(x>=+0?0:pi,y):
  5860:     //              isInfinite(y)||x==0?copySign(pi/2,y):
  5861:     //              x>=0?atan(y/x):atan(y/x)+copySign(pi,y))
  5862:     //
  5863:     //  定義域
  5864:     //    -inf<=y<=inf
  5865:     //    -inf<=x<=inf
  5866:     //    y==0&&x==0を除く
  5867:     //    (y,x)=(Inf,Inf)などは感覚的にはNaNにするべきだと思うがMath.atan2はpi/4を返す
  5868:     //
  5869:     //  値域
  5870:     //    -pi<=atan2(y,x)<=pi
  5871:     //
  5872:     public final EFP atan2 (EFP x) {
  5873:       return this.atan2 (this, x);
  5874:     }  //efp.atan2(EFP)
  5875:     public final EFP atan2 (EFP y, EFP x) {
  5876:       int yf = y.flg;
  5877:       int xf = x.flg;
  5878:       if ((yf | xf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
  5879:         if ((yf | xf) << 3 < 0) {  //どちらかがNaN
  5880:           this.flg = N;
  5881:         } else if ((yf & xf) << 2 < 0) {  //両方±Inf
  5882:           epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  5883:           this.sete (yf >= 0 ? xf >= 0 ? PI_4 : PI3_4 : xf >= 0 ? NEGPI_4 : NEGPI3_4).finish ();
  5884:         } else if (yf << 1 < 0 || xf << 2 < 0) {  //yが±0またはxが±Inf
  5885:           if (xf >= 0) {
  5886:             this.sete (yf >= 0 ? ZERO : NEGZERO);
  5887:           } else {
  5888:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  5889:             if (yf >= 0) {
  5890:               this.sete (ROUNDED_PI[epbRoundingMode]).finish ();
  5891:             } else {
  5892:               this.sete (ROUNDED_NEGPI[epbRoundingMode]).finish ();
  5893:             }
  5894:           }
  5895:         } else {  //yが±Infまたはxが±0
  5896:           epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  5897:           if (yf >= 0) {
  5898:             this.sete (ROUNDED_PI_2[epbRoundingMode]).finish ();
  5899:           } else {
  5900:             this.sete (ROUNDED_NEGPI_2[epbRoundingMode]).finish ();
  5901:           }
  5902:         }
  5903:         return this;
  5904:       }
  5905:       //両方±0,±Inf,NaN以外
  5906:       return (xf < 0 ?
  5907:               this.inner ().div (y, x).atan ().outer ().add (yf >= 0 ? PI : NEGPI) :
  5908:               this.inner ().div (y, x).outer ().atan ());
  5909:     }  //efp.atan2(EFP,EFP)
  5910: 
  5911:     //------------------------------------------------------------------------
  5912:     //x = x.atanh ()
  5913:     //  x=atanh(x)
  5914:     //y = y.atanh (x)
  5915:     //  y=atanh(x)
  5916:     //  逆双曲線正接 inverse hyperbolic tangent インバースハイパボリックタンジェント
  5917:     //
  5918:     //  グラフ
  5919:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{atanh($_[0])});print$g"
  5920:     //    echo read("efp.gp");graph(atanh) | gp -q
  5921:     //    +---------+---------+---------+---------+---------*---------+---------+---------+
  5922:     //    |                                       |         *                             |
  5923:     //    |                                       |         *                             |
  5924:     //    |                                       |         *                             |
  5925:     //    |                                       |         *                             |
  5926:     //    +                                       +         *                             +
  5927:     //    |                                       |         *                             |
  5928:     //    |                                       |         *                             |
  5929:     //    |                                       |         *                             |
  5930:     //    |                                       |         *                             |
  5931:     //    +                                       +         *                             +
  5932:     //    |                                       |        **                             |
  5933:     //    |                                       |        *                              |
  5934:     //    |                                       |        *                              |
  5935:     //    |                                       |       **                              |
  5936:     //    +                                       +      **                               +
  5937:     //    |                                       |     **                                |
  5938:     //    |                                       |    **                                 |
  5939:     //    |                                       |  ***                                  |
  5940:     //    |                                       |***                                    |
  5941:     //    +---------+---------+---------+--------***--------+---------+---------+---------+
  5942:     //    |                                    ***|                                       |
  5943:     //    |                                  ***  |                                       |
  5944:     //    |                                 **    |                                       |
  5945:     //    |                                **     |                                       |
  5946:     //    +                               **      +                                       +
  5947:     //    |                              **       |                                       |
  5948:     //    |                              *        |                                       |
  5949:     //    |                              *        |                                       |
  5950:     //    |                             **        |                                       |
  5951:     //    +                             *         +                                       +
  5952:     //    |                             *         |                                       |
  5953:     //    |                             *         |                                       |
  5954:     //    |                             *         |                                       |
  5955:     //    |                             *         |                                       |
  5956:     //    +                             *         +                                       +
  5957:     //    |                             *         |                                       |
  5958:     //    |                             *         |                                       |
  5959:     //    |                             *         |                                       |
  5960:     //    |                             *         |                                       |
  5961:     //    +---------+---------+---------*---------+---------+---------+---------+---------+
  5962:     //
  5963:     //  定義域
  5964:     //    -1<=x<=1
  5965:     //
  5966:     //  値域
  5967:     //    -inf<=y<=inf
  5968:     //
  5969:     //  テイラー展開
  5970:     //    atanh(x)=sum[k=0..inf]{x^(2*k+1)/(2*k+1)}
  5971:     //    > coeff(sub(a=0,for n:=0:13 sum sub(x=a,df(atanh(x),x,n))/factorial(n)*(x-a)^n),x);
  5972:     //            1     1     1     1     1      1
  5973:     //    {0,1,0,---,0,---,0,---,0,---,0,----,0,----}
  5974:     //            3     5     7     9     11     13
  5975:     //
  5976:     //  対数関数との関係
  5977:     //    atanh(x)=x>=0?log((1+x)/(1-x))/2:-log((1-x)/(1+x))/2
  5978:     //
  5979:     //  変数変換1
  5980:     //    次のように変形する
  5981:     //      atanh(x)=log((1+x)/(1-x))/2
  5982:     //              =(log((1+x)/(1-x))-log(2^n)+log(2^n))/2
  5983:     //              =log((1+x)/(2^n*(1-x)))/2+n*log(2)/2
  5984:     //    ここで
  5985:     //      (1+x)/(2^n*(1-x))=(1+t)/(1-t)
  5986:     //    となるようにtを定める
  5987:     //      atanh(x)=log((1+t)/(1-t))/2+n*log(2)/2
  5988:     //              =atanh(t)+n*log(2)/2
  5989:     //    tをxで表現する
  5990:     //      1+t=(1+x)/(2^n*(1-x))*(1-t)
  5991:     //      (1+(1+x)/(2^n*(1-x)))*t=(1+x)/(2^n*(1-x))-1
  5992:     //      t=((1+x)/(2^n*(1-x))-1)/(1+(1+x)/(2^n*(1-x)))
  5993:     //       =((1+x)-2^n*(1-x))/(2^n*(1-x)+(1+x))
  5994:     //       =(1+x-2^n+2^n*x)/(2^n-2^n*x+1+x)
  5995:     //       =((2^n+1)*x-(2^n-1))/((2^n+1)-(2^n-1)*x)
  5996:     //       =(((2^n+1)*x-(2^n-1))+((2^n+1)-(2^n-1)*x))/((2^n+1)-(2^n-1)*x)-1
  5997:     //       =((2^n+1)*x-(2^n-1)+(2^n+1)-(2^n-1)*x)/((2^n+1)-(2^n-1)*x)-1
  5998:     //       =(2*x+2)/((2^n+1)-(2^n-1)*x)-1
  5999:     //       =2*(1+x)/((2^n+1)-(2^n-1)*x)-1
  6000:     //    xをtで表現する
  6001:     //      1+x=2^n*(1+t)/(1-t)*(1-x)
  6002:     //      (1+2^n*(1+t)/(1-t))*x=2^n*(1+t)/(1-t)-1
  6003:     //      x=(2^n*(1+t)/(1-t)-1)/(1+2^n*(1+t)/(1-t))
  6004:     //       =(2^n*(1+t)-(1-t))/((1-t)+2^n*(1+t))
  6005:     //       =(2^n+2^n*t-1+t)/(1-t+2^n+2^n*t)
  6006:     //       =((2^n+1)*t+(2^n-1))/((2^n+1)+(2^n-1)*t)
  6007:     //       =1-(((2^n+1)+(2^n-1)*t)-((2^n+1)*t+(2^n-1)))/((2^n+1)+(2^n-1)*t)
  6008:     //       =1-((2^n+1)+(2^n-1)*t-(2^n+1)*t-(2^n-1))/((2^n+1)+(2^n-1)*t)
  6009:     //       =1-(2-2*t)/((2^n+1)+(2^n-1)*t)
  6010:     //       =1-2*(1-t)/((2^n+1)+(2^n-1)*t)
  6011:     //
  6012:     //  変数変換2
  6013:     //    t=0となるxで分割する
  6014:     //      x=1-2*(1-0)/((2^n+1)+(2^n-1)*0)
  6015:     //       =1-2/(2^n+1)
  6016:     //    したがって、|x|<1を
  6017:     //      1-2/(2^n+1)={1/3,3/5,7/9,15/17,31/33,...}
  6018:     //    で分割すると、|t|<=1/3になる
  6019:     //    perl -e "use POSIX;sub log2{my($x)=@_;log($x)/log(2);}printf'    //    %4s%10s%10s%11s%18s%c','n','x','1-x','log2(1-x)','floor(log2(1-x))',10;for$n(0..10){$x=1-2/(2**$n+1);printf'    //    %4d%10.6f%10.6f%11.6f%18d%c',$n,$x,1-$x,log2(1-$x),floor(log2(1-$x)),10}"
  6020:     //       n         x       1-x  log2(1-x)  floor(log2(1-x))
  6021:     //       0  0.000000  1.000000   0.000000                 0
  6022:     //       1  0.333333  0.666667  -0.584963                -1
  6023:     //       2  0.600000  0.400000  -1.321928                -2
  6024:     //       3  0.777778  0.222222  -2.169925                -3
  6025:     //       4  0.882353  0.117647  -3.087463                -4
  6026:     //       5  0.939394  0.060606  -4.044394                -5
  6027:     //       6  0.969231  0.030769  -5.022368                -6
  6028:     //       7  0.984496  0.015504  -6.011227                -7
  6029:     //       8  0.992218  0.007782  -7.005625                -8
  6030:     //       9  0.996101  0.003899  -8.002815                -9
  6031:     //      10  0.998049  0.001951  -9.001408               -10
  6032:     //    手順
  6033:     //      n=-floor(log2(1-|x|));  //1-xの指数部を取り出して符号を反転したもの。1以上
  6034:     //      if(|x|<=1-2/(2^n+1)){  //1-2/(2^n+1)は高々LEN通りしかないのでテーブルに列挙しておく
  6035:     //        n--;
  6036:     //      }
  6037:     //      t=(1+|x|-2^n*(1-|x|))/(1+|x|+2^n*(1-|x|))
  6038:     //      //tで多項式を計算する
  6039:     //      //n*log(2)/2を加える
  6040:     //      //xの符号を掛ける
  6041:     //    x→tのグラフ
  6042:     //    perl -e "use POSIX;use Graph;sub log2{my($x)=@_;log($x)/log(2);}$g=new Graph(80,40,-1,1,-1,1);$g->grid();$g->func(sub{$x=$_[0];if(1<=abs($x)){$t=undef;}else{$n=-floor(log2(1-abs($x)));if(abs($x)<=1-2/(2**$n+1)){$n--;}$t=($x<=>0)*(1+abs($x)-2**$n*(1-abs($x)))/(1+abs($x)+2**$n*(1-abs($x)));}$t});print$g"
  6043:     //                                            +                                        
  6044:     //                                            |                                        
  6045:     //                                            |                                        
  6046:     //                                            |                                        
  6047:     //                                            |                                        
  6048:     //                                            |                                        
  6049:     //                                            |                                        
  6050:     //                                            |                                        
  6051:     //                                            |                                        
  6052:     //                                            |                                        
  6053:     //                                            |                                        
  6054:     //                                            |                                        
  6055:     //                                            |                                        
  6056:     //                                            |            *          *      *   *  ***
  6057:     //                                            |          ***        ***     **   * ****
  6058:     //                                            |        ***         **      **   ** ****
  6059:     //                                            |      ***         ***      **    *  ****
  6060:     //                                            |    ***          **       **    ** *****
  6061:     //                                            |  ***          ***       **    **  * ***
  6062:     //                                            |***          ***        **    **   * ***
  6063:     //    ***-**---*-----**---------**-----------***-----------**---------**-----*---**-***
  6064:     //    *** *   **    **        ***          ***|                                        
  6065:     //    *** *  **    **       ***          ***  |                                        
  6066:     //    ***** **    **       **          ***    |                                        
  6067:     //    ****  *    **      ***         ***      |                                        
  6068:     //    **** **   **      **         ***        |                                        
  6069:     //    **** *   **     ***        ***          |                                        
  6070:     //    ***  *   *      *          *            |                                        
  6071:     //                                            |                                        
  6072:     //                                            |                                        
  6073:     //                                            |                                        
  6074:     //                                            |                                        
  6075:     //                                            |                                        
  6076:     //                                            |                                        
  6077:     //                                            |                                        
  6078:     //                                            |                                        
  6079:     //                                            |                                        
  6080:     //                                            |                                        
  6081:     //                                            |                                        
  6082:     //                                            |                                        
  6083:     //                                            +                                        
  6084:     //
  6085:     //  変数変換3
  6086:     //    -r<=t<=rとなるxの範囲が重ならないように分割する
  6087:     //    nのときt=rに対応するxとn+1のときt=-rに対応するxが等しくなるようにする
  6088:     //      1-2*(1-r)/((2^n+1)+(2^n-1)*r)=1-2*(1-(-r))/((2^(n+1)+1)+(2^(n+1)-1)*(-r))
  6089:     //      (1-r)/((2^n+1)+(2^n-1)*r)=(1+r)/((2*2^n+1)-(2*2^n-1)*r)
  6090:     //      (1-r)*((2*2^n+1)-(2*2^n-1)*r)-(1+r)*((2^n+1)+(2^n-1)*r)=0
  6091:     //      ((2*2^n+1)-(2*2^n-1)*r)-((2*2^n+1)-(2*2^n-1)*r)*r-((2^n+1)+(2^n-1)*r)-((2^n+1)+(2^n-1)*r)*r=0
  6092:     //      (2*2^n+1)-(2*2^n-1)*r-(2*2^n+1)*r+(2*2^n-1)*r^2-(2^n+1)-(2^n-1)*r-(2^n+1)*r-(2^n-1)*r^2=0
  6093:     //      (2*2^n-1)*r^2-(2^n-1)*r^2-(2*2^n-1)*r-(2*2^n+1)*r-(2^n-1)*r-(2^n+1)*r+(2*2^n+1)-(2^n+1)=0
  6094:     //      (2*2^n-1-2^n+1)*r^2-(2*2^n-1+2*2^n+1+2^n-1+2^n+1)*r+(2*2^n+1-2^n-1)=0
  6095:     //      (2^n)*r^2-(6*2^n)*r+(2^n)=0
  6096:     //      r^2-6*r+1=0
  6097:     //      r=3+/-2*sqrt(2)
  6098:     //      r=3-2*sqrt(2)
  6099:     //    t=rのときのxは
  6100:     //      x=1-2*(1-r)/((2^n+1)+(2^n-1)*r)
  6101:     //       =1-2*(1-(3-2*sqrt(2)))/((2^n+1)+(2^n-1)*(3-2*sqrt(2)))
  6102:     //       =1-2*(sqrt(2)-1)/((2*2^n-1)-(2^n-1)*sqrt(2))
  6103:     //       =1-2*(sqrt(2)-1)*((2*2^n-1)+(2^n-1)*sqrt(2))/((2*2^n-1)-(2^n-1)*sqrt(2))/((2*2^n-1)+(2^n-1)*sqrt(2))
  6104:     //       =1-2*((2*2^n-1)*sqrt(2)+2*(2^n-1)-(2*2^n-1)-(2^n-1)*sqrt(2))/((2*2^n-1)^2-2*(2^n-1)^2)
  6105:     //       =1-2*((2*2^n-1-2^n+1)*sqrt(2)+(2*2^n-2-2*2^n+1))/(4*4^n-4*2^n+1-2*4^n+4*2^n-2)
  6106:     //       =1-2*(2^n*sqrt(2)-1)/(2*4^n-1)
  6107:     //       =1-2*(2^n*sqrt(2)-1)/((2^n*sqrt(2)-1)*(2^n*sqrt(2)+1))
  6108:     //       =1-2/(2^n*sqrt(2)+1)
  6109:     //    したがって、|x|<1を
  6110:     //       1-2/(2^n*sqrt(2)+1)={3-2*sqrt(2),(9-4*sqrt(2))/7,(33-8*sqrt(2))/31,(129-16*sqrt(2))/127,(513-32*sqrt(2))/511,...}
  6111:     //    で分割すると、|t|<=3-2*sqrt(2)になる
  6112:     //    perl -e "use POSIX;sub log2{my($x)=@_;log($x)/log(2);}printf'    //    %4s%10s%10s%11s%18s%c','n','x','1-x','log2(1-x)','floor(log2(1-x))',10;for$n(0..10){$x=1-2/(2**$n*sqrt(2)+1);printf'    //    %4d%10.6f%10.6f%11.6f%18d%c',$n,$x,1-$x,log2(1-$x),floor(log2(1-$x)),10}"
  6113:     //       n         x       1-x  log2(1-x)  floor(log2(1-x))
  6114:     //       0  0.171573  0.828427  -0.271553                -1
  6115:     //       1  0.477592  0.522408  -0.936752                -1
  6116:     //       2  0.699558  0.300442  -1.734841                -2
  6117:     //       3  0.837579  0.162421  -2.622193                -3
  6118:     //       4  0.915353  0.084647  -3.562390                -4
  6119:     //       5  0.956761  0.043239  -4.531532                -5
  6120:     //       6  0.978144  0.021856  -5.515852                -6
  6121:     //       7  0.989012  0.010988  -6.507948                -7
  6122:     //       8  0.994491  0.005509  -7.503979                -8
  6123:     //       9  0.997242  0.002758  -8.501991                -9
  6124:     //      10  0.998620  0.001380  -9.500996               -10
  6125:     //    手順
  6126:     //      if(|x|<=3-2*sqrt(2)){
  6127:     //        //変数変換を行わない
  6128:     //        //|x|<0.5に区切りが2箇所あるのでn=0を分けなければならない
  6129:     //        //|x|が小さすぎると1-|x|が1になってしまうので1-|x|を経由する方法では正確に計算できない
  6130:     //        //xで多項式を計算する
  6131:     //      }else{
  6132:     //        n=-floor(log2(1-|x|));  //1-|x|の指数部を取り出して符号を反転したもの。1以上
  6133:     //        if(1-2/(2^n*sqrt(2)+1)<|x|){  //1-2/(2^n*sqrt(2)+1)は高々LEN通りしかないのでテーブルに列挙しておく
  6134:     //          n++;
  6135:     //        }
  6136:     //        t=(1+|x|-2^n*(1-|x|))/(1+|x|+2^n*(1-|x|))
  6137:     //        //tで多項式を計算する
  6138:     //        //n*log(2)/2を加える
  6139:     //        //xの符号を掛ける
  6140:     //      }
  6141:     //    x→tのグラフ
  6142:     //    perl -e "use POSIX;use Graph;sub log2{my($x)=@_;log($x)/log(2);}$g=new Graph(80,40,-1,1,-1,1);$g->grid();$g->func(sub{my$x=$_[0];if(1<=abs($x)){$t=undef;}elsif(abs($x)<=3-2*sqrt(2)){$t=$x;}else{$n=-floor(log2(1-abs($x)));if(1-2/(2**$n*sqrt(2)+1)<abs($x)){$n++;}$t=($x<=>0)*(1+abs($x)-2**$n*(1-abs($x)))/(1+abs($x)+2**$n*(1-abs($x)));}$t});print$g"
  6143:     //                                            +                                        
  6144:     //                                            |                                        
  6145:     //                                            |                                        
  6146:     //                                            |                                        
  6147:     //                                            |                                        
  6148:     //                                            |                                        
  6149:     //                                            |                                        
  6150:     //                                            |                                        
  6151:     //                                            |                                        
  6152:     //                                            |                                        
  6153:     //                                            |                                        
  6154:     //                                            |                                        
  6155:     //                                            |                                        
  6156:     //                                            |                                        
  6157:     //                                            |                                        
  6158:     //                                            |                                        
  6159:     //                                            |                                        
  6160:     //    ****  *    **      ***         ***      |    ***          **       **    ** *****
  6161:     //    **** **   **      **         ***        |  ***          ***       **    **  * ***
  6162:     //    ** * *   **      **         **          |***          ***        **    **   * ***
  6163:     //    ******---*-----***--------***----------***----------***--------***-----*---******
  6164:     //    *** *   **    **        ***          ***|          **         **      **   * * **
  6165:     //    *** *  **    **       ***          ***  |        ***         **      **   ** ****
  6166:     //    ***** **    **       **          ***    |      ***         ***      **    *  ****
  6167:     //                                            |                                        
  6168:     //                                            |                                        
  6169:     //                                            |                                        
  6170:     //                                            |                                        
  6171:     //                                            |                                        
  6172:     //                                            |                                        
  6173:     //                                            |                                        
  6174:     //                                            |                                        
  6175:     //                                            |                                        
  6176:     //                                            |                                        
  6177:     //                                            |                                        
  6178:     //                                            |                                        
  6179:     //                                            |                                        
  6180:     //                                            |                                        
  6181:     //                                            |                                        
  6182:     //                                            |                                        
  6183:     //                                            +                                        
  6184:     //
  6185:     //  チェビシェフ展開
  6186:     //    |x|<3-2*sqrt(2)
  6187:     //    echo read("efp.gp");a=2*sqrt(2)-3;b=-a;nmax=55;print1("    //    ");forstep(n=1,nmax,2,printf("%4d",n));print();print1("    //    ");forstep(n=1,nmax,2,printf("%4d",floor(closeness(atanh,chebyshev(atanh,a,b,n),a,b,10000))));print() | gp -q
  6188:     //       1   3   5   7   9  11  13  15  17  19  21  23  25  27  29  31  33  35  37  39  41  43  45  47  49  51  53  55
  6189:     //       7  14  21  28  35  42  49  56  63  70  77  84  91  98 105 113 120 127 134 141 148 155 162 169 176 183 190 197
  6190:     //
  6191:     //  CORDIC
  6192:     //    atanh(y/x)のときxとyを両方入力することで除算が不要になる
  6193:     //    tanh(t)=sinh(t)/cosh(t)
  6194:     //    t=atanh(sinh(t)/cosh(t))
  6195:     //
  6196:     public final EFP atanh () {
  6197:       return this.atanh (this);
  6198:     }  //efp.atanh()
  6199:     public final EFP atanh (EFP x) {
  6200:       int xf = x.flg;
  6201:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  6202:         if (xf << 2 < 0) {  //±Inf
  6203:           epbFpsr |= EPB_FPSR_OE;
  6204:           epbExceptionOperandExponent = xf & M | 0x7fff << 16;
  6205:           epbExceptionOperandMantissa = 0x0000000000000000L;
  6206:           this.flg = N;  //atanh(±Inf)=NaN
  6207:         } else {
  6208:           this.flg = xf;  //atanh(±0)=±0, atanh(NaN)=NaN
  6209:         }
  6210:         return this;
  6211:       }
  6212:       //±0,±Inf,NaN以外
  6213:       int xe = x.epp;
  6214:       if (0 <= xe) {  //1<=|x|
  6215:         if (xe == 0 && x.dvl == MSB && x.cvl == 0L) {  //|x|==1
  6216:           epbFpsr |= EPB_FPSR_DZ;
  6217:           epbExceptionOperandExponent = xf | 0x3fff << 16;
  6218:           epbExceptionOperandMantissa = 0x8000000000000000L;
  6219:           this.flg = xf | I;
  6220:         } else {  //1<|x|
  6221:           epbFpsr |= EPB_FPSR_OE;
  6222:           epbExceptionOperandExponent = xf | 0x3fff + x.epp << 16;
  6223:           epbExceptionOperandMantissa = x.dvl;
  6224:           this.flg = N;
  6225:         }
  6226:         return this;
  6227:       }
  6228:       //|x|<1
  6229:       if (false) {  //logを使う。[89] 540ns
  6230:         if (x.epp < -4) {  //|x|<0.0625
  6231:           EFP x2 = new EFP ().inner ().isqu (x);  //x^2
  6232:           return this.imul (ATANH_C19, x2)
  6233:             .iadd (ATANH_C17).imul (x2)
  6234:               .iadd (ATANH_C15).imul (x2)
  6235:                 .iadd (ATANH_C13).imul (x2)
  6236:                   .iadd (ATANH_C11).imul (x2)
  6237:                     .iadd (ATANH_C9).imul (x2)
  6238:                       .iadd (ATANH_C7).imul (x2)
  6239:                         .iadd (ATANH_C5).imul (x2)
  6240:                           .iadd (ATANH_C3).imul (x2)
  6241:                             .iadd (ATANH_C1).outer ().mul (x);
  6242:         }
  6243:         //0.0625<=|x|
  6244:         this.inner ().iabs (x);  //|x|
  6245:         EFP t = new EFP ().negdec (this);  //1-|x|
  6246:         return this.inc ().div (t).log ().idiv2 ().outer ().neg (xf < 0);  //sgn(x)*log((1+|x|)/(1-|x|))/2
  6247:       } else {  //|x|<3-2*sqrt(2)に畳む。[90] 425ns
  6248:         int savedFpsr = epbFpsr;
  6249:         this.inner ();
  6250:         long xd = x.dvl;
  6251:         long xc = x.cvl;
  6252:         if (xe <= -3 && (xe < -3 || xd <= 0xafb0ccc06219b7baL)) {  //|x|<=3-2*sqrt(2)。xcの比較は省略
  6253:           if (this == x) {
  6254:             x = new EFP (x);  //必要なときだけコピーする
  6255:           }
  6256:           EFP x2 = new EFP ().isqu (x);  //x^2
  6257:           /*
  6258:           return this.imul (ATH_C25, x2)
  6259:             .iadd (ATH_C23).imul (x2)
  6260:               .iadd (ATH_C21).imul (x2)
  6261:                 .iadd (ATH_C19).imul (x2)
  6262:                   .iadd (ATH_C17).imul (x2)
  6263:                     .iadd (ATH_C15).imul (x2)
  6264:                       .iadd (ATH_C13).imul (x2)
  6265:                         .iadd (ATH_C11).imul (x2)
  6266:                           .iadd (ATH_C9).imul (x2)
  6267:                             .iadd (ATH_C7).imul (x2)
  6268:                               .iadd (ATH_C5).imul (x2)
  6269:                                 .iadd (ATH_C3).imul (x2)
  6270:                                   .iadd (ATH_C1).outer ().mul (x);
  6271:            */
  6272:           this.imul (ATH_C27, x2)
  6273:             .iadd (ATH_C25).imul (x2)
  6274:               .iadd (ATH_C23).imul (x2)
  6275:                 .iadd (ATH_C21).imul (x2)
  6276:                   .iadd (ATH_C19).imul (x2)
  6277:                     .iadd (ATH_C17).imul (x2)
  6278:                       .iadd (ATH_C15).imul (x2)
  6279:                         .iadd (ATH_C13).imul (x2)
  6280:                           .iadd (ATH_C11).imul (x2)
  6281:                             .iadd (ATH_C9).imul (x2)
  6282:                               .iadd (ATH_C7).imul (x2)
  6283:                                 .iadd (ATH_C5).imul (x2)
  6284:                                   .iadd (ATH_C3).imul (x2)
  6285:                                     .iadd (ATH_C1).outer ().mul (x);
  6286:           return this.originLowerUpper (x).correctUnderflow (savedFpsr);
  6287:         }
  6288:         EFP a = new EFP (P, xe, xd, xc);  //|x|
  6289:         EFP t = new EFP ().negdec (a);  //1-|x|
  6290:         int n = -t.epp;  //-floor(log2(1-|x|))
  6291:         if (ATH_T[n].lt (a)) {  //1-2/(2^n*sqrt(2)+1)<|x|
  6292:           n++;
  6293:         }
  6294:         EFP u = new EFP ().iadd (a.inc (), t.shl (n));
  6295:         t.negsub (a).div (u);  //(1+|x|-2^n*(1-|x|))/(1+|x|+2^n*(1-|x|))
  6296:         a.isqu (t);  //t^2
  6297:         /*
  6298:         return this.imul (ATH_C25, a)
  6299:           .iadd (ATH_C23).imul (a)
  6300:             .iadd (ATH_C21).imul (a)
  6301:               .iadd (ATH_C19).imul (a)
  6302:                 .iadd (ATH_C17).imul (a)
  6303:                   .iadd (ATH_C15).imul (a)
  6304:                     .iadd (ATH_C13).imul (a)
  6305:                       .iadd (ATH_C11).imul (a)
  6306:                         .iadd (ATH_C9).imul (a)
  6307:                           .iadd (ATH_C7).imul (a)
  6308:                             .iadd (ATH_C5).imul (a)
  6309:                               .iadd (ATH_C3).imul (a)
  6310:                                 .iadd (ATH_C1).imul (t).iadd (t.muli (LOG_2_2, n)).outer ().neg (xf < 0);  //+n*log(2)/2
  6311:          */
  6312:         return this.imul (ATH_C27, a)
  6313:           .iadd (ATH_C25).imul (a)
  6314:             .iadd (ATH_C23).imul (a)
  6315:               .iadd (ATH_C21).imul (a)
  6316:                 .iadd (ATH_C19).imul (a)
  6317:                   .iadd (ATH_C17).imul (a)
  6318:                     .iadd (ATH_C15).imul (a)
  6319:                       .iadd (ATH_C13).imul (a)
  6320:                         .iadd (ATH_C11).imul (a)
  6321:                           .iadd (ATH_C9).imul (a)
  6322:                             .iadd (ATH_C7).imul (a)
  6323:                               .iadd (ATH_C5).imul (a)
  6324:                                 .iadd (ATH_C3).imul (a)
  6325:                                   .iadd (ATH_C1).imul (t).iadd (t.muli (LOG_2_2, n)).outer ().neg (xf < 0);  //+n*log(2)/2
  6326:       }
  6327:     }  //efp.atanh(EFP)
  6328: 
  6329:     //------------------------------------------------------------------------
  6330:     //x = x.cbrt ()
  6331:     //  x=x^(1/3)
  6332:     //y = y.cbrt (x)
  6333:     //  y=x^(1/3)
  6334:     //  1/3乗(立方根)
  6335:     //
  6336:     //  グラフ
  6337:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{($_[0]<=>0)*abs($_[0])**(1/3)});print$g"
  6338:     //    echo read("efp.gp");eval("cbrt(x)=sign(x)*abs(x)^(1/3)");graph(cbrt) | gp -q
  6339:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  6340:     //    |                                       |                                       |
  6341:     //    |                                       |                                       |
  6342:     //    |                                       |                                       |
  6343:     //    |                                       |                                       |
  6344:     //    +                                       +                                       +
  6345:     //    |                                       |                                       |
  6346:     //    |                                       |                                       |
  6347:     //    |                                       |                                       |
  6348:     //    |                                       |                                       |
  6349:     //    +                                       +                                       +
  6350:     //    |                                       |                                       |
  6351:     //    |                                       |                                 *******
  6352:     //    |                                       |                     *************     |
  6353:     //    |                                       |            **********                 |
  6354:     //    +                                       +      *******                          +
  6355:     //    |                                       |  *****                                |
  6356:     //    |                                       |***                                    |
  6357:     //    |                                       **                                      |
  6358:     //    |                                       *                                       |
  6359:     //    +---------+---------+---------+---------*---------+---------+---------+---------+
  6360:     //    |                                       *                                       |
  6361:     //    |                                      **                                       |
  6362:     //    |                                    ***|                                       |
  6363:     //    |                                *****  |                                       |
  6364:     //    +                          *******      +                                       +
  6365:     //    |                 **********            |                                       |
  6366:     //    |     *************                     |                                       |
  6367:     //    *******                                 |                                       |
  6368:     //    |                                       |                                       |
  6369:     //    +                                       +                                       +
  6370:     //    |                                       |                                       |
  6371:     //    |                                       |                                       |
  6372:     //    |                                       |                                       |
  6373:     //    |                                       |                                       |
  6374:     //    +                                       +                                       +
  6375:     //    |                                       |                                       |
  6376:     //    |                                       |                                       |
  6377:     //    |                                       |                                       |
  6378:     //    |                                       |                                       |
  6379:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  6380:     //
  6381:     //  定義域
  6382:     //    -inf<=x<=inf
  6383:     //
  6384:     //  値域
  6385:     //    -inf<=y<=inf
  6386:     //
  6387:     //  ニュートン法
  6388:     //    f(t)=t^3-x
  6389:     //    f'(t)=3*t^2
  6390:     //    t'=t-f(t)/f'(t)
  6391:     //      =t-(t^3-x)/(3*t^2)
  6392:     //      =(2*t^3+x)/(3*t^2)
  6393:     //      =(2*t+x/t^2)/3
  6394:     //
  6395:     public final EFP cbrt () {
  6396:       return this.cbrt (this);
  6397:     }  //efp.cbrt()
  6398:     public final EFP cbrt (EFP x) {
  6399:       int xf = x.flg;
  6400:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  6401:         this.flg = xf;
  6402:         return this;
  6403:       }
  6404:       //±0,±Inf,NaN以外
  6405:       if (false) {  //ニュートン法。[90] 1095.4ns
  6406:         this.inner ();
  6407:         EFP s = new EFP ().sgn (x);
  6408:         EFP a = new EFP ().iabs (x);
  6409:         EFP t = new EFP ().iadd (TWO, a).div3 ();  //t=(2+a)/3
  6410:         EFP w = new EFP ();
  6411:         do {
  6412:           //this.sete (t);
  6413:           this.flg = t.flg;
  6414:           this.epp = t.epp;
  6415:           this.dvl = t.dvl;
  6416:           this.cvl = t.cvl;
  6417:           w.isqu (t).mul3 ();  //3*t^2
  6418:           t.cub ().imul2 ().iadd (a).div (w);  //t=(2*t^3+a)/(3*t^2)
  6419:         } while (this.gt (t));
  6420:         return this.outer ().mul (s);
  6421:       } else {  //Math.cbrtを使う。[91] 214ns
  6422:         this.inner ();
  6423:         int xe = x.epp;  //-32768..32767
  6424:         int xe3 = (int) (xe * 43691L >> 17);  //xe / 3
  6425:         long s = Double.doubleToLongBits (Math.cbrt (Double.longBitsToDouble ((long) (1023 + (xe - xe3 * 3)) << 52 | x.dvl << 1 >>> 12)));
  6426:         EFP t = new EFP (P, (int) (s >>> 52) - 1023 + xe3, MSB | s << 12 >>> 1, 0L);
  6427:         EFP t2 = new EFP ().imul2 (t);
  6428:         t2.flg |= xf;
  6429:         return this.iadd (t2, t.isqu ().rcpdiv (x)).outer ().div3 ();  //(2*t+x/t^2)/3
  6430:       }
  6431:     }  //efp.cbrt(EFP)
  6432: 
  6433:     //------------------------------------------------------------------------
  6434:     //x = x.ceil ()
  6435:     //  x=ceil(x)
  6436:     //y = y.ceil (x)
  6437:     //  y=ceil(x)
  6438:     //  天井関数 ceiling function
  6439:     //
  6440:     //  グラフ
  6441:     //    perl -e "use POSIX;use Graph;$g=new Graph();$g->grid();$g->func(sub{ceil($_[0])});print$g"
  6442:     //    echo read("efp.gp");graph(ceil) | gp -q
  6443:     //    +---------+---------+---------+---------+---------+---------+---------***********
  6444:     //    |                                       |                                       |
  6445:     //    |                                       |                                       |
  6446:     //    |                                       |                                       |
  6447:     //    |                                       |                                       |
  6448:     //    +                                       +                   ***********         +
  6449:     //    |                                       |                                       |
  6450:     //    |                                       |                                       |
  6451:     //    |                                       |                                       |
  6452:     //    |                                       |                                       |
  6453:     //    +                                       +         ***********                   +
  6454:     //    |                                       |                                       |
  6455:     //    |                                       |                                       |
  6456:     //    |                                       |                                       |
  6457:     //    |                                       |                                       |
  6458:     //    +                                       ***********                             +
  6459:     //    |                                       |                                       |
  6460:     //    |                                       |                                       |
  6461:     //    |                                       |                                       |
  6462:     //    |                                       |                                       |
  6463:     //    +---------+---------+---------***********---------+---------+---------+---------+
  6464:     //    |                                       |                                       |
  6465:     //    |                                       |                                       |
  6466:     //    |                                       |                                       |
  6467:     //    |                                       |                                       |
  6468:     //    +                   ***********         +                                       +
  6469:     //    |                                       |                                       |
  6470:     //    |                                       |                                       |
  6471:     //    |                                       |                                       |
  6472:     //    |                                       |                                       |
  6473:     //    +         ***********                   +                                       +
  6474:     //    |                                       |                                       |
  6475:     //    |                                       |                                       |
  6476:     //    |                                       |                                       |
  6477:     //    |                                       |                                       |
  6478:     //    ***********                             +                                       +
  6479:     //    |                                       |                                       |
  6480:     //    |                                       |                                       |
  6481:     //    |                                       |                                       |
  6482:     //    |                                       |                                       |
  6483:     //    *---------+---------+---------+---------+---------+---------+---------+---------+
  6484:     //
  6485:     public final EFP ceil () {
  6486:       return this.ceil (this);
  6487:     }  //efp.ceil()
  6488:     public final EFP ceil (EFP x) {  //2.8ns
  6489:       int xf = x.flg;
  6490:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  6491:         this.flg = xf;
  6492:         return this;
  6493:       }
  6494:       //±0,±Inf,NaN以外
  6495:       int xe = x.epp;
  6496:       if (xe < 0) {  //すべて小数部
  6497:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  6498:         if (xf < 0) {  //ceil(-1<x<0)=-0
  6499:           this.flg = M | Z;
  6500:         } else {  //ceil(0<x<1)=+1
  6501:           this.flg = P;
  6502:           this.epp = 0;
  6503:           this.dvl = MSB;
  6504:           this.cvl = 0L;
  6505:         }
  6506:         return this;
  6507:       }
  6508:       //整数部がある
  6509:       long xd = x.dvl;
  6510:       long xc = x.cvl;
  6511:       long m = MSB >> xe;  //整数部のマスク。符号に注意
  6512:       if (xf < 0) {  //ceil(x<0)=trunc(x)。小数部を切り捨てる
  6513:         if (xe <= 63) {  //0..63。dの途中または末尾まで整数部
  6514:           if ((xd & ~m | xc) != 0L) {  //小数部が0ではない
  6515:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  6516:             xd &= m;  //小数部を切り捨てる
  6517:             xc = 0L;
  6518:           }
  6519:         } else if (xe <= LEN - 2) {  //64..90。cの途中まで整数部
  6520:           if ((xc & ~m) != 0L) {  //小数部が0ではない
  6521:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  6522:             xc &= m;  //小数部を切り捨てる
  6523:           }
  6524:         }
  6525:         //すべて整数部のときはそのまま
  6526:       } else {  //ceil(0<x)。小数部を切り捨てる。小数部が0でなかったときは絶対値に1を加える
  6527:         if (xe <= 63) {  //0..63。dの途中または末尾まで整数部
  6528:           long t = xd;  //保存して
  6529:           xd &= m;  //小数部を切り捨てる
  6530:           if (((t ^ xd) | xc) != 0L) {  //小数部が0でなかった
  6531:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  6532:             xd -= m;  //絶対値に1を加える。符号に注意
  6533:             if (xd >= 0L) {  //dから溢れた
  6534:               xd = MSB;
  6535:               xe++;
  6536:               if ((short) xe != xe) {  //オーバーフローした
  6537:                 epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
  6538:                 epbExceptionOperandExponent = xf;
  6539:                 epbExceptionOperandMantissa = xd;
  6540:                 return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | xf >>> 31]).finish ();  //±Inf
  6541:               }
  6542:             }
  6543:             xc = 0L;
  6544:           }
  6545:           //小数部が0のときはそのまま
  6546:         } else if (xe <= LEN - 2) {  //64..90。cの途中まで整数部
  6547:           long t = xc;  //保存して
  6548:           xc &= m;  //小数部を切り捨てる
  6549:           if ((t ^ xc) != 0L) {  //小数部が0でなかった
  6550:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  6551:             xc -= m;  //絶対値に1を加える。符号に注意
  6552:             if ((t ^ xc) < 0L) {  //cから溢れた
  6553:               xd++;
  6554:               if (xd >= 0L) {  //dから溢れた
  6555:                 xd = MSB;
  6556:                 xe++;
  6557:                 if ((short) xe != xe) {  //オーバーフローした
  6558:                   epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
  6559:                   epbExceptionOperandExponent = xf;
  6560:                   epbExceptionOperandMantissa = xd;
  6561:                   return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | xf >>> 31]).finish ();  //±Inf
  6562:                 }
  6563:               }
  6564:             }
  6565:           }
  6566:         }
  6567:         //すべて整数部のときはそのまま
  6568:       }
  6569:       return this.finish (xf, xe, xd, xc, 0L);
  6570:     }  //efp.ceil(EFP)
  6571: 
  6572:     //------------------------------------------------------------------------
  6573:     //s = x.cmp (y)
  6574:     //  s=x<=>y
  6575:     //  比較
  6576:     //
  6577:     //  -Inf==-Inf<-x<-0==+0<+x<+Inf==+Inf
  6578:     //
  6579:     //  NaNの扱い
  6580:     //    どちらかがNaNのときは0を返す
  6581:     //    どちらかがNaNのときにNaNを返すのはx.sgnsub(y)
  6582:     //
  6583:     //  ±0の扱い
  6584:     //    両方が±0のときは符号に関係なく0を返す
  6585:     //
  6586:     //  関係演算子および等価演算子との違い
  6587:     //    doubleのNaNはNaNを含むすべての数と等しくなく大きくなく小さくもないので-1,0,1に分類できない
  6588:     //
  6589:     //  x.compareTo(y)との違い
  6590:     //    x.compareTo(y)はx.equals(y)と一貫性を保つためにNaNを含むすべての数について大小関係が定められている
  6591:     //    -Inf==-Inf<x<-0<+0<+x<+Inf==+Inf<NaN
  6592:     //    ((Double)x).compareTo(y)とDouble.compare(double,double)も同様
  6593:     //
  6594:     //  xn/xd<=>yn/yd
  6595:     //    =xn*yd<=>xd*yn  (xd>0,yd>0)
  6596:     //
  6597:     public int cmp (EFP y) {
  6598:       int xf = this.flg;
  6599:       int yf = y.flg;
  6600:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
  6601:         //return ((xf | yf) << 3 < 0 || (xf & yf) << 1 < 0 || xf == yf ? 0 :  //どちらかがNaNまたは両方±0または両方-Infまたは両方+Inf
  6602:         //        (xf ^ yf) < 0 ? xf >= 0 ? 1 : -1 :  //両方NaN以外でどちらかが±0,±Infで符号が違う
  6603:         //        xf == (P | I) || yf == (P | Z) || xf == (M | Z) || yf == (M | I) ? 1 : -1);  //両方NaN以外でどちらかが±0,±Infで符号が同じ
  6604:         return EFP_CMP_TABLE[xf >>> 28] << (yf >>> 28 - 1) >> 30;
  6605:       }
  6606:       //両方±0,±Inf,NaN以外
  6607:       if (xf != yf) {  //両方±0,±Inf,NaN以外で符号が違う
  6608:         return xf >= 0 ? 1 : -1;
  6609:       }
  6610:       //両方±0,±Inf,NaN以外で符号が同じ
  6611:       int s;
  6612:       long t;
  6613:       return (xf >= 0 ? 1 : -1) * ((s = this.epp - y.epp) != 0 ? s >= 0 ? 1 : -1 :
  6614:                                    (t = this.dvl - y.dvl) != 0L ? t >= 0L ? 1 : -1 :
  6615:                                    (t = (this.cvl >>> 1) - (y.cvl >>> 1)) != 0L ? t >= 0L ? 1 : -1 :
  6616:                                    0);
  6617:     }  //efp.cmp(EFP)
  6618: 
  6619:     //------------------------------------------------------------------------
  6620:     //s = x.cmp0 ()
  6621:     //  s=x<=>0
  6622:     //  0との比較
  6623:     //
  6624:     //  グラフ
  6625:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{$_[0]<=>0});print$g"
  6626:     //    echo read("efp.gp");graph(sign) | gp -q
  6627:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  6628:     //    |                                       |                                       |
  6629:     //    |                                       |                                       |
  6630:     //    |                                       |                                       |
  6631:     //    |                                       |                                       |
  6632:     //    +                                       +                                       +
  6633:     //    |                                       |                                       |
  6634:     //    |                                       |                                       |
  6635:     //    |                                       |                                       |
  6636:     //    |                                       |                                       |
  6637:     //    +                                       +                                       +
  6638:     //    |                                       |                                       |
  6639:     //    |                                       |                                       |
  6640:     //    |                                       |                                       |
  6641:     //    |                                       |                                       |
  6642:     //    +                                       *****************************************
  6643:     //    |                                       |                                       |
  6644:     //    |                                       |                                       |
  6645:     //    |                                       |                                       |
  6646:     //    |                                       |                                       |
  6647:     //    +---------+---------+---------+---------*---------+---------+---------+---------+
  6648:     //    |                                       |                                       |
  6649:     //    |                                       |                                       |
  6650:     //    |                                       |                                       |
  6651:     //    |                                       |                                       |
  6652:     //    *****************************************                                       +
  6653:     //    |                                       |                                       |
  6654:     //    |                                       |                                       |
  6655:     //    |                                       |                                       |
  6656:     //    |                                       |                                       |
  6657:     //    +                                       +                                       +
  6658:     //    |                                       |                                       |
  6659:     //    |                                       |                                       |
  6660:     //    |                                       |                                       |
  6661:     //    |                                       |                                       |
  6662:     //    +                                       +                                       +
  6663:     //    |                                       |                                       |
  6664:     //    |                                       |                                       |
  6665:     //    |                                       |                                       |
  6666:     //    |                                       |                                       |
  6667:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  6668:     //
  6669:     //  x.cmp(0)と同じ
  6670:     //
  6671:     public int cmp0 () {
  6672:       int xf = this.flg;
  6673:       return xf << 3 < 0 || xf << 1 < 0 ? 0 : xf >= 0 ? 1 : -1;
  6674:     }  //efp.cmp0()
  6675: 
  6676:     //------------------------------------------------------------------------
  6677:     //s = x.cmp1 ()
  6678:     //  s=x<=>1
  6679:     //  1との比較
  6680:     //
  6681:     //  グラフ
  6682:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{$_[0]<=>1});print$g"
  6683:     //    echo read("efp.gp");eval("cmp1(x)=sign(x-1)");graph(cmp1) | gp -q
  6684:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  6685:     //    |                                       |                                       |
  6686:     //    |                                       |                                       |
  6687:     //    |                                       |                                       |
  6688:     //    |                                       |                                       |
  6689:     //    +                                       +                                       +
  6690:     //    |                                       |                                       |
  6691:     //    |                                       |                                       |
  6692:     //    |                                       |                                       |
  6693:     //    |                                       |                                       |
  6694:     //    +                                       +                                       +
  6695:     //    |                                       |                                       |
  6696:     //    |                                       |                                       |
  6697:     //    |                                       |                                       |
  6698:     //    |                                       |                                       |
  6699:     //    +                                       +         *******************************
  6700:     //    |                                       |                                       |
  6701:     //    |                                       |                                       |
  6702:     //    |                                       |                                       |
  6703:     //    |                                       |                                       |
  6704:     //    +---------+---------+---------+---------+---------*---------+---------+---------+
  6705:     //    |                                       |                                       |
  6706:     //    |                                       |                                       |
  6707:     //    |                                       |                                       |
  6708:     //    |                                       |                                       |
  6709:     //    ***************************************************                             +
  6710:     //    |                                       |                                       |
  6711:     //    |                                       |                                       |
  6712:     //    |                                       |                                       |
  6713:     //    |                                       |                                       |
  6714:     //    +                                       +                                       +
  6715:     //    |                                       |                                       |
  6716:     //    |                                       |                                       |
  6717:     //    |                                       |                                       |
  6718:     //    |                                       |                                       |
  6719:     //    +                                       +                                       +
  6720:     //    |                                       |                                       |
  6721:     //    |                                       |                                       |
  6722:     //    |                                       |                                       |
  6723:     //    |                                       |                                       |
  6724:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  6725:     //
  6726:     //  x.cmp(1)と同じ
  6727:     //
  6728:     public int cmp1 () {
  6729:       int xf = this.flg;
  6730:       if (xf != 0) {  //-x,±0,±Inf,NaN
  6731:         return xf << 3 < 0 ? 0 : (xf | xf << 1) < 0 ? -1 : 1;
  6732:       }
  6733:       //+x
  6734:       int xe = this.epp;  //xの指数
  6735:       return xe < 0 ? -1 : xe == 0 && this.dvl == MSB && this.cvl == 0L ? 0 : 1;
  6736:     }  //efp.cmp1()
  6737: 
  6738:     //------------------------------------------------------------------------
  6739:     //s = x.cmp1abs ()
  6740:     //  s=|x|<=>1
  6741:     //  絶対値と1の比較
  6742:     //
  6743:     //  グラフ
  6744:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{abs($_[0])<=>1});print$g"
  6745:     //    echo read("efp.gp");eval("cmp1abs(x)=sign(abs(x)-1)");graph(cmp1abs) | gp -q
  6746:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  6747:     //    |                                       |                                       |
  6748:     //    |                                       |                                       |
  6749:     //    |                                       |                                       |
  6750:     //    |                                       |                                       |
  6751:     //    +                                       +                                       +
  6752:     //    |                                       |                                       |
  6753:     //    |                                       |                                       |
  6754:     //    |                                       |                                       |
  6755:     //    |                                       |                                       |
  6756:     //    +                                       +                                       +
  6757:     //    |                                       |                                       |
  6758:     //    |                                       |                                       |
  6759:     //    |                                       |                                       |
  6760:     //    |                                       |                                       |
  6761:     //    *******************************         +         *******************************
  6762:     //    |                                       |                                       |
  6763:     //    |                                       |                                       |
  6764:     //    |                                       |                                       |
  6765:     //    |                                       |                                       |
  6766:     //    +---------+---------+---------*---------+---------*---------+---------+---------+
  6767:     //    |                                       |                                       |
  6768:     //    |                                       |                                       |
  6769:     //    |                                       |                                       |
  6770:     //    |                                       |                                       |
  6771:     //    +                             *********************                             +
  6772:     //    |                                       |                                       |
  6773:     //    |                                       |                                       |
  6774:     //    |                                       |                                       |
  6775:     //    |                                       |                                       |
  6776:     //    +                                       +                                       +
  6777:     //    |                                       |                                       |
  6778:     //    |                                       |                                       |
  6779:     //    |                                       |                                       |
  6780:     //    |                                       |                                       |
  6781:     //    +                                       +                                       +
  6782:     //    |                                       |                                       |
  6783:     //    |                                       |                                       |
  6784:     //    |                                       |                                       |
  6785:     //    |                                       |                                       |
  6786:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  6787:     //
  6788:     //  t.abs(x).cmp1()と同じ
  6789:     //
  6790:     public int cmp1abs () {
  6791:       int xf = this.flg;
  6792:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  6793:         return xf << 3 < 0 ? 0 : xf << 1 < 0 ? -1 : 1;
  6794:       }
  6795:       //±0,±Inf,NaN以外
  6796:       int xe = this.epp;  //xの指数
  6797:       return xe < 0 ? -1 : xe == 0 && this.dvl == MSB && this.cvl == 0L ? 0 : 1;
  6798:     }  //efp.cmp1abs()
  6799: 
  6800:     //------------------------------------------------------------------------
  6801:     //s = x.cmpabs (y)
  6802:     //  s=|x|<=>|y|
  6803:     //  絶対値比較
  6804:     //
  6805:     public int cmpabs (EFP y) {
  6806:       int xf = this.flg & ~M;
  6807:       int yf = y.flg & ~M;
  6808:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
  6809:         return EFP_CMP_TABLE[xf >>> 28] << (yf >>> 28 - 1) >> 30;
  6810:       }
  6811:       //両方±0,±Inf,NaN以外
  6812:       int s;
  6813:       long t;
  6814:       return ((s = this.epp - y.epp) != 0 ? s >= 0 ? 1 : -1 :
  6815:               (t = this.dvl - y.dvl) != 0L ? t >= 0L ? 1 : -1 :
  6816:               (t = (this.cvl >>> 1) - (y.cvl >>> 1)) != 0L ? t >= 0L ? 1 : -1 :
  6817:               0);
  6818:     }  //efp.cmpabs(EFP)
  6819: 
  6820:     //------------------------------------------------------------------------
  6821:     //s = x.compareTo (y)
  6822:     //  s=x<=>y
  6823:     //  比較
  6824:     //
  6825:     //  -Inf==-Inf<-x<-0<+0<+x<+Inf==+Inf<NaN==NaN
  6826:     //
  6827:     //  equalsであるオブジェクトはcompareToが0であることが強く推奨される
  6828:     //  同じクラスだがequalsでないオブジェクトはcompareToが0でないことが強く推奨される
  6829:     //
  6830:     @Override public int compareTo (EFP y) {
  6831:       EFP x = this;
  6832:       int xf = x.flg;
  6833:       int yf = y.flg;
  6834:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
  6835:         //return (xf == yf ? 0 :  //両方-Infまたは両方-0または両方+0または両方+Infまたは両方NaN
  6836:         //        (xf | yf) << 3 < 0 ? xf << 3 < 0 ? 1 : -1 :  //どちらか一方がNaN
  6837:         //        (xf ^ yf) < 0 ? xf >= 0 ? 1 : -1 :  //両方NaN以外でどちらかが±0,±Infで符号が違う
  6838:         //        xf == (P | I) || yf == (P | Z) || xf == (M | Z) || yf == (M | I) ? 1 : -1);  //両方NaN以外でどちらかが±0,±Infで符号が同じ
  6839:         return EFP_COMPARE_TABLE[xf >>> 28] << (yf >>> 28 - 1) >> 30;
  6840:       }
  6841:       //両方±0,±Inf,NaN以外
  6842:       if (xf != yf) {  //両方±0,±Inf,NaN以外で符号が違う
  6843:         return xf >= 0 ? 1 : -1;
  6844:       }
  6845:       //両方±0,±Inf,NaN以外で符号が同じ
  6846:       int s;
  6847:       long t;
  6848:       return (xf >= 0 ? 1 : -1) * ((s = x.epp - y.epp) != 0 ? s >= 0 ? 1 : -1 :
  6849:                                    (t = x.dvl - y.dvl) != 0L ? t >= 0L ? 1 : -1 :
  6850:                                    (t = (x.cvl >>> 1) - (y.cvl >>> 1)) != 0L ? t >= 0L ? 1 : -1 :
  6851:                                    0);
  6852:     }  //efp.compareTo(EFP)
  6853: 
  6854:     //------------------------------------------------------------------------
  6855:     //x = x.cos ()
  6856:     //  x=cos(x)
  6857:     //y = y.cos (x)
  6858:     //  y=cos(x)
  6859:     //  余弦 cosine コサイン
  6860:     //
  6861:     //  グラフ
  6862:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{cos($_[0])});print$g"
  6863:     //    echo read("efp.gp");graph(cos) | gp -q
  6864:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  6865:     //    |                                       |                                       |
  6866:     //    |                                       |                                       |
  6867:     //    |                                       |                                       |
  6868:     //    |                                       |                                       |
  6869:     //    +                                       +                                       +
  6870:     //    |                                       |                                       |
  6871:     //    |                                       |                                       |
  6872:     //    |                                       |                                       |
  6873:     //    |                                       |                                       |
  6874:     //    +                                       +                                       +
  6875:     //    |                                       |                                       |
  6876:     //    |                                       |                                       |
  6877:     //    |                                       |                                       |
  6878:     //    |                                       |                                       |
  6879:     //    +                                  ***********                                  +
  6880:     //    |                               ****    |    ****                               |
  6881:     //    |                             ***       |       ***                             |
  6882:     //    |                          ****         |         ****                          |
  6883:     //    |                        ***            |            ***                        |
  6884:     //    +---------+---------+--***----+---------+---------+----***--+---------+---------+
  6885:     //    |                    ***                |                ***                    |
  6886:     //    |                  ***                  |                  ***                  |
  6887:     //    **               ***                    |                    ***               **
  6888:     //    |****        *****                      |                      *****        ****|
  6889:     //    +   **********                          +                          **********   +
  6890:     //    |                                       |                                       |
  6891:     //    |                                       |                                       |
  6892:     //    |                                       |                                       |
  6893:     //    |                                       |                                       |
  6894:     //    +                                       +                                       +
  6895:     //    |                                       |                                       |
  6896:     //    |                                       |                                       |
  6897:     //    |                                       |                                       |
  6898:     //    |                                       |                                       |
  6899:     //    +                                       +                                       +
  6900:     //    |                                       |                                       |
  6901:     //    |                                       |                                       |
  6902:     //    |                                       |                                       |
  6903:     //    |                                       |                                       |
  6904:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  6905:     //
  6906:     //  定義域
  6907:     //    -inf<=x<=inf
  6908:     //
  6909:     //  値域
  6910:     //    -1<=y<=1
  6911:     //
  6912:     //  三角関数のとの関係
  6913:     //    cos(x)=(1-tan(x/2)^2)/(1+tan(x/2)^2)
  6914:     //
  6915:     //  変数変換
  6916:     //    収束を速くするために|x|<=pi/4にする
  6917:     //    cos(x)=-sin(x-pi/2)
  6918:     //          =-cos(x-pi)
  6919:     //          =sin(x-3*pi/2)
  6920:     //          =cos(x-2*pi)
  6921:     //                 -sin(x-pi/2)
  6922:     //                             k=1
  6923:     //                       │    ←
  6924:     //            k=2↓＼    │    ／
  6925:     //                   ＼  │  ／
  6926:     //                     ＼│／
  6927:     //    -cos(x-pi) ────・──── cos(x)
  6928:     //                     ／│＼
  6929:     //                   ／  │  ＼
  6930:     //                 ／    │    ＼↑k=0
  6931:     //                 →    │
  6932:     //                k=3
  6933:     //                 sin(x-3*pi/2)
  6934:     //
  6935:     //  メモ
  6936:     //    k=round(x/(pi/2))としてx-k*pi/2を計算するとき、pi/2の近似値3217/2048を用いて
  6937:     //    x-k*pi/2=x-k*(3217/2048+(pi/2-3217/2048))
  6938:     //            =x-k*3217/2048+k*(pi/2-3217/2048)
  6939:     //    を計算するという方法がある
  6940:     //    kは普通は桁数の少ない整数で2048は2の累乗なのでk*3217/2048は正確に計算できる
  6941:     //    xとk*3217/2048はほぼ同じ値なのでx-k*3217/2048は桁落ちを発生させながら正確に計算できる
  6942:     //    k*(pi/2-3217/2048)で発生する誤差は小さい
  6943:     //    echo Pi/2-3217/2048 | gp -q
  6944:     //    -4.4544551033807686783083602485579023568 E-6
  6945:     //
  6946:     //  テイラー展開
  6947:     //    cos(x)=1-x^2/2!+x^4/4!-x^6/6!+...
  6948:     //    f(n,x)=sum(k=0,n,(-1)^k*x^(2*k)/(2*k)!)
  6949:     //    echo read("efp.gp");eval("f(h,x)=sum(k=0,h,(-1)^k/(2*k)!*x^(2*k))");a=-Pi/4;b=-a;hmax=27;print1("    //    ");for(h=0,hmax,n=2*h;printf("%4d",n));print();print1("    //    ");for(h=0,hmax,n=2*h;printf("%4d",floor(closeness(cos,f(h,x),a,b,10000))));print() | gp -q
  6950:     //       0   2   4   6   8  10  12  14  16  18  20  22  24  26  28  30  32  34  36  38  40  42  44  46  48  50  52  54
  6951:     //       1   5  11  17  24  32  40  49  58  67  77  86  96 107 117 128 139 150 161 172 184 195 207 219 231 243 255 267
  6952:     //
  6953:     //  チェビシェフ展開
  6954:     //    echo read("efp.gp");a=-Pi/4;b=-a;hmax=27;print1("    //    ");for(h=0,hmax,n=2*h;printf("%4d",n));print();print1("    //    ");for(h=0,hmax,n=2*h;printf("%4d",floor(closeness(cos,chebyshev(cos,a,b,n),a,b,10000))));print() | gp -q
  6955:     //       0   2   4   6   8  10  12  14  16  18  20  22  24  26  28  30  32  34  36  38  40  42  44  46  48  50  52  54
  6956:     //       2   8  16  24  33  43  53  64  75  86  98 109 121 134 146 159 172 185 198 211 225 238 252 266 280 294 308 322
  6957:     //
  6958:     public final EFP cos () {
  6959:       return this.cos (this);
  6960:     }  //efp.cos()
  6961:     public final EFP cos (EFP x) {
  6962:       int xf = x.flg;
  6963:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  6964:         if (xf << 1 < 0) {  //±0
  6965:           this.flg = P;  //cos(±0)=1
  6966:           this.epp = 0;
  6967:           this.dvl = MSB;
  6968:           this.cvl = 0L;
  6969:         } else if (xf << 2 < 0) {  //±Inf
  6970:           epbFpsr |= EPB_FPSR_OE;
  6971:           epbExceptionOperandExponent = xf & M | 0x7fff << 16;
  6972:           epbExceptionOperandMantissa = 0x0000000000000000L;
  6973:           this.flg = N;  //cos(±Inf)=NaN
  6974:         } else {  //NaN
  6975:           this.flg = N;  //cos(NaN)=NaN
  6976:         }
  6977:         return this;
  6978:       }
  6979:       //±0,±Inf,NaN以外
  6980:       this.inner ();
  6981:       EFP u = new EFP ();
  6982:       EFP u2 = new EFP ();
  6983:       int k = u.ieeerempi2 (x);  //-pi/2<=u<=pi/2。kはx-uの象限
  6984:       if (false) {  //テイラー展開
  6985:         EFP s = new EFP ();
  6986:         EFP t = new EFP ();
  6987:         u2.isqu (u);  //u^2
  6988:         if ((k & 1) != 0) {  //sin
  6989:           //s.sete (u);  //(-1)^k*x^(2*k+1)/(2*k+1)!
  6990:           s.flg = u.flg;
  6991:           s.epp = u.epp;
  6992:           s.dvl = u.dvl;
  6993:           s.cvl = u.cvl;
  6994:           //t.set0 ();
  6995:           t.flg = P | Z;
  6996:           //this.sete (s);
  6997:           this.flg = s.flg;
  6998:           this.epp = s.epp;
  6999:           this.dvl = s.dvl;
  7000:           this.cvl = s.cvl;
  7001:           for (int twok1 = 3; this.ne (t); twok1 += 2) {  //2*k+1
  7002:             s.imul (u2).divi ((1 - twok1) * twok1);  //(-1)^k*x^(2*k+1)/(2*k+1)!
  7003:             //t.sete (this);
  7004:             t.flg = this.flg;
  7005:             t.epp = this.epp;
  7006:             t.dvl = this.dvl;
  7007:             t.cvl = this.cvl;
  7008:             this.iadd (s);
  7009:           }
  7010:         } else {  //cos
  7011:           //s.set1 ();  //(-1)^k*x^(2*k)/(2*k)!
  7012:           s.flg = P;
  7013:           s.epp = 0;
  7014:           s.dvl = MSB;
  7015:           s.cvl = 0L;
  7016:           //t.set0 ();
  7017:           t.flg = P | Z;
  7018:           //this.sete (s);
  7019:           this.flg = s.flg;
  7020:           this.epp = s.epp;
  7021:           this.dvl = s.dvl;
  7022:           this.cvl = s.cvl;
  7023:           for (int twok = 2; this.ne (t); twok += 2) {  //2*k
  7024:             s.imul (u2).divi ((1 - twok) * twok);  //(-1)^k*x^(2*k)/(2*k)!
  7025:             //t.sete (this);
  7026:             t.flg = this.flg;
  7027:             t.epp = this.epp;
  7028:             t.dvl = this.dvl;
  7029:             t.cvl = this.cvl;
  7030:             this.iadd (s);
  7031:           }
  7032:         }
  7033:       } else {  //チェビシェフ展開
  7034:         if ((k & 1) != 0) {  //sin
  7035:           u2.isqu (u);  //u^2
  7036:           this.imul (SIN_C21, u2)
  7037:             .iadd (SIN_C19).imul (u2)
  7038:               .iadd (SIN_C17).imul (u2)
  7039:                 .iadd (SIN_C15).imul (u2)
  7040:                   .iadd (SIN_C13).imul (u2)
  7041:                     .iadd (SIN_C11).imul (u2)
  7042:                       .iadd (SIN_C9).imul (u2)
  7043:                         .iadd (SIN_C7).imul (u2)
  7044:                           .iadd (SIN_C5).imul (u2)
  7045:                             .iadd (SIN_C3).imul (u2)
  7046:                               .iadd (SIN_C1).imul (u);
  7047:         } else {  //cos
  7048:           u2.isqu (u);  //u^2
  7049:           this.imul (COS_C20, u2)
  7050:             .iadd (COS_C18).imul (u2)
  7051:               .iadd (COS_C16).imul (u2)
  7052:                 .iadd (COS_C14).imul (u2)
  7053:                   .iadd (COS_C12).imul (u2)
  7054:                     .iadd (COS_C10).imul (u2)
  7055:                       .iadd (COS_C8).imul (u2)
  7056:                         .iadd (COS_C6).imul (u2)
  7057:                           .iadd (COS_C4).imul (u2)
  7058:                             .iadd (COS_C2).imul (u2)
  7059:                               .iadd (COS_C0);
  7060:         }
  7061:       }
  7062:       //                   0123
  7063:       this.outer ().neg (0b0110 << 28 << k < 0);
  7064:       //  n*pi/2はn==0を除いて正確に表現できないので、
  7065:       //    RZまたはRPでsin(x)およびcos(x)が-1になることはあり得ない
  7066:       //    RZまたはRMでsin(x)およびcos(x)がcos(0)以外で+1になることはあり得ない
  7067:       if (this.flg << 1 == 0 && this.epp == 0) {  //結果が±1
  7068:         if (this.flg < 0) {  //結果が-1
  7069:           if (epbRoundingMode == EPB_MODE_RZ || epbRoundingMode == EPB_MODE_RP) {  //RZまたはRPで結果が-1
  7070:             this.sete (NEXTUP_MINUSONE[epbRoundingPrec]);
  7071:           }
  7072:         } else {  //結果が+1
  7073:           if (epbRoundingMode == EPB_MODE_RZ || epbRoundingMode == EPB_MODE_RM) {  //RZまたはRMで結果が+1
  7074:             this.sete (NEXTDOWN_PLUSONE[epbRoundingPrec]);
  7075:           }
  7076:         }
  7077:       }
  7078:       return this;
  7079:     }  //efp.cos(EFP)
  7080: 
  7081:     //------------------------------------------------------------------------
  7082:     //x = x.cosh ()
  7083:     //  x=cosh(x)
  7084:     //y = y.cosh (x)
  7085:     //  y=cosh(x)
  7086:     //  双曲線余弦 hyperbolic cosine ハイパボリックコサイン
  7087:     //
  7088:     //  グラフ
  7089:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{cosh($_[0])});print$g"
  7090:     //    echo read("efp.gp");graph(cosh) | gp -q
  7091:     //    +---------+--------**---------+---------+---------+---------**--------+---------+
  7092:     //    |                   *                   |                   *                   |
  7093:     //    |                   **                  |                  **                   |
  7094:     //    |                    *                  |                  *                    |
  7095:     //    |                    **                 |                 **                    |
  7096:     //    +                     **                +                **                     +
  7097:     //    |                      *                |                *                      |
  7098:     //    |                      **               |               **                      |
  7099:     //    |                       **              |              **                       |
  7100:     //    |                        **             |             **                        |
  7101:     //    +                         **            +            **                         +
  7102:     //    |                          ***          |          ***                          |
  7103:     //    |                            **         |         **                            |
  7104:     //    |                             ***       |       ***                             |
  7105:     //    |                               *****   |   *****                               |
  7106:     //    +                                   *********                                   +
  7107:     //    |                                       |                                       |
  7108:     //    |                                       |                                       |
  7109:     //    |                                       |                                       |
  7110:     //    |                                       |                                       |
  7111:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  7112:     //    |                                       |                                       |
  7113:     //    |                                       |                                       |
  7114:     //    |                                       |                                       |
  7115:     //    |                                       |                                       |
  7116:     //    +                                       +                                       +
  7117:     //    |                                       |                                       |
  7118:     //    |                                       |                                       |
  7119:     //    |                                       |                                       |
  7120:     //    |                                       |                                       |
  7121:     //    +                                       +                                       +
  7122:     //    |                                       |                                       |
  7123:     //    |                                       |                                       |
  7124:     //    |                                       |                                       |
  7125:     //    |                                       |                                       |
  7126:     //    +                                       +                                       +
  7127:     //    |                                       |                                       |
  7128:     //    |                                       |                                       |
  7129:     //    |                                       |                                       |
  7130:     //    |                                       |                                       |
  7131:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  7132:     //
  7133:     //  定義域
  7134:     //    -inf<=x<=inf
  7135:     //
  7136:     //  値域
  7137:     //    1<=y<=inf
  7138:     //
  7139:     //  指数関数との関係
  7140:     //    cosh(x)=(e^x+e^-x)/2
  7141:     //           =((e^x)^2+1)/(2*e^x)
  7142:     //
  7143:     //  テイラー展開
  7144:     //    cosh(x)=1+x^2/2!+x^4/4!+x^6/6!+...
  7145:     //    f(n,x)=sum(k=0,n,x^(2*k)/(2*k)!)
  7146:     //    echo read("efp.gp");eval("f(h,x)=sum(k=0,h,1/(2*k)!*x^(2*k))");a=-1;b=-a;hmax=27;print1("    //    ");for(h=0,hmax,n=2*h;printf("%4d",n));print();print1("    //    ");for(h=0,hmax,n=2*h;printf("%4d",floor(closeness(cosh,f(h,x),a,b,10000))));print() | gp -q
  7147:     //       0   2   4   6   8  10  12  14  16  18  20  22  24  26  28  30  32  34  36  38  40  42  44  46  48  50  52  54
  7148:     //       1   5  10  15  22  29  36  44  53  61  70  79  89  98 108 118 128 138 149 159 170 181 192 203 214 226 237 249
  7149:     //
  7150:     //  チェビシェフ展開
  7151:     //    echo read("efp.gp");a=-1;b=-a;nmax=54;print1("    //    ");forstep(n=0,nmax,2,printf("%4d",n));print();print1("    //    ");forstep(n=0,nmax,2,printf("%4d",floor(closeness(cosh,chebyshev(cosh,a,b,n),a,b,10000))));print() | gp -q
  7152:     //       0   2   4   6   8  10  12  14  16  18  20  22  24  26  28  30  32  34  36  38  40  42  44  46  48  50  52  54
  7153:     //       2   7  14  22  30  39  49  59  69  80  90 102 113 124 136 148 160 173 185 198 210 223 236 249 263 276 290 303
  7154:     //
  7155:     public final EFP cosh () {
  7156:       return this.cosh (this);
  7157:     }  //efp.cosh()
  7158:     public final EFP cosh (EFP x) {
  7159:       int xf = x.flg;
  7160:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  7161:         if (xf << 1 < 0) {  //cosh(±0)=1
  7162:           //this.set1 ();
  7163:           this.flg = P;
  7164:           this.epp = 0;
  7165:           this.dvl = MSB;
  7166:           this.cvl = 0L;
  7167:         } else if (xf << 2 < 0) {  //cosh(±Inf)=+Inf
  7168:           this.flg = P | I;
  7169:         } else {  //cosh(NaN)=NaN
  7170:           this.flg = N;
  7171:         }
  7172:         return this;
  7173:       }
  7174:       //±0,±Inf,NaN以外
  7175:       epbFpsr |= EPB_FPSR_X2;  //不正確な結果。オーバーフローまたはアンダーフローのときもセットされる
  7176:       epbExceptionOperandExponent = xf | 0x3fff + x.epp << 16;
  7177:       epbExceptionOperandMantissa = x.dvl;
  7178:       if (15 <= x.epp) {  //x<=-32768||32768<=x。cosh(-big)=+Inf,cosh(+big)=+Inf
  7179:         epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
  7180:         return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1]).finish ();  //+Inf
  7181:       }
  7182:       if (x.epp < -3) {  //|x|<0.125
  7183:         EFP x2 = new EFP ().inner ().isqu (x);  //x^2
  7184:         return this.imul (COSH_C14, x2)
  7185:           .iadd (COSH_C12).imul (x2)
  7186:             .iadd (COSH_C10).imul (x2)
  7187:               .iadd (COSH_C8).imul (x2)
  7188:                 .iadd (COSH_C6).imul (x2)
  7189:                   .iadd (COSH_C4).imul (x2)
  7190:                     .iadd (COSH_C2).imul (x2)
  7191:                       .outer ().add (COSH_C0);
  7192:       }
  7193:       //0.125<=|x|
  7194:       //  xが絶対値の大きい負数のときそのままe^xを計算するとアンダーフローして0になりさらに1/e^xがゼロ除算になる
  7195:       //  オーバーフローだけセットさせるためにxの符号を取ってからe^xを計算する
  7196:       this.inner ().abs (x).exp ();  //e^|x|
  7197:       this.iadd (new EFP ().rcp (this)).outer ().div2 ();  //(e^|x|+e^-|x|)/2
  7198:       if (this.flg << 2 < 0) {
  7199:         epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
  7200:         return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | this.flg >>> 31]).finish ();  //±Inf
  7201:       }
  7202:       return this;
  7203:     }  //efp.cosh(EFP)
  7204: 
  7205:     //------------------------------------------------------------------------
  7206:     //x = x.cot ()
  7207:     //  x=cot(x)
  7208:     //y = y.cot (x)
  7209:     //  y=cot(x)
  7210:     //  余接 cotangent コタンジェント
  7211:     //
  7212:     //  グラフ
  7213:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{cot($_[0])});print$g"
  7214:     //    echo read("../misc/efp.gp");graph(cotan) | gp -q
  7215:     //    +---------+*--------+---------+---------+-**------+---------+---------+---*-----+
  7216:     //    |          *                            |  *                              *     |
  7217:     //    |          *                            |  *                              *     |
  7218:     //    |          **                           |  *                              *     |
  7219:     //    |           *                           |  *                              **    |
  7220:     //    +           *                           +  *                               *    +
  7221:     //    |           *                           |  **                              *    |
  7222:     //    |           *                           |   *                              *    |
  7223:     //    |           **                          |   *                              **   |
  7224:     //    |            *                          |   *                               *   |
  7225:     //    +            *                          +   **                              *   +
  7226:     //    |            **                         |    *                              **  |
  7227:     //    |             *                         |    **                              *  |
  7228:     //    |             **                        |     **                             ** |
  7229:     //    |              **                       |      *                              **|
  7230:     //    +               **                      +      **                              **
  7231:     //    |                **                     |       ***                             *
  7232:     //    |                 ***                   |         **                            |
  7233:     //    |                   **                  |          ***                          |
  7234:     //    |                    ***                |            ***                        |
  7235:     //    +---------+---------+--***----+---------+---------+----***--+---------+---------+
  7236:     //    |                        ***            |                ***                    |
  7237:     //    |                          ***          |                  **                   |
  7238:     //    |                            **         |                   ***                 |
  7239:     //    *                             ***       |                     **                |
  7240:     //    **                              **      +                      **               +
  7241:     //    |**                              *      |                       **              |
  7242:     //    | **                             **     |                        **             |
  7243:     //    |  *                              **    |                         *             |
  7244:     //    |  **                              *    |                         **            |
  7245:     //    +   *                              **   +                          *            +
  7246:     //    |   *                               *   |                          *            |
  7247:     //    |   **                              *   |                          **           |
  7248:     //    |    *                              *   |                           *           |
  7249:     //    |    *                              **  |                           *           |
  7250:     //    +    *                               *  +                           *           +
  7251:     //    |    **                              *  |                           *           |
  7252:     //    |     *                              *  |                           **          |
  7253:     //    |     *                              *  |                            *          |
  7254:     //    |     *                              *  |                            *          |
  7255:     //    +-----*---+---------+---------+------**-+---------+---------+--------*+---------+
  7256:     //
  7257:     //  定義域
  7258:     //    -inf<=x<=inf
  7259:     //    n*piを除く
  7260:     //
  7261:     //  値域
  7262:     //    -inf<=cot(x)<=inf
  7263:     //
  7264:     //  三角関数との関係
  7265:     //    cot(x)=1/tan(x)
  7266:     //          =cos(x)/sin(x)
  7267:     //          =tan(pi/2-x)
  7268:     //
  7269:     public final EFP cot () {
  7270:       return this.cot (this);
  7271:     }  //efp.cot()
  7272:     public final EFP cot (EFP x) {
  7273:       int xf = x.flg;
  7274:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  7275:         if (xf << 1 < 0) {  //±0
  7276:           epbFpsr |= EPB_FPSR_OE;
  7277:           epbExceptionOperandExponent = xf & M;
  7278:           epbExceptionOperandMantissa = 0x0000000000000000L;
  7279:           this.flg = N;  //cot(±0)=NaN
  7280:         } else if (xf << 2 < 0) {  //±Inf
  7281:           epbFpsr |= EPB_FPSR_OE;
  7282:           epbExceptionOperandExponent = xf & M | 0x7fff << 16;
  7283:           epbExceptionOperandMantissa = 0x0000000000000000L;
  7284:           this.flg = N;  //cot(±Inf)=NaN
  7285:         } else {  //NaN
  7286:           this.flg = N;  //cot(NaN)=NaN
  7287:         }
  7288:         return this;
  7289:       }
  7290:       //±0,±Inf,NaN以外
  7291:       if (false) {  //cos(x)/sin(x)。[90] 810ns
  7292:         EFP s = new EFP ().inner ().sin (x);  //sin(x)
  7293:         return this.cos (x).outer ().div (s);  //cos(x)/sin(x)
  7294:       } else if (false) {  //tan(pi/2-x)。[38]
  7295:         return this.inner ().sub (PI_2, x).iadd (PI_2A).outer ().tan ();  //cot(x)=tan(pi/2-x)
  7296:       } else if (false) {  //1/tan(x)。[90] 415ns
  7297:         return this.inner ().tan (x).outer ().rcp ();  //cot(x)=1/tan(x)
  7298:       } else {  //128分割。[90] 340ns
  7299:         if (15 <= x.epp) {  //|x|が大きすぎる
  7300:           EFP s = new EFP ().inner ().sin (x);  //sin(x)
  7301:           return this.cos (x).outer ().div (s);  //cos(x)/sin(x)
  7302:         }
  7303:         this.inner ();
  7304:         EFP s = new EFP ();
  7305:         EFP t = new EFP ();
  7306:         EFP u = new EFP ().iabs (x);  //|x|
  7307:         EFP u2 = new EFP ();
  7308:         s.iadd (u, TAN7_X).imul (TAN7_Y).trunc ();  //|x|+pi/256をpi/128で割った商
  7309:         //  |x|をpi/128で割った余りを求めるとき|x|がpi/128の整数倍に近いと桁落ちが発生するので倍精度で計算する
  7310:         u.sub (t.imulw (u2, s, TAN7_Z)).sub (u2).sub (t.imul (s, TAN7_ZA));  //|x|をpi/128で割った余り。[-pi/256,pi/256]
  7311:         int k = s.geti () & 127;  //|x|+pi/256をpi/128で割った商の下位7bit
  7312:         u2.isqu (u);  //u^2
  7313:         this.imul (TAN7_C11, u2)
  7314:           .iadd (TAN7_C9).imul (u2)
  7315:             .iadd (TAN7_C7).imul (u2)
  7316:               .iadd (TAN7_C5).imul (u2)
  7317:                 .iadd (TAN7_C3).imul (u2)
  7318:                   .iadd (TAN7_C1).imul (u);
  7319:         if (k == 0) {
  7320:           this.rcp ();  //1/tan(x)
  7321:         } else if (k <= 63) {
  7322:           t = TAN7_T[k];
  7323:           s.iadd (this, t);
  7324:           this.imul (t).negdec ().div (s);  //(1-tan(k*pi/128)*t)/(tan(x-k*pi/128)+t)
  7325:         } else if (k == 64) {
  7326:           this.ineg ();  //-tan(x-pi/2)
  7327:         } else {
  7328:           t = TAN7_T[128 - k];
  7329:           s.sub (this, t);
  7330:           this.imul (t).inc ().div (s);  //(1+tan((128-k)*pi/128)*t)/(tan(x-(128-k)*pi/128)-t)
  7331:         }
  7332:         return this.outer ().neg (xf < 0);  //cotは奇関数なのでxの符号を掛ける
  7333:       }
  7334:     }  //efp.cot(EFP)
  7335: 
  7336:     //------------------------------------------------------------------------
  7337:     //x = x.coth ()
  7338:     //  x=coth(x)
  7339:     //y = y.coth (x)
  7340:     //  y=coth(x)
  7341:     //  双曲線余接 hyperbolic cotangent ハイパボリックコタンジェント
  7342:     //
  7343:     //  グラフ
  7344:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{coth($_[0])});print$g"
  7345:     //    echo read("../misc/efp.gp");eval("coth(x)=1/tanh(x)");graph(coth) | gp -q
  7346:     //    +---------+---------+---------+---------+-**------+---------+---------+---------+
  7347:     //    |                                       |  *                                    |
  7348:     //    |                                       |  *                                    |
  7349:     //    |                                       |  *                                    |
  7350:     //    |                                       |  *                                    |
  7351:     //    +                                       +  **                                   +
  7352:     //    |                                       |   *                                   |
  7353:     //    |                                       |   *                                   |
  7354:     //    |                                       |   **                                  |
  7355:     //    |                                       |    *                                  |
  7356:     //    +                                       +    **                                 +
  7357:     //    |                                       |     **                                |
  7358:     //    |                                       |      **                               |
  7359:     //    |                                       |       ***                             |
  7360:     //    |                                       |         ******                        |
  7361:     //    +                                       +              **************************
  7362:     //    |                                       |                                       |
  7363:     //    |                                       |                                       |
  7364:     //    |                                       |                                       |
  7365:     //    |                                       |                                       |
  7366:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  7367:     //    |                                       |                                       |
  7368:     //    |                                       |                                       |
  7369:     //    |                                       |                                       |
  7370:     //    |                                       |                                       |
  7371:     //    **************************              +                                       +
  7372:     //    |                        ******         |                                       |
  7373:     //    |                             ***       |                                       |
  7374:     //    |                               **      |                                       |
  7375:     //    |                                **     |                                       |
  7376:     //    +                                 **    +                                       +
  7377:     //    |                                  *    |                                       |
  7378:     //    |                                  **   |                                       |
  7379:     //    |                                   *   |                                       |
  7380:     //    |                                   *   |                                       |
  7381:     //    +                                   **  +                                       +
  7382:     //    |                                    *  |                                       |
  7383:     //    |                                    *  |                                       |
  7384:     //    |                                    *  |                                       |
  7385:     //    |                                    *  |                                       |
  7386:     //    +---------+---------+---------+------**-+---------+---------+---------+---------+
  7387:     //
  7388:     //  定義域
  7389:     //    -inf<=x<0
  7390:     //    0<x<=inf
  7391:     //
  7392:     //  値域
  7393:     //    -inf<=y<1
  7394:     //    1<y<=inf
  7395:     //
  7396:     //  双曲線関数との関係
  7397:     //    coth(x)=1/tanh(x)
  7398:     //           =cosh(x)/sinh(x)
  7399:     //
  7400:     //  指数関数との関係
  7401:     //    coth(x)=(e^x+e^(-x))/(e^x-e^(-x))
  7402:     //           =1+2*e^(-x)/(e^x-e^(-x))
  7403:     //           =((e^x)^2+1)/((e^x)^2-1)
  7404:     //
  7405:     //  定義域の制限
  7406:     //    x=log(sqrt(2^(n+1)+1))
  7407:     //    のとき
  7408:     //    (e^x)^2=2^(n+1)+1
  7409:     //    coth(x)=((e^x)^2+1)/((e^x)^2-1)
  7410:     //           =(2^(n+1)+1+1)/(2^(n+1)+1-1)
  7411:     //           =(2^(n+1)+2)/2^(n+1)
  7412:     //           =1+1/2^n
  7413:     //    したがって、仮数部がnbitのとき
  7414:     //    log(sqrt(2^(n+1)+1))<x
  7415:     //    ならばcoth(x)と1を区別できない(cothは奇関数なので負のときも同様)
  7416:     //    > log(sqrt(2^(53+1)+1));
  7417:     //    18.714973875118523382020842894999680078257317575103
  7418:     //    > log(sqrt(2^(92+1)+1));
  7419:     //    32.231343896037456887901293647855697513444901003298
  7420:     //    cosh(x)/sinh(x)ではxの絶対値が大きすぎるとInf/Infで結果がNaNになってしまうので途中で打ち切って1にする必要がある
  7421:     //
  7422:     public final EFP coth () {
  7423:       return this.coth (this);
  7424:     }  //efp.coth()
  7425:     public final EFP coth (EFP x) {
  7426:       int xf = x.flg;
  7427:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  7428:         if (xf << 1 < 0) {  //±0
  7429:           epbFpsr |= EPB_FPSR_OE;
  7430:           epbExceptionOperandExponent = xf & M;
  7431:           epbExceptionOperandMantissa = 0x0000000000000000L;
  7432:           this.flg = N;  //coth(±0)=NaN
  7433:         } else if (xf << 2 < 0) {  //±Inf
  7434:           this.flg = xf & M;  //coth(±Inf)=±1
  7435:           this.epp = 0;
  7436:           this.dvl = MSB;
  7437:           this.cvl = 0L;
  7438:         } else {  //NaN
  7439:           this.flg = N;  //coth(NaN)=NaN
  7440:         }
  7441:         return this;
  7442:       }
  7443:       //±0,±Inf,NaN以外
  7444:       //  e^xを経由する方法はオーバーフローを発生させずに計算できる範囲が狭いので|x|が大きい場合を分ける必要がある
  7445:       int xe = x.epp;
  7446:       if (xe < -2) {  //|x|<0.25
  7447:         EFP x2 = new EFP ().inner ().isqu (x);  //x^2
  7448:         return this.imul (TANH_C27, x2)
  7449:           .iadd (TANH_C25).imul (x2)
  7450:             .iadd (TANH_C23).imul (x2)
  7451:               .iadd (TANH_C21).imul (x2)
  7452:                 .iadd (TANH_C19).imul (x2)
  7453:                   .iadd (TANH_C17).imul (x2)
  7454:                     .iadd (TANH_C15).imul (x2)
  7455:                       .iadd (TANH_C13).imul (x2)
  7456:                         .iadd (TANH_C11).imul (x2)
  7457:                           .iadd (TANH_C9).imul (x2)
  7458:                             .iadd (TANH_C7).imul (x2)
  7459:                               .iadd (TANH_C5).imul (x2)
  7460:                                 .iadd (TANH_C3).imul (x2)
  7461:                                   .iadd (TANH_C1).imul (x).outer ().rcp ();
  7462:       }
  7463:       //0.25<=|x|
  7464:       if (false) {  //cosh/sinh
  7465:         EFP s = new EFP ().inner ().sinh (x);  //sinh(x)
  7466:         return this.cosh (x).outer ().div (s);  //cosh(x)/sinh(x)
  7467:       } else if (EFP_COTH_EPP_MAX < xe) {
  7468:         this.flg = xf & M;  //±1
  7469:         this.epp = 0;
  7470:         this.dvl = MSB;
  7471:         this.cvl = 0L;
  7472:         return this;
  7473:       } else {
  7474:         EFP t = new EFP ().inner ().imul2 (x).exp ();  //e^(2*x)
  7475:         return this.inc (t).outer ().div (t.dec ());  //(e^(2*x)+1)/(e^(2*x)-1)
  7476:       }
  7477:     }  //efp.coth(EFP)
  7478: 
  7479:     //------------------------------------------------------------------------
  7480:     //x = x.csc ()
  7481:     //  x=csc(x)
  7482:     //y = y.csc (x)
  7483:     //  y=csc(x)
  7484:     //  余割 cosecant コセカント
  7485:     //
  7486:     //  グラフ
  7487:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{csc($_[0])});print$g"
  7488:     //    echo read("../misc/efp.gp");eval("csc(x)=1/sin(x)");graph(csc) | gp -q
  7489:     //    +-----*---+---------+---------+---------+-**------+---------+--------*+---------+
  7490:     //    |     *                                 |  *                         *          |
  7491:     //    |     *                                 |  *                         *          |
  7492:     //    |     *                                 |  *                        **          |
  7493:     //    |    **                                 |  *                        *           |
  7494:     //    +    *                                  +  **                       *           +
  7495:     //    |    *                                  |   *                       *           |
  7496:     //    |   **                                  |   *                      **           |
  7497:     //    |   *                                   |   *                      *            |
  7498:     //    |   *                                   |   **                    **            |
  7499:     //    +  **                                   +    **                   *             +
  7500:     //    | **                                    |     *                  **             |
  7501:     //    |**                                     |     **                **              |
  7502:     //    **                                      |      ***             **               |
  7503:     //    |                                       |        ***        ****                |
  7504:     //    +                                       +          **********                   +
  7505:     //    |                                       |                                       |
  7506:     //    |                                       |                                       |
  7507:     //    |                                       |                                       |
  7508:     //    |                                       |                                       |
  7509:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  7510:     //    |                                       |                                       |
  7511:     //    |                                       |                                       |
  7512:     //    |                                       |                                       |
  7513:     //    |                                       |                                       |
  7514:     //    +                   **********          +                                       +
  7515:     //    |                ****        ***        |                                       |
  7516:     //    |               **             ***      |                                      **
  7517:     //    |              **                **     |                                     **|
  7518:     //    |             **                  *     |                                    ** |
  7519:     //    +             *                   **    +                                   **  +
  7520:     //    |            **                    **   |                                   *   |
  7521:     //    |            *                      *   |                                   *   |
  7522:     //    |           **                      *   |                                  **   |
  7523:     //    |           *                       *   |                                  *    |
  7524:     //    +           *                       **  +                                  *    +
  7525:     //    |           *                        *  |                                 **    |
  7526:     //    |          **                        *  |                                 *     |
  7527:     //    |          *                         *  |                                 *     |
  7528:     //    |          *                         *  |                                 *     |
  7529:     //    +---------+*--------+---------+------**-+---------+---------+---------+---*-----+
  7530:     //
  7531:     //  定義域
  7532:     //    -inf<=x<=inf
  7533:     //    n*piを除く
  7534:     //
  7535:     //  値域
  7536:     //    -inf<=y<=-1
  7537:     //    1<=y<=inf
  7538:     //
  7539:     //  三角関数との関係
  7540:     //    csc(x)=1/sin(x)
  7541:     //
  7542:     public final EFP csc () {
  7543:       return this.csc (this);
  7544:     }  //efp.csc()
  7545:     public final EFP csc (EFP x) {
  7546:       return this.inner ().sin (x).outer ().rcp ();  //1/sin(x)
  7547:     }  //efp.csc(EFP)
  7548: 
  7549:     //------------------------------------------------------------------------
  7550:     //x = x.csch ()
  7551:     //  x=csch(x)
  7552:     //y = y.csch (x)
  7553:     //  y=csch(x)
  7554:     //  双曲線余割 hyperbolic cosecant ハイパボリックコセカント
  7555:     //
  7556:     //  グラフ
  7557:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{csch($_[0])});print$g"
  7558:     //    echo read("../misc/efp.gp");eval("csch(x)=1/sinh(x)");graph(csch) | gp -q
  7559:     //    +---------+---------+---------+---------+-**------+---------+---------+---------+
  7560:     //    |                                       |  *                                    |
  7561:     //    |                                       |  *                                    |
  7562:     //    |                                       |  *                                    |
  7563:     //    |                                       |  *                                    |
  7564:     //    +                                       +  *                                    +
  7565:     //    |                                       |  **                                   |
  7566:     //    |                                       |   *                                   |
  7567:     //    |                                       |   *                                   |
  7568:     //    |                                       |   **                                  |
  7569:     //    +                                       +    *                                  +
  7570:     //    |                                       |    **                                 |
  7571:     //    |                                       |     *                                 |
  7572:     //    |                                       |     **                                |
  7573:     //    |                                       |      **                               |
  7574:     //    +                                       +       ***                             +
  7575:     //    |                                       |         ***                           |
  7576:     //    |                                       |           ***                         |
  7577:     //    |                                       |             ******                    |
  7578:     //    |                                       |                  ************         |
  7579:     //    ***********---------+---------+---------+---------+---------+---------***********
  7580:     //    |         ************                  |                                       |
  7581:     //    |                    ******             |                                       |
  7582:     //    |                         ***           |                                       |
  7583:     //    |                           ***         |                                       |
  7584:     //    +                             ***       +                                       +
  7585:     //    |                               **      |                                       |
  7586:     //    |                                **     |                                       |
  7587:     //    |                                 *     |                                       |
  7588:     //    |                                 **    |                                       |
  7589:     //    +                                  *    +                                       +
  7590:     //    |                                  **   |                                       |
  7591:     //    |                                   *   |                                       |
  7592:     //    |                                   *   |                                       |
  7593:     //    |                                   **  |                                       |
  7594:     //    +                                    *  +                                       +
  7595:     //    |                                    *  |                                       |
  7596:     //    |                                    *  |                                       |
  7597:     //    |                                    *  |                                       |
  7598:     //    |                                    *  |                                       |
  7599:     //    +---------+---------+---------+------**-+---------+---------+---------+---------+
  7600:     //
  7601:     //  定義域
  7602:     //    -inf<=x<0
  7603:     //    0<x<=inf
  7604:     //
  7605:     //  値域
  7606:     //    -inf<=y<0
  7607:     //    0<y<=inf
  7608:     //
  7609:     //  双曲線関数との関係
  7610:     //    csch(x)=1/sinh(x)
  7611:     //
  7612:     //  指数関数との関係
  7613:     //    csch(x)=2/(e^x-e^-x)
  7614:     //           =2*e^x/((e^x)^2-1)
  7615:     //
  7616:     public final EFP csch () {
  7617:       return this.csch (this);
  7618:     }  //efp.csch()
  7619:     public final EFP csch (EFP x) {
  7620:       int xf = x.flg;
  7621:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  7622:         if (xf << 1 < 0) {  //±0
  7623:           epbFpsr |= EPB_FPSR_OE;
  7624:           epbExceptionOperandExponent = xf & M;
  7625:           epbExceptionOperandMantissa = 0x0000000000000000L;
  7626:           this.flg = N;  //csch(±0)=NaN
  7627:         } else {  //±Inf,NaN
  7628:           this.flg = xf << 2 < 0 ? xf ^ (Z | I) : N;  //csch(±Inf)=±0, csch(NaN)=NaN
  7629:         }
  7630:         return this;
  7631:       }
  7632:       //±0,±Inf,NaN以外
  7633:       if (true) {
  7634:         return this.inner ().sinh (x).outer ().rcp ();  //1/sinh(x) [88] 89以上が多いが88も出ることがある
  7635:       } else if (false) {
  7636:         this.inner ().exp (x);  //e^x
  7637:         return this.sub (new EFP ().rcp (this)).outer ().rcp ().outer ().mul2 ();  //2/(e^x-e^-x) [87]
  7638:       } else {
  7639:         return this.sub (new EFP ().inner ().exp (x), new EFP ().ineg (x).exp ()).rcp ().outer ().mul2 ();  //2/(e^x-e^-x) [88]
  7640:       }
  7641:     }  //efp.csch(EFP)
  7642: 
  7643:     //------------------------------------------------------------------------
  7644:     //x = x.cub ()
  7645:     //  x*=x^2
  7646:     //y = y.cub (x)
  7647:     //  y=x^3
  7648:     //  3乗
  7649:     //
  7650:     //  グラフ
  7651:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{$_[0]**3});print$g"
  7652:     //    echo read("../misc/efp.gp");eval("cub(x)=x^3");graph(cub) | gp -q
  7653:     //    +---------+---------+---------+---------+---------+-----*---+---------+---------+
  7654:     //    |                                       |              **                       |
  7655:     //    |                                       |              *                        |
  7656:     //    |                                       |              *                        |
  7657:     //    |                                       |              *                        |
  7658:     //    +                                       +             **                        +
  7659:     //    |                                       |             *                         |
  7660:     //    |                                       |             *                         |
  7661:     //    |                                       |            **                         |
  7662:     //    |                                       |            *                          |
  7663:     //    +                                       +           **                          +
  7664:     //    |                                       |           *                           |
  7665:     //    |                                       |          **                           |
  7666:     //    |                                       |          *                            |
  7667:     //    |                                       |         **                            |
  7668:     //    +                                       +         *                             +
  7669:     //    |                                       |        **                             |
  7670:     //    |                                       |       **                              |
  7671:     //    |                                       |      **                               |
  7672:     //    |                                       |    ***                                |
  7673:     //    +---------+---------+---------+----***********----+---------+---------+---------+
  7674:     //    |                                ***    |                                       |
  7675:     //    |                               **      |                                       |
  7676:     //    |                              **       |                                       |
  7677:     //    |                             **        |                                       |
  7678:     //    +                             *         +                                       +
  7679:     //    |                            **         |                                       |
  7680:     //    |                            *          |                                       |
  7681:     //    |                           **          |                                       |
  7682:     //    |                           *           |                                       |
  7683:     //    +                          **           +                                       +
  7684:     //    |                          *            |                                       |
  7685:     //    |                         **            |                                       |
  7686:     //    |                         *             |                                       |
  7687:     //    |                         *             |                                       |
  7688:     //    +                        **             +                                       +
  7689:     //    |                        *              |                                       |
  7690:     //    |                        *              |                                       |
  7691:     //    |                        *              |                                       |
  7692:     //    |                       **              |                                       |
  7693:     //    +---------+---------+---*-----+---------+---------+---------+---------+---------+
  7694:     //
  7695:     //  定義域
  7696:     //    -inf<=x<=inf
  7697:     //
  7698:     //  値域
  7699:     //    -inf<=y<=inf
  7700:     //
  7701:     //  (a*x^2+b*x+c)^3 = a^3*x^6 + 3*a^2*b*x^5 + (3*a^2*c + 3*a*b^2)*x^4 + (6*a*b*c + b^3)*x^3 + (3*a*c^2 + 3*b^2*c)*x^2 + 3*b*c^2*x + c^3
  7702:     //
  7703:     public final EFP cub () {
  7704:       return this.mul (new EFP ().isqu (this));  //x*x^2
  7705:     }  //efp.cub()
  7706:     public final EFP cub (EFP x) {
  7707:       return this.mul (x, new EFP ().isqu (x));  //x*x^2
  7708:     }  //efp.cub(EFP)
  7709: 
  7710:     //------------------------------------------------------------------------
  7711:     //x = x.dec ()
  7712:     //  x-=1
  7713:     //y = y.dec (x)
  7714:     //  y=x-1
  7715:     //  1を引く(デクリメント)
  7716:     //
  7717:     //  グラフ
  7718:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{$_[0]-1});print$g"
  7719:     //    echo read("../misc/efp.gp");eval("dec(x)=x-1");graph(dec) | gp -q
  7720:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  7721:     //    |                                       |                                       |
  7722:     //    |                                       |                                       |
  7723:     //    |                                       |                                       |
  7724:     //    |                                       |                                       |
  7725:     //    +                                       +                                      **
  7726:     //    |                                       |                                    ***|
  7727:     //    |                                       |                                  ***  |
  7728:     //    |                                       |                                ***    |
  7729:     //    |                                       |                              ***      |
  7730:     //    +                                       +                            ***        +
  7731:     //    |                                       |                          ***          |
  7732:     //    |                                       |                        ***            |
  7733:     //    |                                       |                      ***              |
  7734:     //    |                                       |                    ***                |
  7735:     //    +                                       +                  ***                  +
  7736:     //    |                                       |                ***                    |
  7737:     //    |                                       |              ***                      |
  7738:     //    |                                       |            ***                        |
  7739:     //    |                                       |          ***                          |
  7740:     //    +---------+---------+---------+---------+--------***--------+---------+---------+
  7741:     //    |                                       |      ***                              |
  7742:     //    |                                       |    ***                                |
  7743:     //    |                                       |  ***                                  |
  7744:     //    |                                       |***                                    |
  7745:     //    +                                      ***                                      +
  7746:     //    |                                    ***|                                       |
  7747:     //    |                                  ***  |                                       |
  7748:     //    |                                ***    |                                       |
  7749:     //    |                              ***      |                                       |
  7750:     //    +                            ***        +                                       +
  7751:     //    |                          ***          |                                       |
  7752:     //    |                        ***            |                                       |
  7753:     //    |                      ***              |                                       |
  7754:     //    |                    ***                |                                       |
  7755:     //    +                  ***                  +                                       +
  7756:     //    |                ***                    |                                       |
  7757:     //    |              ***                      |                                       |
  7758:     //    |            ***                        |                                       |
  7759:     //    |          ***                          |                                       |
  7760:     //    +--------***--------+---------+---------+---------+---------+---------+---------+
  7761:     //
  7762:     public final EFP dec () {
  7763:       return this.dec (this);
  7764:     }  //efp.dec()
  7765:     public final EFP dec (EFP x) {
  7766:       //return this.sub (x, ONE);  //7.4ns
  7767:       //6.1ns
  7768:       int xf = x.flg;
  7769:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  7770:         if (xf << 1 < 0) {  //±0
  7771:           this.flg = M;  //-1
  7772:           this.epp = 0;
  7773:           this.dvl = MSB;
  7774:           this.cvl = 0L;
  7775:         } else {  //±Inf,NaN
  7776:           this.flg = xf;
  7777:         }
  7778:         return this;
  7779:       }
  7780:       //±0,±Inf,NaN以外
  7781:       int xe = x.epp;
  7782:       if (xe < -LEN) {  //..-LEN-1。xの先頭がguard bitよりも右
  7783:         //絶対値は1の方が大きいのでxを右にシフトするがxの絶対値が小さすぎるので-1になる
  7784:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  7785:         this.flg = M;  //-1
  7786:         this.epp = 0;
  7787:         this.dvl = MSB;
  7788:         this.cvl = 0L;
  7789:         return this;
  7790:       }
  7791:       long xd = x.dvl;
  7792:       long xc = x.cvl;
  7793:       if (LEN < xe) {  //LEN+1..。1がguard bitよりも右
  7794:         //絶対値はxの方が大きいので1を右にシフトするが1の絶対値が小さすぎるのでxになる
  7795:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  7796:         return this.finish (xf, xe, xd, xc, 0L);  //x
  7797:       }
  7798:       long xb = 0L;
  7799:       if (xe == 0) {  //0。xの最上位bitと1が重なる
  7800:         //絶対値はxの方が大きいか等しいが小数点の位置は同じ
  7801:         if (xf < 0) {  //-x
  7802:           //絶対値に1を加える
  7803:           xb = xc << -1;
  7804:           xc = xd << -1 | xc >>> 1;
  7805:           xd = (xd >>> 1) + (MSB >>> 1);
  7806:           xe++;
  7807:         } else {  //+x
  7808:           //絶対値から1を引く
  7809:           xd -= MSB;
  7810:         }
  7811:       } else if (0 < xe) {  //1..LEN
  7812:         //絶対値はxの方が大きいので1を右にシフトする
  7813:         if (xf < 0) {  //-x
  7814:           //絶対値に1を加える
  7815:           if (xe <= 63) {  //1..63。xの上位と1が重なる
  7816:             if ((xd += MSB >>> xe) >>> ~xe == 0L) {  //絶対値に1を加えたら加えたbitから上がすべて0になって溢れた
  7817:               xb = xc << -1;
  7818:               xc = xd << -1 | xc >>> 1;
  7819:               xd = MSB | xd >>> 1;
  7820:               xe++;
  7821:             }
  7822:           } else {  //64..LEN。xの下位またはguard bitと1が重なる
  7823:             if ((xc += MSB >>> xe) >>> ~xe == 0L && ++xd == 0L) {  //絶対値に1を加えたら加えたbitから上がすべて0になって溢れた
  7824:               xb = xc << -1;
  7825:               xc = xc >>> 1;
  7826:               xd = MSB;
  7827:               xe++;
  7828:             }
  7829:           }
  7830:         } else {  //+x
  7831:           //絶対値から1を引く
  7832:           if (xe <= 63) {  //1..63。xの上位の2bit目以降と1が重なる
  7833:             xd -= MSB >>> xe;  //最上位bitが1なのでボローはなく0にもならない
  7834:           } else {  //64..LEN。xの下位またはguard bitと1が重なる
  7835:             if (xc >>> ~xe != 0L) {  //下位の引く位置から上が0ではない。下位だけで引ける
  7836:               xc -= MSB >>> xe;
  7837:             } else {  //下位の引く位置から上が0なのでボローが発生する
  7838:               xc |= MSB >> xe;  //下位の引く位置から上は-1になる
  7839:               xd--;  //ボローを上位から引く
  7840:             }
  7841:           }
  7842:         }
  7843:       } else {  //-LEN..-1
  7844:         //絶対値は1の方が大きいのでxを右にシフトする
  7845:         if (-63 <= xe) {  //-63..-1。xの先頭が1の右隣から上位の最下位bitまで
  7846:           xb = xc << xe;
  7847:           xc = xd << xe | xc >>> -xe;
  7848:           xd >>>= -xe;
  7849:         } else if (-64 == xe) {  //-64。xの先頭が下位の最上位bit
  7850:           xb = xc;
  7851:           xc = xd;
  7852:           xd = 0L;
  7853:         } else {  //-LEN..-65。xの先頭が下位の上から2bit目からguard bitまで
  7854:           xb = xd << xe | xc >>> -xe;
  7855:           xc = xd >>> -xe;
  7856:           xd = 0L;
  7857:         }
  7858:         xe = 0;
  7859:         if (xf < 0) {  //-x
  7860:           //絶対値に1を加える
  7861:           xd |= MSB;
  7862:         } else {  //+x
  7863:           //絶対値を1から引く
  7864:           if (xb != 0L) {
  7865:             xb = -xb;
  7866:             xc = -1L - xc;
  7867:             xd = MSB - 1L - xd;
  7868:           } else if (xc != 0L) {
  7869:             xc = -xc;
  7870:             xd = MSB - 1L - xd;
  7871:           } else {
  7872:             xd = MSB - xd;
  7873:           }
  7874:           xf ^= M;  //符号反転
  7875:         }
  7876:       }
  7877:       //正規化する
  7878:       if (xd >= 0L) {
  7879:         if (xd != 0L) {
  7880:           int o = Long.numberOfLeadingZeros (xd);  //1..63。左にシフトするbit数
  7881:           xe -= o;
  7882:           xd = xd << o | xc >>> -o;
  7883:           xc = xc << o | xb >>> -o;
  7884:           xb <<= o;
  7885:         } else if (xc < 0L) {
  7886:           xe -= 64;
  7887:           xd = xc;
  7888:           xc = xb;
  7889:           xb = 0L;
  7890:         } else if (xc != 0L) {
  7891:           int o = 64 + Long.numberOfLeadingZeros (xc);  //65..127。左にシフトするbit数
  7892:           xe -= o;
  7893:           xd = xc << o | xb >>> -o;
  7894:           xc = xb << o;
  7895:           xb = 0L;
  7896:         } else if (xb < 0L) {
  7897:           xe -= 128;
  7898:           xd = xb;
  7899:           xc = 0L;
  7900:           xb = 0L;
  7901:         } else if (xb != 0L) {
  7902:           int o = 128 + Long.numberOfLeadingZeros (xb);  //129..191。左にシフトするbit数
  7903:           xe -= o;
  7904:           xd = xb << o;
  7905:           xc = 0L;
  7906:           xb = 0L;
  7907:         } else {
  7908:           this.flg = P | Z;  //-1+1=+0
  7909:           return this;
  7910:         }
  7911:       }
  7912:       return this.finish (xf, xe, xd, xc, xb);
  7913:     }  //efp.dec(EFP)
  7914: 
  7915:     //------------------------------------------------------------------------
  7916:     //x = x.deg ()
  7917:     //  x*=180/pi
  7918:     //y = y.deg (x)
  7919:     //  y=x*180/pi
  7920:     //  180/pi倍(デグリー)
  7921:     //
  7922:     //  グラフ
  7923:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{45/atan2(1,1)*$_[0]});print$g"
  7924:     //    echo read("../misc/efp.gp");eval("deg(x)=x*180/Pi");graph(deg) | gp -q
  7925:     //    +---------+---------+---------+---------+*--------+---------+---------+---------+
  7926:     //    |                                       |*                                      |
  7927:     //    |                                       |*                                      |
  7928:     //    |                                       |*                                      |
  7929:     //    |                                       |*                                      |
  7930:     //    +                                       +*                                      +
  7931:     //    |                                       **                                      |
  7932:     //    |                                       *                                       |
  7933:     //    |                                       *                                       |
  7934:     //    |                                       *                                       |
  7935:     //    +                                       *                                       +
  7936:     //    |                                       *                                       |
  7937:     //    |                                       *                                       |
  7938:     //    |                                       *                                       |
  7939:     //    |                                       *                                       |
  7940:     //    +                                       *                                       +
  7941:     //    |                                       *                                       |
  7942:     //    |                                       *                                       |
  7943:     //    |                                       *                                       |
  7944:     //    |                                       *                                       |
  7945:     //    +---------+---------+---------+---------*---------+---------+---------+---------+
  7946:     //    |                                       *                                       |
  7947:     //    |                                       *                                       |
  7948:     //    |                                       *                                       |
  7949:     //    |                                       *                                       |
  7950:     //    +                                       *                                       +
  7951:     //    |                                       *                                       |
  7952:     //    |                                       *                                       |
  7953:     //    |                                       *                                       |
  7954:     //    |                                       *                                       |
  7955:     //    +                                       *                                       +
  7956:     //    |                                       *                                       |
  7957:     //    |                                       *                                       |
  7958:     //    |                                       *                                       |
  7959:     //    |                                      **                                       |
  7960:     //    +                                      *+                                       +
  7961:     //    |                                      *|                                       |
  7962:     //    |                                      *|                                       |
  7963:     //    |                                      *|                                       |
  7964:     //    |                                      *|                                       |
  7965:     //    +---------+---------+---------+--------*+---------+---------+---------+---------+
  7966:     //
  7967:     //  定義域
  7968:     //    -inf<=x<=inf
  7969:     //
  7970:     //  値域
  7971:     //    -inf<=y<=inf
  7972:     //
  7973:     public final EFP deg () {
  7974:       return this.deg (this);
  7975:     }  //efp.deg()
  7976:     public final EFP deg (EFP x) {
  7977:       return this.mul (x, TO_DEG);  //x*180/pi
  7978:     }  //efp.deg(EFP)
  7979: 
  7980:     //------------------------------------------------------------------------
  7981:     //x = x.div (y)
  7982:     //  x/=y
  7983:     //z = z.div (x, y)
  7984:     //  z=x/y
  7985:     //  除算
  7986:     //
  7987:     //  (xn/xd)/(yn/yd)
  7988:     //    =(xn*yd)/(xd*yn)
  7989:     //
  7990:     public final EFP div (EFP y) {
  7991:       return this.div (this, y);
  7992:     }  //efp.div(EFP)
  7993:     public final EFP div (EFP x, EFP y) {
  7994:       int xf = x.flg;
  7995:       int yf = y.flg;
  7996:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
  7997:         if ((xf | yf) << 3 != 0) {  //どちらかがNaNのときNaN
  7998:           this.flg = N;
  7999:         } else if ((xf & yf & (Z | I)) != 0) {  //±0/±0または±Inf/±InfのときNaN
  8000:           epbFpsr |= EPB_FPSR_OE;
  8001:           if (yf << 1 < 0) {  //±0/±0
  8002:             epbExceptionOperandExponent = yf & M;
  8003:             epbExceptionOperandMantissa = 0x0000000000000000L;
  8004:           } else {  //±Inf/±Inf
  8005:             epbExceptionOperandExponent = yf & M | 0x7fff << 16;
  8006:             epbExceptionOperandMantissa = 0x0000000000000000L;
  8007:           }
  8008:           this.flg = N;
  8009:         } else if (xf << 1 == 0 && yf << 1 < 0) {  //(±0,NaN以外)/±0のとき±Inf
  8010:           epbFpsr |= EPB_FPSR_DZ;
  8011:           epbExceptionOperandExponent = yf & M;
  8012:           epbExceptionOperandMantissa = 0x0000000000000000L;
  8013:           this.flg = (xf ^ yf) & M | I;
  8014:         } else {  //±0/(±0,NaN以外)または(±Inf,NaN以外)/±Infのとき±0、±Inf/(±Inf,NaN以外)のとき±Inf
  8015:           this.flg = (xf ^ yf) & M | ((xf & Z | yf & I) != 0 ? Z : I);
  8016:         }
  8017:         return this;
  8018:       }
  8019:       //±0,±Inf,NaN以外
  8020:       long r01 = x.dvl;
  8021:       long y01 = y.dvl;
  8022:       long r2 = (r01 << -2 | x.cvl >>> 2) >>> 33;
  8023:       long y2 = (y01 << -2 | y.cvl >>> 2) >>> 33;
  8024:       r01 >>>= 2;
  8025:       y01 >>>= 2;
  8026:       long y0 = y01 >>> 31;
  8027:       long y1 = y01 & 0x7fffffffL;
  8028:       //先頭1bit
  8029:       boolean qq;
  8030:       if (r01 < y01 || (r01 == y01 && r2 < y2)) {  //x<y
  8031:         qq = false;
  8032:       } else {
  8033:         qq = true;
  8034:         r2 -= y2;
  8035:         r01 -= y01;
  8036:         if (r2 < 0L) {
  8037:           r2 += 0x80000000L;
  8038:           r01--;
  8039:         }
  8040:       }
  8041:       //1桁目
  8042:       long q0 = r01 >> 31 == y0 ? 0x7fffffffL : r01 / y0;
  8043:       r01 = (r01 - q0 * y0 << 31) + r2 - q0 * y1;
  8044:       if (r01 < 0L) {
  8045:         q0--;
  8046:         r01 += y01;
  8047:       }
  8048:       r2 = q0 * y2 + 0x7fffffffL;
  8049:       r01 -= r2 >> 31;
  8050:       r2 = ~r2 & 0x7fffffffL;  //~(r2 | ~0x7fffffffL)
  8051:       if (r01 < 0L) {
  8052:         q0--;
  8053:         r2 += y2;
  8054:         r01 += y01 + (r2 >> 31);
  8055:         r2 &= 0x7fffffffL;
  8056:       }
  8057:       //2桁目
  8058:       long q1 = r01 >> 31 == y0 ? 0x7fffffffL : r01 / y0;
  8059:       r01 = (r01 - q1 * y0 << 31) + r2 - q1 * y1;
  8060:       if (r01 < 0L) {
  8061:         q1--;
  8062:         r01 += y01;
  8063:       }
  8064:       r2 = q1 * y2 + 0x7fffffffL;
  8065:       r01 -= r2 >> 31;
  8066:       r2 = ~r2 & 0x7fffffffL;  //~(r2 | ~0x7fffffffL)
  8067:       if (r01 < 0L) {
  8068:         q1--;
  8069:         r2 += y2;
  8070:         r01 += y01 + (r2 >> 31);
  8071:         r2 &= 0x7fffffffL;
  8072:       }
  8073:       //3桁目
  8074:       long q2 = r01 >> 31 == y0 ? 0x7fffffffL : r01 / y0;
  8075:       r01 = (r01 - q2 * y0 << 31) + r2 - q2 * y1;
  8076:       if (r01 < 0L) {
  8077:         q2--;
  8078:         r01 += y01;
  8079:       }
  8080:       r2 = q2 * y2 + 0x7fffffffL;
  8081:       r01 -= r2 >> 31;
  8082:       r2 = ~r2 & 0x7fffffffL;  //~(r2 | ~0x7fffffffL)
  8083:       if (r01 < 0L) {
  8084:         q2--;
  8085:         r2 += y2;
  8086:         r01 += y01 + (r2 >> 31);
  8087:         r2 &= 0x7fffffffL;
  8088:       }
  8089:       //商  (((qq ? MSB : 0) | q0) << 31 | q1) << 31 | q2
  8090:       //余り  r01 << 31 | r2
  8091:       //正規化する
  8092:       int ze = x.epp - y.epp;
  8093:       if (qq) {  //商は94bit
  8094:         q0 = MSB | q0 << 32 | q1 << 1 | q2 >>> 30;
  8095:         q2 <<= -30;
  8096:       } else {  //商は93bit
  8097:         ze--;
  8098:         q0 = q0 << -31 | q1 << 2 | q2 >>> 29;
  8099:         q2 <<= -29;
  8100:       }
  8101:       return this.finish2 (xf ^ yf, ze, q0, q2, r01 | r2);
  8102:     }  //efp.div(EFP,EFP)
  8103: 
  8104:     //------------------------------------------------------------------------
  8105:     //x = x.div2 ()
  8106:     //  x/=2
  8107:     //y = y.div2 (x)
  8108:     //  y=x/2
  8109:     //  1/2倍
  8110:     //
  8111:     //  グラフ
  8112:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{$_[0]/2});print$g"
  8113:     //    echo read("../misc/efp.gp");eval("div2(x)=x/2");graph(div2) | gp -q
  8114:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  8115:     //    |                                       |                                       |
  8116:     //    |                                       |                                       |
  8117:     //    |                                       |                                       |
  8118:     //    |                                       |                                       |
  8119:     //    +                                       +                                       +
  8120:     //    |                                       |                                       |
  8121:     //    |                                       |                                       |
  8122:     //    |                                       |                                       |
  8123:     //    |                                       |                                       |
  8124:     //    +                                       +                                     ***
  8125:     //    |                                       |                                 ***** |
  8126:     //    |                                       |                             *****     |
  8127:     //    |                                       |                         *****         |
  8128:     //    |                                       |                     *****             |
  8129:     //    +                                       +                 *****                 +
  8130:     //    |                                       |             *****                     |
  8131:     //    |                                       |         *****                         |
  8132:     //    |                                       |     *****                             |
  8133:     //    |                                       | *****                                 |
  8134:     //    +---------+---------+---------+-------*****-------+---------+---------+---------+
  8135:     //    |                                 ***** |                                       |
  8136:     //    |                             *****     |                                       |
  8137:     //    |                         *****         |                                       |
  8138:     //    |                     *****             |                                       |
  8139:     //    +                 *****                 +                                       +
  8140:     //    |             *****                     |                                       |
  8141:     //    |         *****                         |                                       |
  8142:     //    |     *****                             |                                       |
  8143:     //    | *****                                 |                                       |
  8144:     //    ***                                     +                                       +
  8145:     //    |                                       |                                       |
  8146:     //    |                                       |                                       |
  8147:     //    |                                       |                                       |
  8148:     //    |                                       |                                       |
  8149:     //    +                                       +                                       +
  8150:     //    |                                       |                                       |
  8151:     //    |                                       |                                       |
  8152:     //    |                                       |                                       |
  8153:     //    |                                       |                                       |
  8154:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  8155:     //
  8156:     //  定義域
  8157:     //    -inf<=x<=inf
  8158:     //
  8159:     //  値域
  8160:     //    -inf<=y<=inf
  8161:     //
  8162:     public final EFP div2 () {
  8163:       return this.finish (this.flg, this.epp - 1, this.dvl, this.cvl, 0L);
  8164:     }  //efp.div2()
  8165:     public final EFP idiv2 () {
  8166:       this.epp--;
  8167:       return this;
  8168:     }  //efp.idiv2()
  8169:     public final EFP div2 (EFP x) {
  8170:       return this.finish (x.flg, x.epp - 1, x.dvl, x.cvl, 0L);
  8171:     }  //efp.div2(EFP)
  8172:     public final EFP idiv2 (EFP x) {
  8173:       this.flg = x.flg;
  8174:       this.epp = x.epp - 1;
  8175:       this.dvl = x.dvl;
  8176:       this.cvl = x.cvl;
  8177:       return this;
  8178:     }  //efp.idiv2(EFP)
  8179: 
  8180:     //------------------------------------------------------------------------
  8181:     //x = x.div3 ()
  8182:     //  x/=3
  8183:     //y = y.div3 (x)
  8184:     //  y=x/3
  8185:     //  1/3倍
  8186:     //
  8187:     //  グラフ
  8188:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{$_[0]/3});print$g"
  8189:     //    echo read("../misc/efp.gp");eval("div3(x)=x/3");graph(div3) | gp -q
  8190:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  8191:     //    |                                       |                                       |
  8192:     //    |                                       |                                       |
  8193:     //    |                                       |                                       |
  8194:     //    |                                       |                                       |
  8195:     //    +                                       +                                       +
  8196:     //    |                                       |                                       |
  8197:     //    |                                       |                                       |
  8198:     //    |                                       |                                       |
  8199:     //    |                                       |                                       |
  8200:     //    +                                       +                                       +
  8201:     //    |                                       |                                       |
  8202:     //    |                                       |                                       |
  8203:     //    |                                       |                                      **
  8204:     //    |                                       |                                *******|
  8205:     //    +                                       +                          *******      +
  8206:     //    |                                       |                    *******            |
  8207:     //    |                                       |              *******                  |
  8208:     //    |                                       |        *******                        |
  8209:     //    |                                       |  *******                              |
  8210:     //    +---------+---------+---------+------*******------+---------+---------+---------+
  8211:     //    |                              *******  |                                       |
  8212:     //    |                        *******        |                                       |
  8213:     //    |                  *******              |                                       |
  8214:     //    |            *******                    |                                       |
  8215:     //    +      *******                          +                                       +
  8216:     //    |*******                                |                                       |
  8217:     //    **                                      |                                       |
  8218:     //    |                                       |                                       |
  8219:     //    |                                       |                                       |
  8220:     //    +                                       +                                       +
  8221:     //    |                                       |                                       |
  8222:     //    |                                       |                                       |
  8223:     //    |                                       |                                       |
  8224:     //    |                                       |                                       |
  8225:     //    +                                       +                                       +
  8226:     //    |                                       |                                       |
  8227:     //    |                                       |                                       |
  8228:     //    |                                       |                                       |
  8229:     //    |                                       |                                       |
  8230:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  8231:     //
  8232:     //  定義域
  8233:     //    -inf<=x<=inf
  8234:     //
  8235:     //  値域
  8236:     //    -inf<=y<=inf
  8237:     //
  8238:     public final EFP div3 () {
  8239:       return this.div3 (this);
  8240:     }  //efp.div3()
  8241:     public final EFP div3 (EFP x) {
  8242:       //return this.divi (x, 3);  //x/3
  8243:       int xf = x.flg;
  8244:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  8245:         this.flg = xf;
  8246:         return this;
  8247:       }
  8248:       //±0,±Inf,NaN以外
  8249:       //2分割して割る
  8250:       int ze = x.epp;
  8251:       long zc = x.dvl;
  8252:       long zb = x.cvl;
  8253:       zb = (zc << -1 | zb >>> 1) >>> 3;  //被除数の下位61bit
  8254:       zc >>>= 1;  //被除数の上位63bit
  8255:       long zd = zc / 3L;  //商の上位61..62bit
  8256:       zb |= zc - zd * 3L << -3;  //上位の余りを下位に連結する
  8257:       zc = zb / 3L;  //商の下位61bit
  8258:       zb -= zc * 3L;  //余り
  8259:       zc <<= 3;
  8260:       //正規化する
  8261:       if (zd << 2 < 0L) {  //1bit減った
  8262:         ze--;
  8263:         zd = zd << 2 | zc >>> -2;
  8264:         zc <<= 2;
  8265:       } else {  //2bit減った
  8266:         ze -= 2;
  8267:         zd = zd << 3 | zc >>> -3;
  8268:         zc <<= 3;
  8269:       }
  8270:       return this.finish (xf, ze, zd, zc, zb);
  8271:     }  //efp.div3(EFP)
  8272: 
  8273:     //------------------------------------------------------------------------
  8274:     //x = x.divi (n)
  8275:     //  x/=n
  8276:     //z = z.divi (x, n)
  8277:     //  z=x/n
  8278:     //  int除算
  8279:     //
  8280:     public final EFP divi (int n) {
  8281:       return this.divi (this, n);
  8282:     }  //efp.divi(int)
  8283:     public final EFP divi (EFP x, int n) {
  8284:       //return this.div (x, new EFP (n));  //x/n
  8285:       int xf = x.flg;
  8286:       if (n == 0) {  //yが0
  8287:         if (xf << 1 != 0) {  //xが±0,±Inf,NaN
  8288:           if (xf << 1 < 0) {  //xが±0
  8289:             epbFpsr |= EPB_FPSR_OE;
  8290:             epbExceptionOperandExponent = P;
  8291:             epbExceptionOperandMantissa = 0x0000000000000000L;
  8292:             this.flg = N;  //±0/0=NaN
  8293:           } else {
  8294:             this.flg = xf;  //NaN/0=NaN, ±Inf/0=±Inf
  8295:           }
  8296:         } else {  //xが±0,±Inf,NaN以外
  8297:           epbFpsr |= EPB_FPSR_DZ;
  8298:           epbExceptionOperandExponent = P;
  8299:           epbExceptionOperandMantissa = 0x0000000000000000L;
  8300:           this.flg = (xf & M) | I;  //±x/0=±Inf
  8301:         }
  8302:         return this;
  8303:       }
  8304:       if (xf << 1 != 0) {  //xが±0,±Inf,NaN
  8305:         this.flg = xf << 3 < 0 ? N : xf ^ (n & M);  //NaN/±n=NaN, ±Inf/±n=±Inf, ±0/±n=±0
  8306:         return this;
  8307:       }
  8308:       //両方±0,±Inf,NaN以外
  8309:       int ze = x.epp;
  8310:       long zd = x.dvl;
  8311:       long zc = x.cvl;
  8312:       long zb = 0L;
  8313:       if (n < 0) {  //yが負
  8314:         xf ^= M;
  8315:         //0x80000000を取り除く
  8316:         if (n == 0x80000000) {
  8317:           ze -= 31;
  8318:           if ((short) ze != ze) {  //アンダーフロー
  8319:             epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
  8320:             epbExceptionOperandExponent = xf;
  8321:             epbExceptionOperandMantissa = zd;
  8322:             return this.sete (UNFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | xf >>> 31]).finish ();  //±0
  8323:           }
  8324:           this.flg = xf;
  8325:           this.epp = ze;
  8326:           this.dvl = zd;
  8327:           this.cvl = zc;
  8328:           return this;
  8329:         }
  8330:         n = -n;
  8331:       }
  8332:       if (n != 1) {  //0x80000000を取り除いていない場合はn>1は不可
  8333:         long y = (long) n;  //0x80000000を取り除いていない場合は&0xffffffffLが必要
  8334:         if (n >>> 16 == 0) {  //除数が2..16bit
  8335:           //2分割して割る
  8336:           zb = (zd << -1 | zc >>> 1) >>> 17;  //被除数の下位47bit
  8337:           zc = zd >>> 1;  //被除数の上位63bit
  8338:           zd = zc / y;  //商の上位47..62bit
  8339:           zb |= zc - zd * y << 47;  //上位の余り16bitと被除数の下位47bitを連結する
  8340:           zc = zb / y;  //商の下位47bit。上位の余り16bitは除数よりも小さいので47bit以内に収まる
  8341:           zb -= zc * y;  //余り16bit
  8342:           zc <<= 17;
  8343:         } else {  //除数が17..32bit
  8344:           //3分割して割る
  8345:           zb = (zd << -1 | zc >>> 1) >>> 33;  //被除数の中位31bit
  8346:           zc = zd >>> 1;  //被除数の上位63bit
  8347:           zd = zc / y;  //商の上位31..47bit
  8348:           zb |= zc - zd * y << 31;  //上位の余り32bitと被除数の中位31bitを連結する
  8349:           zc = zb / y;  //商の中位31bit。上位の余り32bitは除数よりも小さいので31bit以内に収まる
  8350:           zb = zb - zc * y << 31;  //中位の余り32bitと被除数の下位31bit(0)を連結する
  8351:           long t = zb / y;  //商の下位31bit
  8352:           zc = (zc << 31 | t) << 2;  //商の下位62bit
  8353:           zb -= t * y;  //余り
  8354:         }
  8355:         //正規化する
  8356:         int o = Long.numberOfLeadingZeros (zd);
  8357:         ze -= o - 1;
  8358:         zd = zd << o | zc >>> -o;
  8359:         zc <<= o;
  8360:       }  //n!=1
  8361:       return this.finish (xf, ze, zd, zc, zb);
  8362:     }  //efp.divi(EFP,int)
  8363: 
  8364:     //------------------------------------------------------------------------
  8365:     //x = x.divpi ()
  8366:     //  x/=pi
  8367:     //y = y.divpi (x)
  8368:     //  y=x/pi
  8369:     //  1/pi倍
  8370:     //
  8371:     //  グラフ
  8372:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{$_[0]/(4*atan2(1,1))});print$g"
  8373:     //    echo read("../misc/efp.gp");eval("divpi(x)=x/Pi");graph(divpi) | gp -q
  8374:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  8375:     //    |                                       |                                       |
  8376:     //    |                                       |                                       |
  8377:     //    |                                       |                                       |
  8378:     //    |                                       |                                       |
  8379:     //    +                                       +                                       +
  8380:     //    |                                       |                                       |
  8381:     //    |                                       |                                       |
  8382:     //    |                                       |                                       |
  8383:     //    |                                       |                                       |
  8384:     //    +                                       +                                       +
  8385:     //    |                                       |                                       |
  8386:     //    |                                       |                                       |
  8387:     //    |                                       |                                       |
  8388:     //    |                                       |                                  ******
  8389:     //    +                                       +                           ********    +
  8390:     //    |                                       |                     *******           |
  8391:     //    |                                       |               *******                 |
  8392:     //    |                                       |        ********                       |
  8393:     //    |                                       |  *******                              |
  8394:     //    +---------+---------+---------+------*******------+---------+---------+---------+
  8395:     //    |                              *******  |                                       |
  8396:     //    |                       ********        |                                       |
  8397:     //    |                 *******               |                                       |
  8398:     //    |           *******                     |                                       |
  8399:     //    +    ********                           +                                       +
  8400:     //    ******                                  |                                       |
  8401:     //    |                                       |                                       |
  8402:     //    |                                       |                                       |
  8403:     //    |                                       |                                       |
  8404:     //    +                                       +                                       +
  8405:     //    |                                       |                                       |
  8406:     //    |                                       |                                       |
  8407:     //    |                                       |                                       |
  8408:     //    |                                       |                                       |
  8409:     //    +                                       +                                       +
  8410:     //    |                                       |                                       |
  8411:     //    |                                       |                                       |
  8412:     //    |                                       |                                       |
  8413:     //    |                                       |                                       |
  8414:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  8415:     //
  8416:     //  定義域
  8417:     //    -inf<=x<=inf
  8418:     //
  8419:     //  値域
  8420:     //    -inf<=y<=inf
  8421:     //
  8422:     public final EFP divpi () {
  8423:       return this.mul (this, ONE_PI);  //x*1/pi
  8424:     }  //efp.divpi()
  8425:     public final EFP divpi (EFP x) {
  8426:       return this.mul (x, ONE_PI);  //x*1/pi
  8427:     }  //efp.divpi(EFP)
  8428: 
  8429:     //------------------------------------------------------------------------
  8430:     //x = x.divrz (y)
  8431:     //  x/=y
  8432:     //z = z.divrz (x, y)
  8433:     //  z=x/y
  8434:     //  除算(RZ)
  8435:     //
  8436:     public final EFP divrz (EFP y) {
  8437:       return this.divrz (this, y);
  8438:     }  //efp.divrz(EFP)
  8439:     public final EFP divrz (EFP x, EFP y) {
  8440:       int xf = x.flg;
  8441:       int yf = y.flg;
  8442:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
  8443:         if ((xf | yf) << 3 != 0) {  //どちらかがNaNのときNaN
  8444:           this.flg = N;
  8445:         } else if ((xf & yf & (Z | I)) != 0) {  //±0/±0または±Inf/±InfのときNaN
  8446:           epbFpsr |= EPB_FPSR_OE;
  8447:           if (yf << 1 < 0) {  //±0/±0
  8448:             epbExceptionOperandExponent = yf & M;
  8449:             epbExceptionOperandMantissa = 0x0000000000000000L;
  8450:           } else {  //±Inf/±Inf
  8451:             epbExceptionOperandExponent = yf & M | 0x7fff << 16;
  8452:             epbExceptionOperandMantissa = 0x0000000000000000L;
  8453:           }
  8454:           this.flg = N;
  8455:         } else if (xf << 1 == 0 && yf << 1 < 0) {  //(±0,NaN以外)/±0のとき±Inf
  8456:           epbFpsr |= EPB_FPSR_DZ;
  8457:           epbExceptionOperandExponent = yf & M;
  8458:           epbExceptionOperandMantissa = 0x0000000000000000L;
  8459:           this.flg = (xf ^ yf) & M | I;
  8460:         } else {  //±0/(±0,NaN以外)または(±Inf,NaN以外)/±Infのとき±0、±Inf/(±Inf,NaN以外)のとき±Inf
  8461:           this.flg = (xf ^ yf) & M | ((xf & Z | yf & I) != 0 ? Z : I);
  8462:         }
  8463:         return this;
  8464:       }
  8465:       //±0,±Inf,NaN以外
  8466:       long r01 = x.dvl;
  8467:       long y01 = y.dvl;
  8468:       long r2 = (r01 << -2 | x.cvl >>> 2) >>> 33;
  8469:       long y2 = (y01 << -2 | y.cvl >>> 2) >>> 33;
  8470:       r01 >>>= 2;
  8471:       y01 >>>= 2;
  8472:       long y0 = y01 >>> 31;
  8473:       long y1 = y01 & 0x7fffffffL;
  8474:       //先頭1bit
  8475:       boolean qq;
  8476:       if (r01 < y01 || (r01 == y01 && r2 < y2)) {  //x<y
  8477:         qq = false;
  8478:       } else {
  8479:         qq = true;
  8480:         r2 -= y2;
  8481:         r01 -= y01;
  8482:         if (r2 < 0L) {
  8483:           r2 += 0x80000000L;
  8484:           r01--;
  8485:         }
  8486:       }
  8487:       //1桁目
  8488:       long q0 = r01 >> 31 == y0 ? 0x7fffffffL : r01 / y0;
  8489:       r01 = (r01 - q0 * y0 << 31) + r2 - q0 * y1;
  8490:       if (r01 < 0L) {
  8491:         q0--;
  8492:         r01 += y01;
  8493:       }
  8494:       r2 = q0 * y2 + 0x7fffffffL;
  8495:       r01 -= r2 >> 31;
  8496:       r2 = ~r2 & 0x7fffffffL;  //~(r2 | ~0x7fffffffL)
  8497:       if (r01 < 0L) {
  8498:         q0--;
  8499:         r2 += y2;
  8500:         r01 += y01 + (r2 >> 31);
  8501:         r2 &= 0x7fffffffL;
  8502:       }
  8503:       //2桁目
  8504:       long q1 = r01 >> 31 == y0 ? 0x7fffffffL : r01 / y0;
  8505:       r01 = (r01 - q1 * y0 << 31) + r2 - q1 * y1;
  8506:       if (r01 < 0L) {
  8507:         q1--;
  8508:         r01 += y01;
  8509:       }
  8510:       r2 = q1 * y2 + 0x7fffffffL;
  8511:       r01 -= r2 >> 31;
  8512:       r2 = ~r2 & 0x7fffffffL;  //~(r2 | ~0x7fffffffL)
  8513:       if (r01 < 0L) {
  8514:         q1--;
  8515:         r2 += y2;
  8516:         r01 += y01 + (r2 >> 31);
  8517:         r2 &= 0x7fffffffL;
  8518:       }
  8519:       //3桁目
  8520:       long q2 = r01 >> 31 == y0 ? 0x7fffffffL : r01 / y0;
  8521:       r01 = (r01 - q2 * y0 << 31) + r2 - q2 * y1;
  8522:       if (r01 < 0L) {
  8523:         q2--;
  8524:         r01 += y01;
  8525:       }
  8526:       r2 = q2 * y2 + 0x7fffffffL;
  8527:       r01 -= r2 >> 31;
  8528:       r2 = ~r2 & 0x7fffffffL;  //~(r2 | ~0x7fffffffL)
  8529:       if (r01 < 0L) {
  8530:         q2--;
  8531:         r2 += y2;
  8532:         r01 += y01 + (r2 >> 31);
  8533:         r2 &= 0x7fffffffL;
  8534:       }
  8535:       //商  (((qq ? MSB : 0) | q0) << 31 | q1) << 31 | q2
  8536:       //余り  r01 << 31 | r2
  8537:       //正規化する
  8538:       int ze = x.epp - y.epp;
  8539:       if (qq) {  //商は94bit
  8540:         q0 = MSB | q0 << 32 | q1 << 1 | q2 >>> 30;
  8541:         q2 <<= -30;
  8542:       } else {  //商は93bit
  8543:         ze--;
  8544:         q0 = q0 << -31 | q1 << 2 | q2 >>> 29;
  8545:         q2 <<= -29;
  8546:       }
  8547:       return this.finish (xf ^ yf, ze, q0, q2, r01 | r2);
  8548:     }  //efp.divrz(EFP,EFP)
  8549: 
  8550:     //------------------------------------------------------------------------
  8551:     //b = x.eq (y)
  8552:     //  b=x==y
  8553:     //  等しいか
  8554:     //
  8555:     //  -Inf==-Inf<-x<-0==+0<+x<+Inf==+Inf
  8556:     //
  8557:     //  NaNの扱い
  8558:     //    どちらかがNaNのときはfalseを返す
  8559:     //
  8560:     public boolean eq (EFP y) {
  8561:       int xf = this.flg;
  8562:       int yf = y.flg;
  8563:       return ((xf | yf) << 1 != 0 ?  //どちらかが±0,±Inf,NaN
  8564:               EFP_EQ_TABLE[xf >>> 28] << (yf >>> 28 - 1) < 0
  8565:               : //両方±0,±Inf,NaN以外
  8566:               xf == yf && this.epp == y.epp && this.dvl == y.dvl && this.cvl == y.cvl);
  8567:     }  //efp.eq(EFP)
  8568: 
  8569:     //------------------------------------------------------------------------
  8570:     //b = x.equals (y)
  8571:     //  b=x==y
  8572:     //  一致
  8573:     //
  8574:     //  equalsであるオブジェクトはクラスと内容の両方が一致していなければならない
  8575:     //  equalsであるオブジェクトはhashCodeが同じでなければならない
  8576:     //  equalsでないオブジェクトはhashCodeがなるべく違う方がよい
  8577:     //  equalsであるオブジェクトはcompareToが0であることが強く推奨される
  8578:     //  equalsでないオブジェクトはcompareToが0でないことが強く推奨される
  8579:     //
  8580:     @Override public boolean equals (Object yo) {
  8581:       if (yo instanceof EFP) {
  8582:         EFP x = this;
  8583:         EFP y = (EFP) yo;
  8584:         return (x.flg == y.flg &&
  8585:                 x.epp == y.epp &&
  8586:                 x.dvl == y.dvl &&
  8587:                 x.cvl == y.cvl);
  8588:       }
  8589:       return false;
  8590:     }  //efp.equals(Object)
  8591: 
  8592:     //------------------------------------------------------------------------
  8593:     //x = x.exp ()
  8594:     //  x=e^x
  8595:     //y = y.exp (x)
  8596:     //  y=e^x
  8597:     //  指数関数 exponential
  8598:     //
  8599:     //  グラフ
  8600:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{exp($_[0])});print$g"
  8601:     //    echo read("../misc/efp.gp");graph(exp) | gp -q
  8602:     //    +---------+---------+---------+---------+---------+---*-----+---------+---------+
  8603:     //    |                                       |            **                         |
  8604:     //    |                                       |            *                          |
  8605:     //    |                                       |           **                          |
  8606:     //    |                                       |          **                           |
  8607:     //    +                                       +          *                            +
  8608:     //    |                                       |         **                            |
  8609:     //    |                                       |        **                             |
  8610:     //    |                                       |       **                              |
  8611:     //    |                                       |      **                               |
  8612:     //    +                                       +     **                                +
  8613:     //    |                                       |    **                                 |
  8614:     //    |                                       |   **                                  |
  8615:     //    |                                       |  **                                   |
  8616:     //    |                                       |***                                    |
  8617:     //    +                                      ***                                      +
  8618:     //    |                                   ****|                                       |
  8619:     //    |                                ****   |                                       |
  8620:     //    |                           ******      |                                       |
  8621:     //    |                ************           |                                       |
  8622:     //    ******************--+---------+---------+---------+---------+---------+---------+
  8623:     //    |                                       |                                       |
  8624:     //    |                                       |                                       |
  8625:     //    |                                       |                                       |
  8626:     //    |                                       |                                       |
  8627:     //    +                                       +                                       +
  8628:     //    |                                       |                                       |
  8629:     //    |                                       |                                       |
  8630:     //    |                                       |                                       |
  8631:     //    |                                       |                                       |
  8632:     //    +                                       +                                       +
  8633:     //    |                                       |                                       |
  8634:     //    |                                       |                                       |
  8635:     //    |                                       |                                       |
  8636:     //    |                                       |                                       |
  8637:     //    +                                       +                                       +
  8638:     //    |                                       |                                       |
  8639:     //    |                                       |                                       |
  8640:     //    |                                       |                                       |
  8641:     //    |                                       |                                       |
  8642:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  8643:     //
  8644:     //  定義域
  8645:     //    -inf<=x<=inf
  8646:     //
  8647:     //  値域
  8648:     //    0<y<=inf
  8649:     //
  8650:     //  テイラー展開
  8651:     //    e^x=1+1/1!*x+1/2!*x^2+1/3!*x^3+1/4!*x^4+1/5!*x^5+1/6!*x^6+...
  8652:     //    f(n,x)=sum(k=0,n,1/k!*x^k)
  8653:     //
  8654:     //  対数関数との関係
  8655:     //    e^log(x)=x
  8656:     //    log(e^x)=x
  8657:     //
  8658:     //  双曲線関数との関係
  8659:     //    e^x=cosh(x)+sinh(x)
  8660:     //    e^-x=cosh(x)-sinh(x)
  8661:     //    cosh(x)=(e^x+e^-x)/2
  8662:     //    sinh(x)=(e^x-e^-x)/2
  8663:     //
  8664:     public final EFP exp () {
  8665:       return this.exp (this);
  8666:     }  //efp.exp()
  8667:     public final EFP exp (EFP x) {
  8668:       int xf = x.flg;
  8669:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  8670:         if (xf << 1 < 0) {  //e^±0=1
  8671:           //this.set1 ();
  8672:           this.flg = P;
  8673:           this.epp = 0;
  8674:           this.dvl = MSB;
  8675:           this.cvl = 0L;
  8676:         } else {
  8677:           this.flg = (xf == (P | I) ? P | I :  //e^+Inf=+Inf。オーバーフローはセットされない
  8678:                       xf == (M | I) ? P | Z :  //e^-Inf=+0。アンダーフローはセットされない
  8679:                       N);  //e^NaN=NaN
  8680:         }
  8681:         return this;
  8682:       }
  8683:       //±0,±Inf,NaN以外
  8684:       epbFpsr |= EPB_FPSR_X2;  //不正確な結果。オーバーフローまたはアンダーフローのときもセットされる
  8685:       epbExceptionOperandExponent = xf | 0x3fff + x.epp << 16;
  8686:       epbExceptionOperandMantissa = x.dvl;
  8687:       if (15 <= x.epp) {  //x<=-32768||32768<=x
  8688:         if (xf < 0) {  //x<=-32768。exp(-big)=+0
  8689:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
  8690:           return this.sete (UNFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1]).finish ();  //+0
  8691:         } else {  //32768<=x。exp(+big)=+Inf
  8692:           epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
  8693:           return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1]).finish ();  //+Inf
  8694:         }
  8695:       }
  8696:       if (false) {  //テイラー展開 [71]
  8697:         this.inner ();
  8698:         EFP s = new EFP (1);  //x^k/k!
  8699:         EFP t = new EFP (0);
  8700:         EFP u = new EFP (x);  //thisが破壊されるのでxをコピーしておく
  8701:         //this.sete (s);
  8702:         this.flg = s.flg;
  8703:         this.epp = s.epp;
  8704:         this.dvl = s.dvl;
  8705:         this.cvl = s.cvl;
  8706:         for (int k = 1; this.ne (t); k++) {
  8707:           s.imul (u).divi (k);  //x^k/k!
  8708:           //t.sete (this);
  8709:           t.flg = this.flg;
  8710:           t.epp = this.epp;
  8711:           t.dvl = this.dvl;
  8712:           t.cvl = this.cvl;
  8713:           this.iadd (s);
  8714:         }
  8715:         return this.outer ().finish ();
  8716:       } else if (false) {  //powを使う。powがexpを使っている場合は不可
  8717:         return this.pow (E, x);  //e^x [89]
  8718:       } else if (true) {  //exp2を使う。exp2がexpを使っている場合は不可 [85] 228ns
  8719:         this.inner ();
  8720:         if (this == x) {
  8721:           x = new EFP (x);
  8722:         }
  8723:         if (x.epp < -32) {  //|x|<2^-32
  8724:           this.imul (x, ONE_3).inc ().imul (x).idiv2 ().inc ().imul (x).outer ().inc ();  //e^x=1+x*(1+x/2*(1+x/3))
  8725:           if (epbRoundingMode == EPB_MODE_RZ || epbRoundingMode == EPB_MODE_RM) {
  8726:             if (xf < 0) {
  8727:               //x<0のときe^x<1なのでRZ,RMで1<=yとなってはならない
  8728:               if (this.flg << 1 == 0 && 0 <= this.epp) {
  8729:                 this.set1 ().nextdown (epbRoundingPrec);
  8730:               }
  8731:             }
  8732:           } else if (epbRoundingMode == EPB_MODE_RP) {
  8733:             //x!=0のとき1+x<e^xなのでRPでy<=1+xとなってはならない
  8734:             if (new EFP (this.flg, this.epp, this.dvl, this.cvl).dec ().le (x)) {  //y-1<=x
  8735:               this.inner ().inc(x).outer ().nextup (epbRoundingPrec);  //y=nextup(1+x)
  8736:             }
  8737:           }
  8738:         } else {
  8739:           this.imul (LOG2_E, x).outer ().exp2 ();  //e^x=2^(log2(e)*x)
  8740:         }
  8741:         return this;
  8742:       } else if (false) {  //小数部分だけexp2を使う。[90] 257ns
  8743:         int xe = x.epp;
  8744:         if (xe < 0) {  //|x|<1
  8745:           return this.inner ().imul (LOG2_E, x).outer ().exp2 ();
  8746:         }
  8747:         //1<=|x|
  8748:         this.inner ();
  8749:         int o = (int) (x.dvl >>> ~xe);  //整数部分
  8750:         this.frac (x).imul (LOG2_E).exp2 ();
  8751:         EFP[] a = xf >= 0 ? EXP_P_I : EXP_M_I;
  8752:         for (int i = 0; o != 0; i++) {
  8753:           if ((o & 1) != 0) {
  8754:             this.imul (a[i]);
  8755:           }
  8756:           o >>>= 1;
  8757:         }
  8758:         return this.outer ().finish ();
  8759:       } else {  //64分割。[90] 270ns
  8760:         int xe = x.epp;
  8761:         this.inner ();
  8762:         long xd = x.dvl;  //整数部分は高々16bit
  8763:         long xc = x.cvl;
  8764:         EFP u;
  8765:         if (false) {
  8766:           u = new EFP ().shl (x, 6).frac ().shr (6);  //xの小数点以下7桁目以降
  8767:         } else {
  8768:           int uf = xf;
  8769:           int ue;
  8770:           long ud;
  8771:           long uc;
  8772:           int o = xe + 7;
  8773:           if (o <= 0) {
  8774:             ue = xe;
  8775:             ud = xd;
  8776:             uc = xc;
  8777:           } else if (o <= 63) {
  8778:             ue = -7;
  8779:             ud = xd << o | xc >>> -o;
  8780:             uc = xc << o;
  8781:           } else if (o <= LEN - 1) {
  8782:             ue = -7;
  8783:             ud = xc << o;
  8784:             uc = 0L;
  8785:           } else {
  8786:             ue = 0;
  8787:             ud = 0L;
  8788:             uc = 0L;
  8789:           }
  8790:           if (ud >= 0L) {
  8791:             if (ud != 0L) {
  8792:               o = Long.numberOfLeadingZeros (ud);
  8793:               ue -= o;
  8794:               ud = ud << o | uc >>> -o;
  8795:               uc <<= o;
  8796:             } else if (uc != 0L) {
  8797:               o = 64 + Long.numberOfLeadingZeros (uc);
  8798:               ue -= o;
  8799:               ud = uc << o;
  8800:               uc = 0L;
  8801:             } else {
  8802:               uf |= Z;
  8803:             }
  8804:           }
  8805:           u = new EFP (uf, ue, ud, uc);  //xの小数点以下7桁目以降
  8806:         }
  8807:         this.imul (EXP_C10, u)
  8808:           .iadd (EXP_C9).imul (u)
  8809:             .iadd (EXP_C8).imul (u)
  8810:               .iadd (EXP_C7).imul (u)
  8811:                 .iadd (EXP_C6).imul (u)
  8812:                   .iadd (EXP_C5).imul (u)
  8813:                     .iadd (EXP_C4).imul (u)
  8814:                       .iadd (EXP_C3).imul (u)
  8815:                         .iadd (EXP_C2).imul (u)
  8816:                           .iadd (EXP_C1).imul (u)
  8817:                             //.iadd (EXP_C0);
  8818:                             .inc ();
  8819:         if (xf >= 0) {
  8820:           if (xe >= 0) {
  8821:             this.imul (EXP_P_T[(int) (xd << xe + 1 >>> -6)]);
  8822:             int o = (int) (xd >>> ~xe);  //整数部分
  8823:             for (int i = 0; o != 0; i++) {
  8824:               if ((o & 1) != 0) {
  8825:                 this.imul (EXP_P_I[i]);
  8826:               }
  8827:               o >>>= 1;
  8828:             }
  8829:           } else if (xe >= -6) {
  8830:             this.imul (EXP_P_T[(int) (xd >>> ~xe - 6)]);
  8831:           }
  8832:         } else {
  8833:           if (xe >= 0) {
  8834:             this.imul (EXP_M_T[(int) (xd << xe + 1 >>> -6)]);
  8835:             int o = (int) (xd >>> ~xe);  //整数部分
  8836:             for (int i = 0; o != 0; i++) {
  8837:               if ((o & 1) != 0) {
  8838:                 this.imul (EXP_M_I[i]);
  8839:               }
  8840:               o >>>= 1;
  8841:             }
  8842:           } else if (xe >= -6) {
  8843:             this.imul (EXP_M_T[(int) (xd >>> ~xe - 6)]);
  8844:           }
  8845:         }
  8846:         return this.outer ().finish ();
  8847:       }
  8848:     }  //efp.exp(EFP)
  8849: 
  8850:     //------------------------------------------------------------------------
  8851:     //x = x.exp10 ()
  8852:     //  x=10^x
  8853:     //y = y.exp10 (x)
  8854:     //  y=10^x
  8855:     //  底が10の指数関数 exponential with base 10
  8856:     //
  8857:     //  グラフ
  8858:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{10**$_[0]});print$g"
  8859:     //    echo read("../misc/efp.gp");eval("exp10(x)=10^x");graph(exp10) | gp -q
  8860:     //    +---------+---------+---------+---------+-----*---+---------+---------+---------+
  8861:     //    |                                       |     *                                 |
  8862:     //    |                                       |    **                                 |
  8863:     //    |                                       |    *                                  |
  8864:     //    |                                       |    *                                  |
  8865:     //    +                                       +    *                                  +
  8866:     //    |                                       |   **                                  |
  8867:     //    |                                       |   *                                   |
  8868:     //    |                                       |   *                                   |
  8869:     //    |                                       |  **                                   |
  8870:     //    +                                       +  *                                    +
  8871:     //    |                                       | **                                    |
  8872:     //    |                                       | *                                     |
  8873:     //    |                                       |**                                     |
  8874:     //    |                                       **                                      |
  8875:     //    +                                       *                                       +
  8876:     //    |                                     ***                                       |
  8877:     //    |                                    ** |                                       |
  8878:     //    |                                  ***  |                                       |
  8879:     //    |                             ******    |                                       |
  8880:     //    *******************************---------+---------+---------+---------+---------+
  8881:     //    |                                       |                                       |
  8882:     //    |                                       |                                       |
  8883:     //    |                                       |                                       |
  8884:     //    |                                       |                                       |
  8885:     //    +                                       +                                       +
  8886:     //    |                                       |                                       |
  8887:     //    |                                       |                                       |
  8888:     //    |                                       |                                       |
  8889:     //    |                                       |                                       |
  8890:     //    +                                       +                                       +
  8891:     //    |                                       |                                       |
  8892:     //    |                                       |                                       |
  8893:     //    |                                       |                                       |
  8894:     //    |                                       |                                       |
  8895:     //    +                                       +                                       +
  8896:     //    |                                       |                                       |
  8897:     //    |                                       |                                       |
  8898:     //    |                                       |                                       |
  8899:     //    |                                       |                                       |
  8900:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  8901:     //
  8902:     //  定義域
  8903:     //    -inf<=x<=inf
  8904:     //
  8905:     //  値域
  8906:     //    0<y<=inf
  8907:     //
  8908:     //  指数関数との関係
  8909:     //    10^x=(e^log(10))^x
  8910:     //        =e^(log(10)*x)
  8911:     //
  8912:     //  チェビシェフ展開1
  8913:     //    10^x=10^(trunc(x)+frac(x))
  8914:     //        =10^trunc(x)*10^frac(x)
  8915:     //    xの整数部分は10^(±2^k),0<=k<=13のテーブルを参照して後から掛ける
  8916:     //    以下は-1<x<1とする
  8917:     //    echo read("../misc/efp.gp");eval("f(x)=10^x");a=-1;b=1;for(n=0,31,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
  8918:     //       0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28  29  30  31
  8919:     //      -5  -4  -3  -1   1   3   6   9  12  15  18  22  25  29  32  36  40  44  48  52  56  61  65  69  74  78  83  87  92  97 102 106
  8920:     //
  8921:     //  チェビシェフ展開2
  8922:     //    偶関数と奇関数に分けてそれぞれ展開する
  8923:     //    10^x=(10^x+10^-x)/2+(10^x-10^-x)/2
  8924:     //    echo read("../misc/efp.gp");eval("f(x)=(10^x+10^-x)/2");a=-1;b=1;forstep(n=0,30,2,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
  8925:     //       0   2   4   6   8  10  12  14  16  18  20  22  24  26  28  30
  8926:     //      -1   2   7  12  18  25  32  39  47  55  64  73  82  91 100 110
  8927:     //    echo read("../misc/efp.gp");eval("f(x)=(10^x-10^-x)/2");a=-1;b=1;forstep(n=1,31,2,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
  8928:     //       1   3   5   7   9  11  13  15  17  19  21  23  25  27  29  31
  8929:     //       0   3   8  13  19  26  33  40  48  56  65  74  83  92 101 111
  8930:     //    評価が高くなったように見えるが係数は同じなので偶関数と奇関数に分ける意味はない
  8931:     //
  8932:     public final EFP exp10 () {
  8933:       return this.exp10 (this);
  8934:     }  //efp.exp10()
  8935:     public final EFP exp10 (EFP x) {
  8936:       int xf = x.flg;
  8937:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  8938:         if (xf << 1 < 0) {  //10^±0=1
  8939:           //this.set1 ();
  8940:           this.flg = P;
  8941:           this.epp = 0;
  8942:           this.dvl = MSB;
  8943:           this.cvl = 0L;
  8944:         } else {
  8945:           this.flg = (xf == (P | I) ? P | I :  //10^+Inf=+Inf。オーバーフローはセットされない
  8946:                       xf == (M | I) ? P | Z :  //10^-Inf=+0。アンダーフローはセットされない
  8947:                       N);  //10^NaN=NaN
  8948:         }
  8949:         return this;
  8950:       }
  8951:       //±0,±Inf,NaN以外
  8952:       epbFpsr |= EPB_FPSR_X2;  //不正確な結果。オーバーフローまたはアンダーフローのときもセットされる
  8953:       epbExceptionOperandExponent = xf | 0x3fff + x.epp << 16;
  8954:       epbExceptionOperandMantissa = x.dvl;
  8955:       if (15 <= x.epp) {  //x<=-32768||32768<=x
  8956:         if (xf < 0) {  //x<=-32768。exp10(-big)=+0
  8957:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
  8958:           return this.sete (UNFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1]).finish ();  //+0
  8959:         } else {  //32768<=x。exp10(+big)=+Inf
  8960:           epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
  8961:           return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1]).finish ();  //+Inf
  8962:         }
  8963:       }
  8964:       if (false) {  //powを使う。powがexp10を使っている場合は不可
  8965:         return this.pow (TEN, x);  //10^x
  8966:       } else if (false) {  //expを使う。expがexp10を使っている場合は不可
  8967:         return this.inner ().imul (LOG_10, x).outer ().exp ();  //10^x=e^(log(10)*x)
  8968:       } else if (true) {  //exp2を使う
  8969:         //  10^x=(2^log2(10))^x
  8970:         //      =2^(log2(10)*x)
  8971:         return this.inner ().imul (LOG2_10, x).outer ().exp2 ();
  8972:       } else if (false) {  //exp2とexp2m1と高精度のlog2(10)を使う
  8973:         //  10^x=(2^log2(10))^x
  8974:         //      =2^(log2(10)*x)
  8975:         //      =2^((log2(10)-ε+ε)*x)
  8976:         //      =2^((log2(10)-ε)*x+ε*x)
  8977:         //      =2^((log2(10)-ε)*x)*(1+2^(ε*x)-1)
  8978:         //      =2^((log2(10)-ε)*x)+2^((log2(10)-ε)*x)*(2^(ε*x)-1)
  8979:         this.inner ();
  8980:         EFP t = new EFP ().imul (LOG2_10A, x).exp2m1 ();
  8981:         this.imul (LOG2_10, x).exp2 ();
  8982:         t.imul (this);
  8983:         return this.outer ().add (t);
  8984:       } else if (false) {  //小数部分だけexp2を使う。[90] 258ns
  8985:         int xe = x.epp;
  8986:         this.inner ();
  8987:         if (xe < 0) {  //|x|<1
  8988:           this.imul (LOG2_10, x).exp2 ();
  8989:         } else {
  8990:           int o = (int) (x.dvl >>> ~xe);  //整数部分
  8991:           this.frac (x).imul (LOG2_10).exp2 ();
  8992:           EFP[] a = xf >= 0 ? EXP10_P_I : EXP10_M_I;
  8993:           for (int i = 0; o != 0; i++) {
  8994:             if ((o & 1) != 0) {
  8995:               this.imul (a[i]);
  8996:             }
  8997:             o >>>= 1;
  8998:           }
  8999:         }
  9000:         return this.outer ().finish ();
  9001:       } else {  //64分割。[90] 315ns
  9002:         int xe = x.epp;
  9003:         this.inner ();
  9004:         long xd = x.dvl;  //整数部分は高々16bit
  9005:         long xc = x.cvl;
  9006:         EFP u;
  9007:         if (false) {
  9008:           u = new EFP ().shl (x, 6).frac ().shr (6);  //xの小数点以下7桁目以降
  9009:         } else {
  9010:           int uf = xf;
  9011:           int ue;
  9012:           long ud;
  9013:           long uc;
  9014:           int o = xe + 7;
  9015:           if (o <= 0) {
  9016:             ue = xe;
  9017:             ud = xd;
  9018:             uc = xc;
  9019:           } else if (o <= 63) {
  9020:             ue = -7;
  9021:             ud = xd << o | xc >>> -o;
  9022:             uc = xc << o;
  9023:           } else if (o <= LEN - 1) {
  9024:             ue = -7;
  9025:             ud = xc << o;
  9026:             uc = 0L;
  9027:           } else {
  9028:             ue = 0;
  9029:             ud = 0L;
  9030:             uc = 0L;
  9031:           }
  9032:           if (ud >= 0L) {
  9033:             if (ud != 0L) {
  9034:               o = Long.numberOfLeadingZeros (ud);
  9035:               ue -= o;
  9036:               ud = ud << o | uc >>> -o;
  9037:               uc <<= o;
  9038:             } else if (uc != 0L) {
  9039:               o = 64 + Long.numberOfLeadingZeros (uc);
  9040:               ue -= o;
  9041:               ud = uc << o;
  9042:               uc = 0L;
  9043:             } else {
  9044:               uf |= Z;
  9045:             }
  9046:           }
  9047:           u = new EFP (uf, ue, ud, uc);  //xの小数点以下7桁目以降
  9048:         }
  9049:         this.imul (EXP10_C11, u)
  9050:           .iadd (EXP10_C10).imul (u)
  9051:             .iadd (EXP10_C9).imul (u)
  9052:               .iadd (EXP10_C8).imul (u)
  9053:                 .iadd (EXP10_C7).imul (u)
  9054:                   .iadd (EXP10_C6).imul (u)
  9055:                     .iadd (EXP10_C5).imul (u)
  9056:                       .iadd (EXP10_C4).imul (u)
  9057:                         .iadd (EXP10_C3).imul (u)
  9058:                           .iadd (EXP10_C2).imul (u)
  9059:                             .iadd (EXP10_C1).imul (u)
  9060:                               //.iadd (EXP10_C0);
  9061:                               .inc ();
  9062:         if (xf >= 0) {
  9063:           if (xe >= 0) {
  9064:             this.imul (EXP10_P_T[(int) (xd << xe + 1 >>> -6)]);
  9065:             int o = (int) (xd >>> ~xe);  //整数部分
  9066:             for (int i = 0; o != 0; i++) {
  9067:               if ((o & 1) != 0) {
  9068:                 this.imul (EXP10_P_I[i]);
  9069:               }
  9070:               o >>>= 1;
  9071:             }
  9072:           } else if (xe >= -6) {
  9073:             this.imul (EXP10_P_T[(int) (xd >>> ~xe - 6)]);
  9074:           }
  9075:           this.outer ().finish ();
  9076:           if (epbRoundingMode == EPB_MODE_RP) {
  9077:             //0<xのとき1<10^xなのでRPでy<=1となってはならない
  9078:             if (this.flg << 1 == 0 && (this.epp < 0 ||
  9079:                                        this.epp == 0 && this.dvl == MSB && this.cvl == 0L)) {
  9080:               this.set1 ().nextup (epbRoundingPrec);
  9081:             }
  9082:           }
  9083:         } else {
  9084:           if (xe >= 0) {
  9085:             this.imul (EXP10_M_T[(int) (xd << xe + 1 >>> -6)]);
  9086:             int o = (int) (xd >>> ~xe);  //整数部分
  9087:             for (int i = 0; o != 0; i++) {
  9088:               if ((o & 1) != 0) {
  9089:                 this.imul (EXP10_M_I[i]);
  9090:               }
  9091:               o >>>= 1;
  9092:             }
  9093:           } else if (xe >= -6) {
  9094:             this.imul (EXP10_M_T[(int) (xd >>> ~xe - 6)]);
  9095:           }
  9096:           this.outer ().finish ();
  9097:           if (epbRoundingMode == EPB_MODE_RZ || epbRoundingMode == EPB_MODE_RM) {
  9098:             //x<0のとき10^x<1なのでRZ,RMで1<=yとなってはならない
  9099:             if (this.flg << 1 == 0 && 0 <= this.epp) {
  9100:               this.set1 ().nextdown (epbRoundingPrec);
  9101:             }
  9102:           }
  9103:         }
  9104:         return this;
  9105:       }
  9106:     }  //efp.exp10(EFP)
  9107: 
  9108:     //------------------------------------------------------------------------
  9109:     //x = x.exp2 ()
  9110:     //  x=2^x
  9111:     //y = y.exp2 (x)
  9112:     //  y=2^x
  9113:     //  底が2の指数関数 exponential with base 2
  9114:     //
  9115:     //  グラフ
  9116:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{2**$_[0]});print$g"
  9117:     //    echo read("../misc/efp.gp");eval("exp2(x)=2^x");graph(exp2) | gp -q
  9118:     //    +---------+---------+---------+---------+---------+---------*---------+---------+
  9119:     //    |                                       |                  **                   |
  9120:     //    |                                       |                 **                    |
  9121:     //    |                                       |                **                     |
  9122:     //    |                                       |               **                      |
  9123:     //    +                                       +              **                       +
  9124:     //    |                                       |             **                        |
  9125:     //    |                                       |            **                         |
  9126:     //    |                                       |           **                          |
  9127:     //    |                                       |          **                           |
  9128:     //    +                                       +        ***                            +
  9129:     //    |                                       |       **                              |
  9130:     //    |                                       |     ***                               |
  9131:     //    |                                       |   ***                                 |
  9132:     //    |                                       |****                                   |
  9133:     //    +                                     ****                                      +
  9134:     //    |                                  **** |                                       |
  9135:     //    |                             ******    |                                       |
  9136:     //    |                      ********         |                                       |
  9137:     //    |      *****************                |                                       |
  9138:     //    ********--+---------+---------+---------+---------+---------+---------+---------+
  9139:     //    |                                       |                                       |
  9140:     //    |                                       |                                       |
  9141:     //    |                                       |                                       |
  9142:     //    |                                       |                                       |
  9143:     //    +                                       +                                       +
  9144:     //    |                                       |                                       |
  9145:     //    |                                       |                                       |
  9146:     //    |                                       |                                       |
  9147:     //    |                                       |                                       |
  9148:     //    +                                       +                                       +
  9149:     //    |                                       |                                       |
  9150:     //    |                                       |                                       |
  9151:     //    |                                       |                                       |
  9152:     //    |                                       |                                       |
  9153:     //    +                                       +                                       +
  9154:     //    |                                       |                                       |
  9155:     //    |                                       |                                       |
  9156:     //    |                                       |                                       |
  9157:     //    |                                       |                                       |
  9158:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  9159:     //
  9160:     //  定義域
  9161:     //    -inf<=x<=inf
  9162:     //
  9163:     //  値域
  9164:     //    0<y<=inf
  9165:     //
  9166:     //  指数関数との関係
  9167:     //    2^x=(e^log(2))^x
  9168:     //       =e^(log(2)*x)
  9169:     //    e^x=(2^log2(e))^x
  9170:     //       =2^(log2(e)*x)
  9171:     //
  9172:     //  手順
  9173:     //    abs(x)<2^-LENのときは1を返す
  9174:     //      x→0のとき2^x→1+log(2)*x≒1+0.693*xなので1+xが情報落ちで1になるときは2^xも1になる
  9175:     //    xを整数部と小数部に分ける
  9176:     //    整数部はそのまま指数部にする
  9177:     //    小数部はチェビシェフ展開を行う
  9178:     //
  9179:     //  exp2(x)
  9180:     //    echo read("../misc/efp.gp");eval("f(n,x)=sum(k=0,n,log(2)^k/k!*x^k)");eval("g(x)=2^x");for(n=0,26,printf("%4d",floor(closeness(g,f(n,x),-1,1,10000)))) | gp -q
  9181:     //    echo read("../misc/efp.gp");eval("f(x)=2^x");a=-1;b=0;for(n=0,26,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
  9182:     //    echo read("../misc/efp.gp");eval("f(x)=2^x");a=0;b=1;for(n=0,26,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
  9183:     //                次数   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26
  9184:     //        テイラー展開   0   1   3   5   8  11  15  18  22  26  30  34  38  42  47  51  56  61  65  70  75  80  85  90  95 101 106
  9185:     //    チェビシェフ展開
  9186:     //              [-1,0]   1   4   8  13  18  23  38  34  39  45  51  57  63  70  76  83  89  96 103 110 117 124 131 138 145 152 159
  9187:     //               [0,1]   1   4   8  13  18  23  38  34  39  45  51  57  63  70  76  83  89  96 103 110 117 124 131 138 145 152 159
  9188:     //
  9189:     //  累乗の方法
  9190:     //    例
  9191:     //      2^1.375=2^(1+1/4+1/8)
  9192:     //             =2^1*2^(1/4)*2^(1/8)
  9193:     //    2^(1/4)や2^(1/8)をテーブルに展開しておいて必要なものを掛けるだけ
  9194:     //    1bitずつやると効率が悪いので数bitずつまとめる
  9195:     //       bit  ブロック  サイズ
  9196:     //         1      92    1*92=92
  9197:     //         2      46    3*46=138
  9198:     //         3      31    7*31=217
  9199:     //         4      23    15*23=345
  9200:     //
  9201:     //  チェビシェフ展開
  9202:     //    [0,1]を8分割
  9203:     //    echo read("../misc/efp.gp");eval("f(x)=2^x");a=0;b=0.125;for(n=0,25,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
  9204:     //    echo read("../misc/efp.gp");eval("f(x)=2^x");a=0.125;b=0.25;for(n=0,25,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
  9205:     //    echo read("../misc/efp.gp");eval("f(x)=2^x");a=0.25;b=0.375;for(n=0,25,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
  9206:     //    echo read("../misc/efp.gp");eval("f(x)=2^x");a=0.375;b=0.5;for(n=0,25,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
  9207:     //    echo read("../misc/efp.gp");eval("f(x)=2^x");a=0.5;b=0.625;for(n=0,25,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
  9208:     //    echo read("../misc/efp.gp");eval("f(x)=2^x");a=0.625;b=0.75;for(n=0,25,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
  9209:     //    echo read("../misc/efp.gp");eval("f(x)=2^x");a=0.75;b=0.875;for(n=0,25,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
  9210:     //    echo read("../misc/efp.gp");eval("f(x)=2^x");a=0.875;b=1;for(n=0,25,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
  9211:     //                   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25
  9212:     //       [0,0.125]   4  11  18  25  33  41  49  58  67  76  85  94 103 112 122 131 141 150 160 170 180 190 200 210 220 231
  9213:     //    [0.125,0.25]   4  11  18  25  33  41  49  58  67  76  85  94 103 112 122 131 141 150 160 170 180 190 200 210 220 231
  9214:     //    [0.25,0.375]   4  11  18  25  33  41  49  58  67  76  85  94 103 112 122 131 141 150 160 170 180 190 200 210 220 231
  9215:     //     [0.375,0.5]   4  11  18  25  33  41  49  58  67  76  85  94 103 112 122 131 141 150 160 170 180 190 200 210 220 231
  9216:     //     [0.5,0.625]   4  11  18  25  33  41  49  58  67  76  85  94 103 112 122 131 141 150 160 170 180 190 200 210 220 231
  9217:     //    [0.625,0.75]   4  11  18  25  33  41  49  58  67  76  85  94 103 112 122 131 141 150 160 170 180 190 200 210 220 231
  9218:     //    [0.75,0.875]   4  11  18  25  33  41  49  58  67  76  85  94 103 112 122 131 141 150 160 170 180 190 200 210 220 231
  9219:     //       [0.875,1]   4  11  18  25  33  41  49  58  67  76  85  94 103 112 122 131 141 150 160 170 180 190 200 210 220 231
  9220:     //
  9221:     public final EFP exp2 () {
  9222:       return this.exp2 (this);
  9223:     }  //efp.exp2()
  9224:     public final EFP exp2 (EFP x) {
  9225:       int xf = x.flg;
  9226:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  9227:         if (xf << 1 < 0) {  //2^±0=1
  9228:           //this.set1 ();
  9229:           this.flg = P;
  9230:           this.epp = 0;
  9231:           this.dvl = MSB;
  9232:           this.cvl = 0L;
  9233:         } else {
  9234:           this.flg = (xf == (P | I) ? P | I :  //2^+Inf=+Inf。オーバーフローはセットされない
  9235:                       xf == (M | I) ? P | Z :  //2^-Inf=+0。アンダーフローはセットされない
  9236:                       N);  //2^NaN=NaN
  9237:         }
  9238:         return this;
  9239:       }
  9240:       //±0,±Inf,NaN以外
  9241:       epbFpsr |= EPB_FPSR_X2;  //不正確な結果。オーバーフローまたはアンダーフローのときもセットされる
  9242:       epbExceptionOperandExponent = xf | 0x3fff + x.epp << 16;
  9243:       epbExceptionOperandMantissa = x.dvl;
  9244:       if (15 <= x.epp) {  //x<=-32768||32768<=x
  9245:         if (xf < 0) {  //x<=-32768。exp2(-big)=+0
  9246:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
  9247:           return this.sete (UNFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1]).finish ();  //+0
  9248:         } else {  //32768<=x。exp2(+big)=+Inf
  9249:           epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
  9250:           return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1]).finish ();  //+Inf
  9251:         }
  9252:       }
  9253:       if (false) {  //powを使う。powがexp2を使っている場合は不可
  9254:         return this.pow (TWO, x);  //2^x
  9255:       } else if (false) {  //expを使う。expがexp2を使っている場合は不可
  9256:         return this.inner ().imul (LOG_2, x).outer ().exp ();  //2^x=e^(log(2)*x)
  9257:       } else {  //64分割。[91] 205ns
  9258:         int xe = x.epp;
  9259:         long xd = x.dvl;  //整数部分は高々16bit
  9260:         long xc = x.cvl;
  9261:         this.inner ();
  9262:         EFP u;
  9263:         if (false) {
  9264:           u = new EFP ().shl (x, 6).frac ().shr (6);  //xの小数点以下7桁目以降
  9265:         } else {
  9266:           int uf = xf;
  9267:           int ue;
  9268:           long ud;
  9269:           long uc;
  9270:           int o = xe + 7;
  9271:           if (o <= 0) {
  9272:             ue = xe;
  9273:             ud = xd;
  9274:             uc = xc;
  9275:           } else if (o <= 63) {
  9276:             ue = -7;
  9277:             ud = xd << o | xc >>> -o;
  9278:             uc = xc << o;
  9279:           } else if (o <= LEN - 1) {
  9280:             ue = -7;
  9281:             ud = xc << o;
  9282:             uc = 0L;
  9283:           } else {
  9284:             ue = 0;
  9285:             ud = 0L;
  9286:             uc = 0L;
  9287:           }
  9288:           if (ud >= 0L) {
  9289:             if (ud != 0L) {
  9290:               o = Long.numberOfLeadingZeros (ud);
  9291:               ue -= o;
  9292:               ud = ud << o | uc >>> -o;
  9293:               uc <<= o;
  9294:             } else if (uc != 0L) {
  9295:               o = 64 + Long.numberOfLeadingZeros (uc);
  9296:               ue -= o;
  9297:               ud = uc << o;
  9298:               uc = 0L;
  9299:             } else {
  9300:               uf |= Z;
  9301:             }
  9302:           }
  9303:           u = new EFP (uf, ue, ud, uc);  //xの小数点以下7桁目以降
  9304:         }
  9305:         if (xf >= 0) {
  9306:           this.imul (EXP2P_C8, u)
  9307:             .iadd (EXP2P_C7).imul (u)
  9308:               .iadd (EXP2P_C6).imul (u)
  9309:                 .iadd (EXP2P_C5).imul (u)
  9310:                   .iadd (EXP2P_C4).imul (u)
  9311:                     .iadd (EXP2P_C3).imul (u)
  9312:                       .iadd (EXP2P_C2).imul (u)
  9313:                         .iadd (EXP2P_C1).imul (u)
  9314:                           //.iadd (EXP2P_C0);
  9315:                           .inc ();
  9316:           if (xe >= 0) {
  9317:             this.imul (EXP2P_T[(int) (xd << xe + 1 >>> -6)]).shl ((int) (xd >>> ~xe));
  9318:           } else if (xe >= -6) {
  9319:             this.imul (EXP2P_T[(int) (xd >>> ~xe - 6)]);
  9320:           }
  9321:           this.outer ().finish ();
  9322:           if (epbRoundingMode == EPB_MODE_RP) {
  9323:             //0<xのとき1<2^xなのでRPでy<=1となってはならない
  9324:             if (this.flg << 1 == 0 &&  (this.epp < 0 ||
  9325:                                         this.epp == 0 && this.dvl == MSB && this.cvl == 0L)) {
  9326:               this.set1 ().nextup (epbRoundingPrec);
  9327:             }
  9328:           }
  9329:         } else {
  9330:           this.imul (EXP2M_C8, u)
  9331:             .iadd (EXP2M_C7).imul (u)
  9332:               .iadd (EXP2M_C6).imul (u)
  9333:                 .iadd (EXP2M_C5).imul (u)
  9334:                   .iadd (EXP2M_C4).imul (u)
  9335:                     .iadd (EXP2M_C3).imul (u)
  9336:                       .iadd (EXP2M_C2).imul (u)
  9337:                         .iadd (EXP2M_C1).imul (u)
  9338:                           //.iadd (EXP2M_C0);
  9339:                           .inc ();
  9340:           if (xe >= 0) {
  9341:             this.imul (EXP2M_T[(int) (xd << xe + 1 >>> -6)]).shr ((int) (xd >>> ~xe));
  9342:           } else if (xe >= -6) {
  9343:             this.imul (EXP2M_T[(int) (xd >>> ~xe - 6)]);
  9344:           }
  9345:           this.outer ().finish ();
  9346:           if (epbRoundingMode == EPB_MODE_RZ || epbRoundingMode == EPB_MODE_RM) {
  9347:             //x<0のとき2^x<1なのでRZ,RMで1<=yとなってはならない
  9348:             if (this.flg << 1 == 0 && 0 <= this.epp) {
  9349:               this.set1 ().nextdown (epbRoundingPrec);
  9350:             }
  9351:           }
  9352:         }
  9353:         return this;
  9354:       }
  9355:     }  //efp.exp2(EFP)
  9356: 
  9357:     //------------------------------------------------------------------------
  9358:     //x = x.exp2m1 ()
  9359:     //  x=2^x-1
  9360:     //y = y.exp2m1 (x)
  9361:     //  y=2^x-1
  9362:     //  0に近い数の底が2の指数関数 exponential of number being close to 0 with base 2
  9363:     //
  9364:     //  グラフ
  9365:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{my($x)=@_;2**$x-1});print$g"
  9366:     //    echo read("../misc/efp.gp");eval("f(x)=2^x-1");graph(f) | gp -q
  9367:     //    +---------+---------+---------+---------+---------+---------+--**-----+---------+
  9368:     //    |                                       |                     **                |
  9369:     //    |                                       |                     *                 |
  9370:     //    |                                       |                    **                 |
  9371:     //    |                                       |                   **                  |
  9372:     //    +                                       +                   *                   +
  9373:     //    |                                       |                  **                   |
  9374:     //    |                                       |                 **                    |
  9375:     //    |                                       |                **                     |
  9376:     //    |                                       |               **                      |
  9377:     //    +                                       +              **                       +
  9378:     //    |                                       |             **                        |
  9379:     //    |                                       |            **                         |
  9380:     //    |                                       |           **                          |
  9381:     //    |                                       |          **                           |
  9382:     //    +                                       +        ***                            +
  9383:     //    |                                       |       **                              |
  9384:     //    |                                       |     ***                               |
  9385:     //    |                                       |   ***                                 |
  9386:     //    |                                       |****                                   |
  9387:     //    +---------+---------+---------+-------****--------+---------+---------+---------+
  9388:     //    |                                  **** |                                       |
  9389:     //    |                             ******    |                                       |
  9390:     //    |                      ********         |                                       |
  9391:     //    |      *****************                |                                       |
  9392:     //    ********                                +                                       +
  9393:     //    |                                       |                                       |
  9394:     //    |                                       |                                       |
  9395:     //    |                                       |                                       |
  9396:     //    |                                       |                                       |
  9397:     //    +                                       +                                       +
  9398:     //    |                                       |                                       |
  9399:     //    |                                       |                                       |
  9400:     //    |                                       |                                       |
  9401:     //    |                                       |                                       |
  9402:     //    +                                       +                                       +
  9403:     //    |                                       |                                       |
  9404:     //    |                                       |                                       |
  9405:     //    |                                       |                                       |
  9406:     //    |                                       |                                       |
  9407:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  9408:     //
  9409:     //  定義域
  9410:     //    -inf<=x<=inf
  9411:     //
  9412:     //  値域
  9413:     //    -1<y<=inf
  9414:     //
  9415:     //  メモ
  9416:     //    |x|が0に極端に近いとき、exp2(x)-1を計算しようとすると情報落ちで1になってしまうが、exp2m1(x)は真の値に近い結果を返す
  9417:     //
  9418:     //  加算
  9419:     //    2^(x+y)-1=(2^x-1)*(2^y-1)+(2^x-1)+(2^y-1)
  9420:     //
  9421:     //  テイラー展開
  9422:     //    > coeff(sub(a=0,for n:=0:4 sum sub(x=a,df(2^x-1,x,n))/factorial(n)*(x-a)^n),x);
  9423:     //    {0,
  9424:     //     log(2),
  9425:     //            2
  9426:     //      log(2)
  9427:     //     ---------,
  9428:     //         2
  9429:     //            3
  9430:     //      log(2)
  9431:     //     ---------,
  9432:     //         6
  9433:     //            4
  9434:     //      log(2)
  9435:     //     ---------}
  9436:     //        24
  9437:     //
  9438:     //  チェビシェフ展開
  9439:     //    [0,1]を8分割する
  9440:     //    echo read("../misc/efp.gp");eval("f(x)=2^x-1");for(s=0,7,a=s/8;b=(s+1)/8;printf("  //    [%6.3f,%6.3f]",a,b);for(n=0,15,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000))));print()) | gp -q
  9441:     //                      0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15
  9442:     //    [ 0.000, 0.125] -13  -6   1   8  16  24  33  41  50  59  68  77  86  95 105 114
  9443:     //    [ 0.125, 0.250]   0   7  14  22  29  38  46  54  63  72  81  90  99 109 118 128
  9444:     //    [ 0.250, 0.375]   1   8  15  22  30  38  47  55  64  73  82  91 100 110 119 128
  9445:     //    [ 0.375, 0.500]   2   8  15  23  31  39  47  56  65  73  82  91 101 110 119 129
  9446:     //    [ 0.500, 0.625]   2   9  16  23  31  39  48  56  65  74  83  92 101 110 120 129
  9447:     //    [ 0.625, 0.750]   2   9  16  24  31  40  48  56  65  74  83  92 101 111 120 130
  9448:     //    [ 0.750, 0.875]   3   9  16  24  32  40  48  57  65  74  83  92 102 111 120 130
  9449:     //    [ 0.875, 1.000]   3   9  16  24  32  40  48  57  66  74  83  92 102 111 120 130
  9450:     //
  9451:     public final EFP exp2m1 () {
  9452:       return this.exp2m1 (this);
  9453:     }  //efp.exp2m1()
  9454:     public final EFP exp2m1 (EFP x) {
  9455:       int xf = x.flg;
  9456:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  9457:         if (xf == (M | I)) {  //exp2m1(-Inf)=-1
  9458:           this.flg = M;  //-1
  9459:           this.epp = 0;
  9460:           this.dvl = MSB;
  9461:           this.cvl = 0L;
  9462:         } else {  //exp2m1(±0)=±0, exp2m1(+Inf)=+Inf, exp2m1(NaN)=NaN
  9463:           this.flg = xf;  //x
  9464:         }
  9465:         return this;
  9466:       }
  9467:       //±0,±Inf,NaN以外
  9468:       epbFpsr |= EPB_FPSR_X2;  //不正確な結果。オーバーフローまたはアンダーフローのときもセットされる
  9469:       epbExceptionOperandExponent = xf | 0x3fff + x.epp << 16;
  9470:       epbExceptionOperandMantissa = x.dvl;
  9471:       if (xf < 0) {  //x<0
  9472:         if (8 <= x.epp) {  //x<=-256。exp2m1(-big)=-1
  9473:           //exp2(-big).dec()だとアンダーフローがセットされてしまう場合がある
  9474:           if (epbRoundingMode == EPB_MODE_RZ || epbRoundingMode == EPB_MODE_RP) {
  9475:             return this.sete (NEXTUP_MINUSONE[epbRoundingPrec]).finish ();  //-1
  9476:           } else {
  9477:             return this.negset1 ().finish ();  //-1
  9478:           }
  9479:         }
  9480:       } else {  //0<x
  9481:         if (15 <= x.epp) {  //32768<=x。exp2m1(+big)=+Inf
  9482:           epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
  9483:           return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1]).finish ();  //+Inf
  9484:         }
  9485:       }
  9486:       int xe = x.epp;
  9487:       if (xe < -2) {  //|x|<1/4
  9488:         this.inner ();
  9489:         if (this == x) {
  9490:           x = new EFP (x);  //必要なときだけコピーする
  9491:         }
  9492:         return this.imul (EXP2M1_C17, x)
  9493:           .iadd (EXP2M1_C16).imul (x)
  9494:             .iadd (EXP2M1_C15).imul (x)
  9495:               .iadd (EXP2M1_C14).imul (x)
  9496:                 .iadd (EXP2M1_C13).imul (x)
  9497:                   .iadd (EXP2M1_C12).imul (x)
  9498:                     .iadd (EXP2M1_C11).imul (x)
  9499:                       .iadd (EXP2M1_C10).imul (x)
  9500:                         .iadd (EXP2M1_C9).imul (x)
  9501:                           .iadd (EXP2M1_C8).imul (x)
  9502:                             .iadd (EXP2M1_C7).imul (x)
  9503:                               .iadd (EXP2M1_C6).imul (x)
  9504:                                 .iadd (EXP2M1_C5).imul (x)
  9505:                                   .iadd (EXP2M1_C4).imul (x)
  9506:                                     .iadd (EXP2M1_C3).imul (x)
  9507:                                       .iadd (EXP2M1_C2).imul (x)
  9508:                                         .iadd (EXP2M1_C1).outer ().mul (x);
  9509:       }
  9510:       int savedFpsr = epbFpsr;
  9511:       this.inner ().exp2 (x).outer ().dec ();
  9512:       //exp2(x).dec()だとRZ,RPのとき-1になってしまう場合がある
  9513:       if (this.flg << 1 == 0 && (this.flg < 0 && 0 <= this.epp)) {  //this<=-1
  9514:         if (epbRoundingMode == EPB_MODE_RZ || epbRoundingMode == EPB_MODE_RP) {
  9515:           this.sete (NEXTUP_MINUSONE[epbRoundingPrec]).finish ();  //-1
  9516:         }
  9517:       }
  9518:       return this.correctUnderflow (savedFpsr);
  9519:     }  //efp.exp2m1(EFP)
  9520: 
  9521:     //------------------------------------------------------------------------
  9522:     //x = x.expm1 ()
  9523:     //  x=e^x-1
  9524:     //y = y.expm1 (x)
  9525:     //  y=e^x-1
  9526:     //  0に近い数の指数関数 exponential of number being close to 0
  9527:     //
  9528:     //  グラフ
  9529:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{my($x)=@_;exp($x)-1});print$g"
  9530:     //    echo read("../misc/efp.gp");graph(expm1) | gp -q
  9531:     //    +---------+---------+---------+---------+---------+-----*---+---------+---------+
  9532:     //    |                                       |              **                       |
  9533:     //    |                                       |              *                        |
  9534:     //    |                                       |              *                        |
  9535:     //    |                                       |             **                        |
  9536:     //    +                                       +             *                         +
  9537:     //    |                                       |            **                         |
  9538:     //    |                                       |            *                          |
  9539:     //    |                                       |           **                          |
  9540:     //    |                                       |          **                           |
  9541:     //    +                                       +          *                            +
  9542:     //    |                                       |         **                            |
  9543:     //    |                                       |        **                             |
  9544:     //    |                                       |       **                              |
  9545:     //    |                                       |      **                               |
  9546:     //    +                                       +     **                                +
  9547:     //    |                                       |    **                                 |
  9548:     //    |                                       |   **                                  |
  9549:     //    |                                       |  **                                   |
  9550:     //    |                                       |***                                    |
  9551:     //    +---------+---------+---------+--------***--------+---------+---------+---------+
  9552:     //    |                                   ****|                                       |
  9553:     //    |                                ****   |                                       |
  9554:     //    |                           ******      |                                       |
  9555:     //    |                ************           |                                       |
  9556:     //    ******************                      +                                       +
  9557:     //    |                                       |                                       |
  9558:     //    |                                       |                                       |
  9559:     //    |                                       |                                       |
  9560:     //    |                                       |                                       |
  9561:     //    +                                       +                                       +
  9562:     //    |                                       |                                       |
  9563:     //    |                                       |                                       |
  9564:     //    |                                       |                                       |
  9565:     //    |                                       |                                       |
  9566:     //    +                                       +                                       +
  9567:     //    |                                       |                                       |
  9568:     //    |                                       |                                       |
  9569:     //    |                                       |                                       |
  9570:     //    |                                       |                                       |
  9571:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  9572:     //
  9573:     //  定義域
  9574:     //    -inf<=x<=inf
  9575:     //
  9576:     //  値域
  9577:     //    -1<y<=inf
  9578:     //
  9579:     //  メモ
  9580:     //    |x|が0に極端に近いとき、exp(x)-1を計算しようとすると情報落ちで1になってしまうが、expm1(x)は真の値に近い結果を返す
  9581:     //    e^x-e^-xは|x|が0に極端に近いときexp(x)-exp(-x)よりもexpm1(x)-expm1(-x)の方が正確
  9582:     //
  9583:     //  加算
  9584:     //    e^(x+y)-1=(e^x-1)*(e^y-1)+(e^x-1)+(e^y-1)
  9585:     //
  9586:     //  テイラー展開
  9587:     //    e^x-1=1/1!*x+1/2!*x^2+1/3!*x^3+1/4!*x^4+1/5!*x^5+1/6!*x^6+...
  9588:     //    f(n,x)=sum(k=1,n,1/k!*x^k)
  9589:     //    > coeff(sub(a=0,for n:=0:8 sum sub(x=a,df(e^x-1,x,n))/factorial(n)*(x-a)^n),x);
  9590:     //          1   1   1     1     1     1       1
  9591:     //    {0,1,---,---,----,-----,-----,------,-------}
  9592:     //          2   6   24   120   720   5040   40320
  9593:     //    e^xのテイラー展開から定数項の1を除いたもの
  9594:     //
  9595:     //  チェビシェフ展開
  9596:     //    echo read("../misc/efp.gp");eval("f(x)=expm1(x)");a=-1;b=1;forstep(n=0,30,2,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
  9597:     //       0   2   4   6   8  10  12  14  16  18  20  22  24  26  28  30
  9598:     //     -11  -5   2   9  18  27  36  46  57  67  78  89 100 112 123 135
  9599:     //
  9600:     public final EFP expm1 () {
  9601:       return this.expm1 (this);
  9602:     }  //efp.expm1()
  9603:     public final EFP expm1 (EFP x) {
  9604:       int xf = x.flg;
  9605:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  9606:         if (xf == (M | I)) {  //expm1(-Inf)=-1
  9607:           this.flg = M;  //-1
  9608:           this.epp = 0;
  9609:           this.dvl = MSB;
  9610:           this.cvl = 0L;
  9611:         } else {  //expm1(±0)=±0, expm1(+Inf)=+Inf, expm1(NaN)=NaN
  9612:           this.flg = xf;  //x
  9613:         }
  9614:         return this;
  9615:       }
  9616:       //±0,±Inf,NaN以外
  9617:       epbFpsr |= EPB_FPSR_X2;  //不正確な結果。オーバーフローまたはアンダーフローのときもセットされる
  9618:       epbExceptionOperandExponent = xf | 0x3fff + x.epp << 16;
  9619:       epbExceptionOperandMantissa = x.dvl;
  9620:       if (xf < 0) {  //x<0
  9621:         if (8 <= x.epp) {  //x<=-256。expm1(-big)=-1
  9622:           //exp(-big).dec()だとアンダーフローがセットされてしまう場合がある
  9623:           if (epbRoundingMode == EPB_MODE_RZ || epbRoundingMode == EPB_MODE_RP) {
  9624:             return this.sete (NEXTUP_MINUSONE[epbRoundingPrec]).finish ();  //-1
  9625:           } else {
  9626:             return this.negset1 ().finish ();  //-1
  9627:           }
  9628:         }
  9629:       } else {  //0<x
  9630:         if (15 <= x.epp) {  //32768<=x。expm1(+big)=+Inf
  9631:           epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
  9632:           return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1]).finish ();  //+Inf
  9633:         }
  9634:       }
  9635:       int savedFpsr = epbFpsr;
  9636:       this.inner ();
  9637:       if (x.epp < -2) {  //|x|<1/4
  9638:         if (this == x) {
  9639:           x = new EFP (x);
  9640:         }
  9641:         this.imul (EXPM1_C18, x)
  9642:           .iadd (EXPM1_C17).imul (x)
  9643:             .iadd (EXPM1_C16).imul (x)
  9644:               .iadd (EXPM1_C15).imul (x)
  9645:                 .iadd (EXPM1_C14).imul (x)
  9646:                   .iadd (EXPM1_C13).imul (x)
  9647:                     .iadd (EXPM1_C12).imul (x)
  9648:                       .iadd (EXPM1_C11).imul (x)
  9649:                         .iadd (EXPM1_C10).imul (x)
  9650:                           .iadd (EXPM1_C9).imul (x)
  9651:                             .iadd (EXPM1_C8).imul (x)
  9652:                               .iadd (EXPM1_C7).imul (x)
  9653:                                 .iadd (EXPM1_C6).imul (x)
  9654:                                   .iadd (EXPM1_C5).imul (x)
  9655:                                     .iadd (EXPM1_C4).imul (x)
  9656:                                       .iadd (EXPM1_C3).imul (x)
  9657:                                         .iadd (EXPM1_C2).imul (x)
  9658:                                           .iadd (EXPM1_C1).outer ().mul (x);
  9659:         return this.originUpperUpper (x).correctUnderflow (savedFpsr);
  9660:       }
  9661:       return this.imul (LOG2_E, x).outer ().exp2m1 ();
  9662:     }  //efp.expm1(EFP)
  9663: 
  9664:     //------------------------------------------------------------------------
  9665:     //x = x.floor ()
  9666:     //  x=floor(x)
  9667:     //y = y.floor (x)
  9668:     //  y=floor(x)
  9669:     //  床関数 floor function
  9670:     //
  9671:     //  グラフ
  9672:     //    perl -e "use POSIX;use Graph;$g=new Graph();$g->grid();$g->func(sub{floor($_[0])});print$g"
  9673:     //    echo read("../misc/efp.gp");graph(floor) | gp -q
  9674:     //    +---------+---------+---------+---------+---------+---------+---------+---------*
  9675:     //    |                                       |                                       |
  9676:     //    |                                       |                                       |
  9677:     //    |                                       |                                       |
  9678:     //    |                                       |                                       |
  9679:     //    +                                       +                             ***********
  9680:     //    |                                       |                                       |
  9681:     //    |                                       |                                       |
  9682:     //    |                                       |                                       |
  9683:     //    |                                       |                                       |
  9684:     //    +                                       +                   ***********         +
  9685:     //    |                                       |                                       |
  9686:     //    |                                       |                                       |
  9687:     //    |                                       |                                       |
  9688:     //    |                                       |                                       |
  9689:     //    +                                       +         ***********                   +
  9690:     //    |                                       |                                       |
  9691:     //    |                                       |                                       |
  9692:     //    |                                       |                                       |
  9693:     //    |                                       |                                       |
  9694:     //    +---------+---------+---------+---------***********---------+---------+---------+
  9695:     //    |                                       |                                       |
  9696:     //    |                                       |                                       |
  9697:     //    |                                       |                                       |
  9698:     //    |                                       |                                       |
  9699:     //    +                             ***********                                       +
  9700:     //    |                                       |                                       |
  9701:     //    |                                       |                                       |
  9702:     //    |                                       |                                       |
  9703:     //    |                                       |                                       |
  9704:     //    +                   ***********         +                                       +
  9705:     //    |                                       |                                       |
  9706:     //    |                                       |                                       |
  9707:     //    |                                       |                                       |
  9708:     //    |                                       |                                       |
  9709:     //    +         ***********                   +                                       +
  9710:     //    |                                       |                                       |
  9711:     //    |                                       |                                       |
  9712:     //    |                                       |                                       |
  9713:     //    |                                       |                                       |
  9714:     //    ***********---------+---------+---------+---------+---------+---------+---------+
  9715:     //
  9716:     //  x以下で最大の整数を返す
  9717:     //  +0<=x<1のときは+0を返す
  9718:     //  x==-0のときだけ-0を返す
  9719:     //  floor(x)==-ceil(-x)
  9720:     //
  9721:     public final EFP floor () {
  9722:       return this.floor (this);
  9723:     }  //efp.floor()
  9724:     public final EFP floor (EFP x) {  //2.7ns
  9725:       int xf = x.flg;
  9726:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  9727:         this.flg = xf;
  9728:         return this;
  9729:       }
  9730:       //±0,±Inf,NaN以外
  9731:       int xe = x.epp;
  9732:       if (xe < 0) {  //すべて小数部
  9733:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  9734:         if (xf >= 0) {  //floor(0<x<1)=+0
  9735:           this.flg = P | Z;
  9736:         } else {  //floor(-1<x<0)=-1
  9737:           this.flg = M;
  9738:           this.epp = 0;
  9739:           this.dvl = MSB;
  9740:           this.cvl = 0L;
  9741:         }
  9742:         return this;
  9743:       }
  9744:       //整数部がある
  9745:       long xd = x.dvl;
  9746:       long xc = x.cvl;
  9747:       long m = MSB >> xe;  //整数部のマスク。符号に注意
  9748:       if (xf >= 0) {  //floor(0<x)=trunc(x)。小数部を切り捨てる
  9749:         if (xe <= 63) {  //0..63。dの途中または末尾まで整数部
  9750:           if ((xd & ~m | xc) != 0L) {  //小数部が0ではない
  9751:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  9752:             xd &= m;  //小数部を切り捨てる
  9753:             xc = 0L;
  9754:           }
  9755:         } else if (xe <= LEN - 2) {  //64..90。cの途中まで整数部
  9756:           if ((xc & ~m) != 0L) {  //小数部が0ではない
  9757:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  9758:             xc &= m;  //小数部を切り捨てる
  9759:           }
  9760:         }
  9761:         //すべて整数部のときはそのまま
  9762:       } else {  //floor(x<0)。小数部を切り捨てる。小数部が0でなかったときは絶対値に1を加える
  9763:         if (xe <= 63) {  //0..63。dの途中または末尾まで整数部
  9764:           long t = xd;  //保存して
  9765:           xd &= m;  //小数部を切り捨てる
  9766:           if (((t ^ xd) | xc) != 0L) {  //小数部が0でなかった
  9767:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  9768:             xd -= m;  //絶対値に1を加える。符号に注意
  9769:             if (xd >= 0L) {  //dから溢れた
  9770:               xd = MSB;
  9771:               xe++;
  9772:               if ((short) xe != xe) {  //オーバーフローした
  9773:                 epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
  9774:                 epbExceptionOperandExponent = xf;
  9775:                 epbExceptionOperandMantissa = xd;
  9776:                 return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | 1]).finish ();  //-Inf
  9777:               }
  9778:             }
  9779:             xc = 0L;
  9780:           }
  9781:           //小数部が0のときはそのまま
  9782:         } else if (xe <= LEN - 2) {  //64..90。cの途中まで整数部
  9783:           long t = xc;  //保存して
  9784:           xc &= m;  //小数部を切り捨てる
  9785:           if ((t ^ xc) != 0L) {  //小数部が0でなかった
  9786:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  9787:             xc -= m;  //絶対値に1を加える。符号に注意
  9788:             if ((t ^ xc) < 0L) {  //cから溢れた
  9789:               xd++;
  9790:               if (xd >= 0L) {  //dから溢れた
  9791:                 xd = MSB;
  9792:                 xe++;
  9793:                 if ((short) xe != xe) {  //オーバーフローした
  9794:                   epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
  9795:                   epbExceptionOperandExponent = xf;
  9796:                   epbExceptionOperandMantissa = xd;
  9797:                   return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | 1]).finish ();  //-Inf
  9798:                 }
  9799:               }
  9800:             }
  9801:           }
  9802:         }
  9803:         //すべて整数部のときはそのまま
  9804:       }
  9805:       return this.finish (xf, xe, xd, xc, 0L);
  9806:     }  //efp.floor(EFP)
  9807: 
  9808:     //------------------------------------------------------------------------
  9809:     //x = x.frac ()
  9810:     //  x=frac(x)
  9811:     //y = y.frac (x)
  9812:     //  y=frac(x)
  9813:     //  小数部 fractional part
  9814:     //
  9815:     //  グラフ
  9816:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{$_[0]-int$_[0]});print$g"
  9817:     //    echo read("../misc/efp.gp");eval("f(x)=x-truncate(x)");graph(f) | gp -q
  9818:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  9819:     //    |                                       |                                       |
  9820:     //    |                                       |                                       |
  9821:     //    |                                       |                                       |
  9822:     //    |                                       |                                       |
  9823:     //    +                                       +                                       +
  9824:     //    |                                       |                                       |
  9825:     //    |                                       |                                       |
  9826:     //    |                                       |                                       |
  9827:     //    |                                       |                                       |
  9828:     //    +                                       +                                       +
  9829:     //    |                                       |                                       |
  9830:     //    |                                       |                                       |
  9831:     //    |                                       |                                       |
  9832:     //    |                                       |                                       |
  9833:     //    +                                       +        **        **        **        **
  9834:     //    |                                       |      ***       ***       ***       ***|
  9835:     //    |                                       |    ***       ***       ***       ***  |
  9836:     //    |                                       |  ***       ***       ***       ***    |
  9837:     //    |                                       |***       ***       ***       ***      |
  9838:     //    *--------**--------**--------**--------***--------**--------**--------**--------*
  9839:     //    |      ***       ***       ***       ***|                                       |
  9840:     //    |    ***       ***       ***       ***  |                                       |
  9841:     //    |  ***       ***       ***       ***    |                                       |
  9842:     //    |***       ***       ***       ***      |                                       |
  9843:     //    **        **        **        **        +                                       +
  9844:     //    |                                       |                                       |
  9845:     //    |                                       |                                       |
  9846:     //    |                                       |                                       |
  9847:     //    |                                       |                                       |
  9848:     //    +                                       +                                       +
  9849:     //    |                                       |                                       |
  9850:     //    |                                       |                                       |
  9851:     //    |                                       |                                       |
  9852:     //    |                                       |                                       |
  9853:     //    +                                       +                                       +
  9854:     //    |                                       |                                       |
  9855:     //    |                                       |                                       |
  9856:     //    |                                       |                                       |
  9857:     //    |                                       |                                       |
  9858:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
  9859:     //
  9860:     //  frac(x)=(t=x-trunc(x))==0?copySign(0,x):t
  9861:     //
  9862:     //  整数部を切り捨てて符号と小数部だけ残す
  9863:     //
  9864:     //  doubleの場合
  9865:     //    frac(x)=Double.doubleToLongBits(x)>=0L?x-Math.floor(x):-(-x-Math.floor(-x))
  9866:     //      符号の判別がx>=+0.0でない理由
  9867:     //        doubleの比較演算子は-0.0と+0.0を区別しないのでx>=+0.0だとfrac(-0.0)が+0.0になってしまう
  9868:     //        Double.compare(x,+0.0)>=+0.0でも-0.0と+0.0を区別できるがDouble.doubleToLongBits(x)>=0Lの方が速そう
  9869:     //      負のときの式がx-Math.ceil(x)でない理由
  9870:     //        doubleの(-1.0)-(-1.0)は+0.0なのでx-ceil(x)だとfrac(-1.0)が+0.0になってしまう
  9871:     //
  9872:     public final EFP frac () {
  9873:       return this.frac (this);
  9874:     }  //efp.frac()
  9875:     public final EFP frac (EFP x) {  //5.6ns
  9876:       int xf = x.flg;
  9877:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  9878:         this.flg = xf << 2 != 0 ? N : xf;  //frac(±Inf)=frac(NaN)=NaN,frac(±0)=±0
  9879:         return this;
  9880:       }
  9881:       //±0,±Inf,NaN以外
  9882:       int xe = x.epp;
  9883:       if (xe >= LEN - 1) {  //91..。すべて整数部
  9884:         this.flg = xf | Z;  //±0
  9885:         return this;
  9886:       }
  9887:       long xd = x.dvl;
  9888:       long xc = x.cvl;
  9889:       if (xe >= 0) {  //0..90。整数部がある
  9890:         if (xe < 63) {  //0..62。dの途中まで整数部
  9891:           xe++;  //整数部のbit数
  9892:           xd = xd << xe | xc >>> -xe;  //整数部を押し出す
  9893:           xc <<= xe;
  9894:           if (xd != 0L) {  //小数部の上位64bitが0でない
  9895:             xe = Long.numberOfLeadingZeros (xd);
  9896:             if (xe > 0) {
  9897:               xd = xd << xe | xc >>> -xe;
  9898:               xc <<= xe;
  9899:             }
  9900:             xe = ~xe;  //xe=-1-xe
  9901:           } else if (xc != 0L) {  //小数部の上位64bitが0で続く64bitが0でない
  9902:             xe = Long.numberOfLeadingZeros (xc);
  9903:             xd = xc << xe;
  9904:             xc = 0L;
  9905:             xe = -65 - xe;
  9906:           } else {  //小数部がすべて0
  9907:             this.flg = xf | Z;  //±0
  9908:             return this;
  9909:           }
  9910:         } else {  //63..90。cの先頭または途中まで整数部
  9911:           xe++;  //整数部のbit数
  9912:           xc <<= xe;  //xc<<=xe-64
  9913:           if (xc != 0L) {  //小数部が0でない
  9914:             xe = Long.numberOfLeadingZeros (xc);
  9915:             xd = xc << xe;
  9916:             xc = 0L;
  9917:             xe = ~xe;  //xe=-1-xe
  9918:           } else {  //小数部がすべて0
  9919:             this.flg = xf | Z;  //±0
  9920:             return this;
  9921:           }
  9922:         }
  9923:       }
  9924:       this.flg = xf;
  9925:       this.epp = xe;
  9926:       this.dvl = xd;
  9927:       this.cvl = xc;
  9928:       return this;
  9929:     }  //efp.frac(EFP)
  9930: 
  9931:     //------------------------------------------------------------------------
  9932:     //b = x.ge (y)
  9933:     //  b=x>=y
  9934:     //  より大きいか等しいか
  9935:     //
  9936:     //  -Inf==-Inf<-x<-0==+0<+x<+Inf==+Inf
  9937:     //
  9938:     //  NaNの扱い
  9939:     //    どちらかがNaNのときはfalseを返す
  9940:     //
  9941:     public boolean ge (EFP y) {
  9942:       int xf = this.flg;
  9943:       int yf = y.flg;
  9944:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
  9945:         return EFP_GE_TABLE[xf >>> 28] << (yf >>> 28 - 1) < 0;
  9946:       }
  9947:       //両方±0,±Inf,NaN以外
  9948:       if (xf != yf) {  //両方±0,±Inf,NaN以外で符号が違う
  9949:         return xf > yf;
  9950:       }
  9951:       //両方±0,±Inf,NaN以外で符号が同じ
  9952:       int s;
  9953:       long t;
  9954:       return (xf >= 0 ? 1 : -1) * ((s = this.epp - y.epp) != 0 ? s >= 0 ? 1 : -1 :
  9955:                                    (t = this.dvl - y.dvl) != 0L ? t >= 0L ? 1 : -1 :
  9956:                                    (t = (this.cvl >>> 1) - (y.cvl >>> 1)) != 0L ? t >= 0L ? 1 : -1 :
  9957:                                    0) >= 0;
  9958:     }  //efp.ge(EFP)
  9959: 
  9960:     //------------------------------------------------------------------------
  9961:     //i = x.getb ()
  9962:     //i = x.getb (roundingMode)
  9963:     //  byte値
  9964:     //
  9965:     //  丸めモードを省略したときは小数点以下を切り捨てる(RZ)
  9966:     //  2^7-1よりも大きい数は2^7-1に、-2^7よりも小さい数は-2^7に変換する(飽和変換)
  9967:     //  NaNは-1に変換する
  9968:     //
  9969:     //  Javaのdoubleからbyteへのキャストは飽和変換ではない(intに飽和変換してから下位8bitを取り出す)ことに注意
  9970:     //
  9971:     public int getb () {
  9972:       int xf = this.flg;
  9973:       if (xf << 1 != 0) {  //±0,±Inf,NaN
  9974:         if (xf << 1 < 0) {  //±0
  9975:           return 0;
  9976:         } else if (xf << 2 < 0) {  //±Inf
  9977:           epbFpsr |= EPB_FPSR_OE;
  9978:           epbExceptionOperandExponent = xf & M | 0x7fff << 16;
  9979:           epbExceptionOperandMantissa = 0x0000000000000000L;
  9980:           return xf >> 31 ^ 0x0000007f;  //+Infは0x0000007f,-Infは0xffffff80
  9981:         } else {  //NaN
  9982:           epbFpsr |= EPB_FPSR_OE | EPB_FPSR_AV;
  9983:           epbExceptionOperandExponent = 0x7fff << 16;
  9984:           epbExceptionOperandMantissa = 0xffffffffffffffffL;
  9985:           return -1;  //NaNは-1
  9986:         }
  9987:       }
  9988:       //±0,±Inf,NaN以外
  9989:       int xe = this.epp;
  9990:       long xd = this.dvl;
  9991:       long xc = this.cvl;
  9992:       if (xe < 0) {  //0<|x|<1
  9993:         if (false) {
  9994:           epbFpsr |= EPB_FPSR_X2;  //不正確な結果
  9995:           epbExceptionOperandExponent = xf | 0x3fff + xe << 16;
  9996:           epbExceptionOperandMantissa = xd;
  9997:         }
  9998:         return 0;
  9999:       }
 10000:       //1<=|x|
 10001:       if (xe < 7) {  //1<=|x|<2^7
 10002:         if (false) {
 10003:           if ((xd << 1 + xe | xc) != 0L) {  //端数がある
 10004:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 10005:             epbExceptionOperandExponent = xf | 0x3fff + xe << 16;
 10006:             epbExceptionOperandMantissa = xd;
 10007:           }
 10008:         }
 10009:         return xf >= 0 ? (int) (xd >>> ~xe) : -(int) (xd >>> ~xe);
 10010:       }
 10011:       //2^7<=|x|
 10012:       if (xf >= 0) {  //2^7<=x
 10013:         epbFpsr |= EPB_FPSR_OE;
 10014:         epbExceptionOperandExponent = 0x3fff + xe << 16;
 10015:         epbExceptionOperandMantissa = xd;
 10016:         return 0x0000007f;
 10017:       }
 10018:       //x<=-2^7
 10019:       if (xe != 7 || xd != MSB || xc != 0L) {  //x!=-2^7
 10020:         epbFpsr |= EPB_FPSR_OE;
 10021:         epbExceptionOperandExponent = M | 0x3fff + xe << 16;
 10022:         epbExceptionOperandMantissa = this.dvl;
 10023:       }
 10024:       return 0xffffff80;
 10025:     }  //efp.getb()
 10026:     public int getb (int roundingMode) {
 10027:       return (roundingMode == EPB_MODE_RN ? new EFP ().inner ().rint (this).outer ().getb () :
 10028:               roundingMode == EPB_MODE_RM ? new EFP ().inner ().floor (this).outer ().getb () :
 10029:               roundingMode == EPB_MODE_RP ? new EFP ().inner ().ceil (this).outer ().getb () :
 10030:               new EFP ().inner ().trunc (this).outer ().getb ());
 10031:     }  //efp.getb(int)
 10032: 
 10033:     //------------------------------------------------------------------------
 10034:     //d = x.getd ()
 10035:     //d = x.getd (roundingMode)
 10036:     //b = x.getd01 (b, a)
 10037:     //b = x.getd01 (b, a, roundingMode)
 10038:     //ib = x.getd01 (ib, ia)
 10039:     //ib = x.getd01 (ib, ia, roundingMode)
 10040:     //l = x.getd01 ()
 10041:     //l = x.getd01 (roundingMode)
 10042:     //  double値
 10043:     //
 10044:     //    0x7fffffffffffffffL  Non-Signaling NaN
 10045:     //    0x7ff7ffffffffffffL  Signaling NaN
 10046:     //    0x7ff0000000000000L  +Inf
 10047:     //    0x7fefffffffffffffL  2^1024-2^971    = 1.7976931348623157081452742373170435680 E308   正規化数の最大値
 10048:     //    0x3ff0000000000000L  2^0             = 1
 10049:     //    0x0010000000000000L  2^-1022         = 2.2250738585072013830902327173324040642 E-308  正規化数の最小値
 10050:     //    0x000fffffffffffffL  2^-1022-2^-1074 = 2.2250738585072008890245868760858598877 E-308  非正規化数の最大値
 10051:     //    0x0000000000000001L  2^-1074         = 4.9406564584124654417656879286822137237 E-324  非正規化数の最小値
 10052:     //    0x0000000000000000L  +0
 10053:     //    NaNの符号はDon't Care、出力は0
 10054:     //    Non-Signaling NaNの小数部の先頭は1
 10055:     //    Signaling NaNの小数部の先頭は0
 10056:     //      Signaling NaNが返ることはない
 10057:     //    NaNの小数部の先頭以外はNon-Zero、出力はすべて1
 10058:     //    ±Infの小数部はすべて0
 10059:     //
 10060:     //    for (long l : new long[] {
 10061:     //      0x7ff0000000000000L,
 10062:     //      0x7fefffffffffffffL,
 10063:     //      0x3ff0000000000000L,
 10064:     //      0x0010000000000000L,
 10065:     //      0x000fffffffffffffL,
 10066:     //      0x0000000000000001L,
 10067:     //      0x0000000000000000L,
 10068:     //    }) {
 10069:     //      System.out.printf ("      //  0x%016x  %.17g\n", l, Double.longBitsToDouble (l));
 10070:     //    }
 10071:     //    0x7ff0000000000000  Infinity
 10072:     //    0x7fefffffffffffff  1.7976931348623157e+308
 10073:     //    0x3ff0000000000000  1.0000000000000000
 10074:     //    0x0010000000000000  2.2250738585072014e-308
 10075:     //    0x000fffffffffffff  2.2250738585072010e-308
 10076:     //    0x0000000000000001  4.9000000000000000e-324  不正確なのではなくて非正規化数の有効桁数が調整されている
 10077:     //    0x0000000000000000  0.0000000000000000
 10078:     //
 10079:     //  丸めモードを省略したときは最も近い値に丸める(RN)
 10080:     //
 10081:     public final double getd () {
 10082:       return getd (EPB_MODE_RN);
 10083:     }  //efp.getd()
 10084:     public final double getd (int roundingMode) {
 10085:       return Double.longBitsToDouble (getd01 (roundingMode));
 10086:     }  //efp.getd(int)
 10087:     public final byte[] getd01 (byte[] b, int a) {
 10088:       return getd01 (b, a, EPB_MODE_RN);
 10089:     }  //efp.getd01(byte[],int)
 10090:     public final byte[] getd01 (byte[] b, int a, int roundingMode) {
 10091:       long l = getd01 (roundingMode);
 10092:       b[a] = (byte) (l >> 56);
 10093:       b[a + 1] = (byte) (l >> 48);
 10094:       b[a + 2] = (byte) (l >> 40);
 10095:       b[a + 3] = (byte) (l >> 32);
 10096:       b[a + 4] = (byte) (l >> 24);
 10097:       b[a + 5] = (byte) (l >> 16);
 10098:       b[a + 6] = (byte) (l >> 8);
 10099:       b[a + 7] = (byte) l;
 10100:       return b;
 10101:     }  //efp.getd01(byte[],int,int)
 10102:     public final int[] getd01 (int[] ib, int ia) {
 10103:       return getd01 (ib, ia, EPB_MODE_RN);
 10104:     }  //efp.getd01(int[],int)
 10105:     public final int[] getd01 (int[] ib, int ia, int roundingMode) {
 10106:       long l = getd01 (roundingMode);
 10107:       ib[ia] = (int) (l >> 32);
 10108:       ib[ia + 1] = (int) l;
 10109:       return ib;
 10110:     }  //efp.getd01(int[],int,int)
 10111:     public final long getd01 () {
 10112:       return getd01 (EPB_MODE_RN);
 10113:     }  //efp.getd01()
 10114:     public final long getd01 (int roundingMode) {
 10115:       int xf = this.flg;
 10116:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 10117:         return (xf << 1 < 0 ? 0 <= xf ? 0x0000000000000000L : 0x8000000000000000L :  //±0
 10118:                 xf << 2 < 0 ? 0 <= xf ? 0x7ff0000000000000L : 0xfff0000000000000L :  //±Inf
 10119:                 EFP_FPCP_NAN ? 0x7fffffffffffffffL : 0x7ff8000000000000L);  //NaN
 10120:       }
 10121:       //±0,±Inf,NaN以外
 10122:       int xe = this.epp;  //正規化数は-1022<=xe<=1023、非正規化数は-1075<=xe<=-1023
 10123:       long xd = this.dvl;
 10124:       long xc = this.cvl;
 10125:       if (xe < -1075) {  //指数部が小さすぎる。非正規化数の最小値は2^-1074だが丸めで繰り上がる場合があるので一旦2^-1075まで受け入れる
 10126:         epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 10127:         epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 10128:         epbExceptionOperandMantissa = xd;
 10129:         return (0 <= xf ?
 10130:                 roundingMode == EPB_MODE_RP ? 0x0000000000000001L : 0x0000000000000000L :  //RPのとき+eps,RN,RZ,RMのとき+0
 10131:                 roundingMode == EPB_MODE_RM ? 0x8000000000000001L : 0x8000000000000000L);  //RMのとき-eps,RN,RZ,RPのとき-0
 10132:       }
 10133:       if (1023 < xe) {  //指数部が大きすぎる
 10134:         if (true) {
 10135:           epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 10136:           if ((xd << 53 | xc) != 0L) {  //端数が0ではない
 10137:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 10138:           }
 10139:         } else {
 10140:           epbFpsr |= EPB_FPSR_OF | EPB_FPSR_X2;  //オーバーフロー、不正確な結果
 10141:         }
 10142:         epbExceptionOperandExponent = xf | 0x3fff - 0x6000 + xe << 16;
 10143:         epbExceptionOperandMantissa = xd;
 10144:         return (0 <= xf ?
 10145:                 roundingMode == EPB_MODE_RZ || roundingMode == EPB_MODE_RM ? 0x7fefffffffffffffL : 0x7ff0000000000000L :  //RZ,RMのとき+max,RN,RPのとき+Inf
 10146:                 roundingMode == EPB_MODE_RZ || roundingMode == EPB_MODE_RP ? 0xffefffffffffffffL : 0xfff0000000000000L);  //RZ,RPのとき-max,RN,RMのとき-Inf
 10147:       }
 10148:       long xb = 0L;
 10149:       int o = xe <= -1023 ? 11 + -1022 - xe : 11;  //右にずらすbit数。正規化数は11、非正規化数は11+1<=o<=11+53
 10150:       if (o < 64) {
 10151:         xb = xc << -o;
 10152:         xc = xd << -o | xc >>> o;
 10153:         xd >>>= o;
 10154:       } else {
 10155:         xb = xc;
 10156:         xc = xd;
 10157:         xd = 0L;
 10158:       }
 10159:       if ((xc | xb) != 0L) {  //端数が0ではない
 10160:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 10161:         if (roundingMode == EPB_MODE_RN && xc < 0L && (xd << 63 | xc << 1 | xb) != 0L ||  //RNでguard bitが1かつLSBまたはguard bit以外の端数が0ではないまたは
 10162:             roundingMode == EPB_MODE_RM && xf < 0 ||  //端数が0ではなくてRMで-または
 10163:             roundingMode == EPB_MODE_RP && 0 <= xf) {  //端数が0ではなくてRPで+のとき
 10164:           xd++;  //繰り上げる
 10165:           if (xd >>> 53 != 0L) {  //繰り上がって溢れたとき
 10166:             xd = 1L << 52;
 10167:             xe++;  //指数部をインクリメントする。ここでxe=1024になる場合がある
 10168:             if (1023 < xe) {  //指数部が大きすぎる
 10169:               epbFpsr |= EPB_FPSR_OF | EPB_FPSR_X2;  //オーバーフロー、不正確な結果
 10170:               epbExceptionOperandExponent = xf | 0x3fff - 0x6000 + xe << 16;
 10171:               epbExceptionOperandMantissa = xd;
 10172:               return (0 <= xf ?
 10173:                       roundingMode == EPB_MODE_RZ || roundingMode == EPB_MODE_RM ? 0x7fefffffffffffffL : 0x7ff0000000000000L :  //RZ,RMのとき+max,RN,RPのとき+Inf
 10174:                       roundingMode == EPB_MODE_RZ || roundingMode == EPB_MODE_RP ? 0xffefffffffffffffL : 0xfff0000000000000L);  //RZ,RPのとき-max,RN,RMのとき-Inf
 10175:             }  //if 指数部が大きすぎる
 10176:           } else if (11 < o) {  //非正規化数のとき
 10177:             if (xd << o - 1 < 0L) {  //1bit増えたとき
 10178:               xe++;  //指数部をインクリメントする
 10179: /* getd01 */
 10180:               if (xe == -1022) {  //非正規化数が繰り上がって正規化数になったとき
 10181:                 //xd = 1L << 52;
 10182:                 epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 10183:                 epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 10184:                 epbExceptionOperandMantissa = xd;
 10185:               }
 10186: /**/
 10187:             }
 10188:           }
 10189:         }
 10190:         //RZ toward zeroのときは端数を切り捨てるだけなので何もしなくてよい
 10191:         if (xe <= -1023) {  //非正規化数
 10192:           epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 10193:           epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 10194:           epbExceptionOperandMantissa = xd;
 10195:           if (xd == 0L) {  //非正規化数でxe==-1075だったとき、先頭の1がxcにあって丸めで繰り上がらなかった
 10196:             return (0 <= xf ?
 10197:                     roundingMode == EPB_MODE_RP ? 0x0000000000000001L : 0x0000000000000000L :  //RPのとき+eps,RN,RZ,RMのとき+0
 10198:                     roundingMode == EPB_MODE_RM ? 0x8000000000000001L : 0x8000000000000000L);  //RMのとき-eps,RN,RZ,RPのとき-0
 10199:           }
 10200:         }  //if 非正規化数
 10201:       } else {  //端数が0
 10202:         if (xe <= -1023) {  //非正規化数
 10203:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 10204:           epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 10205:           epbExceptionOperandMantissa = xd;
 10206:           if (xd == 0L) {  //非正規化数でxe==-1075だったとき、先頭の1がxcにあって丸めで繰り上がらなかった
 10207:             return (0 <= xf ?
 10208:                     roundingMode == EPB_MODE_RP ? 0x0000000000000001L : 0x0000000000000000L :  //RPのとき+eps,RN,RZ,RMのとき+0
 10209:                     roundingMode == EPB_MODE_RM ? 0x8000000000000001L : 0x8000000000000000L);  //RMのとき-eps,RN,RZ,RPのとき-0
 10210:           }
 10211:         }  //if 非正規化数
 10212:       }  //if 端数が0ではない/端数が0
 10213:       return ((long) (xf | Math.max (0, xe + 1023) << 52 - 32) << 32 |  //符号と指数部
 10214:               xd & ((1L << 52) - 1L));  //仮数部。正規化数のときは先頭の1を取り除く
 10215:     }  //efp.getd01(int)
 10216: 
 10217:     //------------------------------------------------------------------------
 10218:     //x = x.getexp ()
 10219:     //y = y.getexp (x)
 10220:     //  指数部
 10221:     //
 10222:     //  getexp(±0)=±0, getexp(±Inf)=NaN, getexp(NaN)=NaN
 10223:     //
 10224:     public final EFP getexp () {
 10225:       return this.getexp (this);
 10226:     }  //efp.getexp()
 10227:     public final EFP getexp (EFP x) {
 10228:       int xf = x.flg;
 10229:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 10230:         if (xf << 2 < 0) {  //±Inf
 10231:           epbFpsr |= EPB_FPSR_OE;
 10232:           epbExceptionOperandExponent = xf & M | 0x7fff << 16;
 10233:           epbExceptionOperandMantissa = 0x0000000000000000L;
 10234:           this.flg = N;  //getexp(±Inf)=NaN
 10235:         } else {  //±0,NaN
 10236:           this.flg = xf;  //getexp(±0)=±0, getexp(NaN)=NaN
 10237:         }
 10238:         return this;
 10239:       }
 10240:       return this.seti (x.epp);  //指数部
 10241:     }  //efp.getexp(EFP)
 10242: 
 10243:     //------------------------------------------------------------------------
 10244:     //f = x.getf ()
 10245:     //f = x.getf (roundingMode)
 10246:     //b = x.getf0 (b, a)
 10247:     //b = x.getf0 (b, a, roundingMode)
 10248:     //ib = x.getf0 (ib, a)
 10249:     //ib = x.getf0 (ib, a, roundingMode)
 10250:     //i = x.getf0 ()
 10251:     //i = x.getf0 (roundingMode)
 10252:     //  float値
 10253:     //
 10254:     //    0x7fffffff  Non-Signaling NaN
 10255:     //    0x7fbfffff  Signaling NaN
 10256:     //    0x7f800000  +Inf
 10257:     //    0x7f7fffff  2^128-2^104   = 3.4028234663852885981170418348451692544 E38   正規化数の最大値
 10258:     //    0x3f800000  2^0           = 1
 10259:     //    0x00800000  2^-126        = 1.1754943508222875079687365372222456778 E-38  正規化数の最小値
 10260:     //    0x007fffff  2^-126-2^-149 = 1.1754942106924410754870294448492873488 E-38  非正規化数の最大値
 10261:     //    0x00000001  2^-149        = 1.4012984643248170709237295832899161313 E-45  非正規化数の最小値
 10262:     //    0x00000000  +0
 10263:     //    NaNの符号はDon't Care、出力は0
 10264:     //    Non-Signaling NaNの小数部の先頭は1
 10265:     //    Signaling NaNの小数部の先頭は0
 10266:     //      Signaling NaNが返ることはない
 10267:     //    NaNの小数部の先頭以外はNon-Zero、出力はすべて1
 10268:     //    ±Infの小数部はすべて0
 10269:     //
 10270:     //    for (int i : new int[] {
 10271:     //      0x7f800000,
 10272:     //      0x7f7fffff,
 10273:     //      0x3f800000,
 10274:     //      0x00800000,
 10275:     //      0x007fffff,
 10276:     //      0x00000001,
 10277:     //      0x00000000,
 10278:     //    }) {
 10279:     //      System.out.printf ("      //  0x%08x  %.17g\n", i, Float.intBitsToFloat (i));
 10280:     //    }
 10281:     //    0x7f800000  Infinity
 10282:     //    0x7f7fffff  3.4028234663852886e+38
 10283:     //    0x3f800000  1.0000000000000000
 10284:     //    0x00800000  1.1754943508222875e-38
 10285:     //    0x007fffff  1.1754942106924411e-38
 10286:     //    0x00000001  1.4012984643248170e-45  doubleでは正規化数なので有効桁数は17桁
 10287:     //    0x00000000  0.0000000000000000
 10288:     //
 10289:     //  丸めモードを省略したときは最も近い値に丸める(RN)
 10290:     //
 10291:     public final float getf () {
 10292:       return getf (EPB_MODE_RN);
 10293:     }  //efp.getf()
 10294:     public final float getf (int roundingMode) {
 10295:       return Float.intBitsToFloat (getf0 (roundingMode));
 10296:     }  //efp.getf(int)
 10297:     public final byte[] getf0 (byte[] b, int a) {
 10298:       return getf0 (b, a, EPB_MODE_RN);
 10299:     }  //efp.getf0(byte[],int)
 10300:     public final byte[] getf0 (byte[] b, int a, int roundingMode) {
 10301:       int i = getf0 (roundingMode);
 10302:       b[a] = (byte) (i >> 24);
 10303:       b[a + 1] = (byte) (i >> 16);
 10304:       b[a + 2] = (byte) (i >>  8);
 10305:       b[a + 3] = (byte) i;
 10306:       return b;
 10307:     }  //efp.getf0(byte[],int,int)
 10308:     public final int[] getf0 (int[] ib, int ia) {
 10309:       return getf0 (ib, ia, EPB_MODE_RN);
 10310:     }  //efp.getf0(int[],int)
 10311:     public final int[] getf0 (int[] ib, int ia, int roundingMode) {
 10312:       ib[ia] = getf0 (roundingMode);
 10313:       return ib;
 10314:     }  //efp.getf0(int[],int,int)
 10315:     public final int getf0 () {
 10316:       return getf0 (EPB_MODE_RN);
 10317:     }  //efp.getf0()
 10318:     public final int getf0 (int roundingMode) {
 10319:       int xf = this.flg;
 10320:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 10321:         return (xf << 1 < 0 ? xf & M :  //±0
 10322:                 xf << 2 < 0 ? (xf & M) | 0x7f800000 :  //±Inf
 10323:                 EFP_FPCP_NAN ? 0x7fffffff : 0x7fc00000);  //NaN
 10324:       }
 10325:       //±0,±Inf,NaN以外
 10326:       int xe = this.epp;  //正規化数は-126<=xe<=127、非正規化数は-149<=xe<=-127
 10327:       long xd = this.dvl;
 10328:       long xc = this.cvl;
 10329:       if (xe < -150) {  //指数部が小さすぎる。非正規化数の最小値は2^-149だが丸めで繰り上がる場合があるので一旦2^-150まで受け入れる
 10330:         epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 10331:         epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 10332:         epbExceptionOperandMantissa = xd;
 10333:         return (0 <= xf ?
 10334:                 roundingMode == EPB_MODE_RP ? 0x00000001 : 0x00000000 :  //RPのとき+eps,RN,RZ,RMのとき+0
 10335:                 roundingMode == EPB_MODE_RM ? 0x80000001 : 0x80000000);  //RMのとき-eps,RN,RZ,RPのとき-0
 10336:       }
 10337:       if (127 < xe) {  //指数部が大きすぎる
 10338:         if (true) {
 10339:           epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 10340:           if ((xd << 24 | xc) != 0L) {  //端数が0ではない
 10341:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 10342:           }
 10343:         } else {
 10344:           epbFpsr |= EPB_FPSR_OF | EPB_FPSR_X2;  //オーバーフロー、不正確な結果
 10345:         }
 10346:         epbExceptionOperandExponent = xf | 0x3fff - 0x6000 + xe << 16;
 10347:         epbExceptionOperandMantissa = xd;
 10348:         return (0 <= xf ?
 10349:                 roundingMode == EPB_MODE_RZ || roundingMode == EPB_MODE_RM ? 0x7f7fffff : 0x7f800000 :  //RZ,RMのとき+max,RN,RPのとき+Inf
 10350:                 roundingMode == EPB_MODE_RZ || roundingMode == EPB_MODE_RP ? 0xff7fffff : 0xff800000);  //RZ,RPのとき-max,RN,RMのとき-Inf
 10351:       }
 10352:       long xb = 0L;
 10353:       int o = xe <= -127 ? 40 + -126 - xe : 40;  //右にずらすbit数。正規化数は40、非正規化数は40+1<=o<=40+24
 10354:       if (o < 64) {
 10355:         xb = xc << -o;
 10356:         xc = xd << -o | xc >>> o;
 10357:         xd >>>= o;
 10358:       } else {
 10359:         xb = xc;
 10360:         xc = xd;
 10361:         xd = 0L;
 10362:       }
 10363:       if ((xc | xb) != 0L) {  //端数が0ではない
 10364:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 10365:         if (roundingMode == EPB_MODE_RN && xc < 0L && (xd << -1 | xc << 1 | xb) != 0L ||  //RNでguard bitが1かつLSBまたはguard bit以外の端数が0ではないまたは
 10366:             roundingMode == EPB_MODE_RM && xf < 0 ||  //端数が0ではなくてRMで-または
 10367:             roundingMode == EPB_MODE_RP && 0 <= xf) {  //端数が0ではなくてRPで+のとき
 10368:           xd++;  //繰り上げる
 10369:           if (xd >>> 24 != 0L) {  //繰り上がって溢れたとき
 10370:             xd = 1L << 23;
 10371:             xe++;  //指数部をインクリメントする。ここでxe=128になる場合がある
 10372:             if (127 < xe) {  //指数部が大きすぎる
 10373:               epbFpsr |= EPB_FPSR_OF | EPB_FPSR_X2;  //オーバーフロー、不正確な結果
 10374:               epbExceptionOperandExponent = xf | 0x3fff - 0x6000 + xe << 16;
 10375:               epbExceptionOperandMantissa = xd;
 10376:               return (0 <= xf ?
 10377:                       roundingMode == EPB_MODE_RZ || roundingMode == EPB_MODE_RM ? 0x7f7fffff : 0x7f800000 :  //RZ,RMのとき+max,RN,RPのとき+Inf
 10378:                       roundingMode == EPB_MODE_RZ || roundingMode == EPB_MODE_RP ? 0xff7fffff : 0xff800000);  //RZ,RPのとき-max,RN,RMのとき-Inf
 10379:             }
 10380:           } else if (40 < o) {  //非正規化数のとき
 10381:             if (xd << o - 1 < 0L) {  //1bit増えたとき
 10382:               xe++;  //指数部をインクリメントする
 10383: /* getf0 */
 10384:               if (xe == -126) {  //非正規化数が繰り上がって正規化数になったとき
 10385:                 //xd = 1L << 23;
 10386:                 epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 10387:                 epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 10388:                 epbExceptionOperandMantissa = xd;
 10389:               }
 10390: /**/
 10391:             }
 10392:           }
 10393:         }
 10394:         //RZ toward zeroのときは端数を切り捨てるだけなので何もしなくてよい
 10395:         if (xe <= -127) {  //非正規化数
 10396:           epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 10397:           epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 10398:           epbExceptionOperandMantissa = xd;
 10399:           if (xd == 0L) {  //非正規化数でxe==-150だったとき、先頭の1がxcにあって丸めで繰り上がらなかった
 10400:             return (0 <= xf ?
 10401:                     roundingMode == EPB_MODE_RP ? 0x00000001 : 0x00000000 :  //RPのとき+eps,RN,RZ,RMのとき+0
 10402:                     roundingMode == EPB_MODE_RM ? 0x80000001 : 0x80000000);  //RMのとき-eps,RN,RZ,RPのとき-0
 10403:           }
 10404:         }  //if 非正規化数
 10405:       } else {  //端数が0
 10406:         if (xe <= -127) {  //非正規化数
 10407:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 10408:           epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 10409:           epbExceptionOperandMantissa = xd;
 10410:           if (xd == 0L) {  //非正規化数でxe==-150だったとき、先頭の1がxcにあって丸めで繰り上がらなかった
 10411:             return (0 <= xf ?
 10412:                     roundingMode == EPB_MODE_RP ? 0x00000001 : 0x00000000 :  //RPのとき+eps,RN,RZ,RMのとき+0
 10413:                     roundingMode == EPB_MODE_RM ? 0x80000001 : 0x80000000);  //RMのとき-eps,RN,RZ,RPのとき-0
 10414:           }
 10415:         }  //if 非正規化数
 10416:       }  //if 端数が0ではない/端数が0
 10417:       return (xf | Math.max (0, xe + 127) << 23 |  //符号と指数部
 10418:               (int) xd & ((1 << 23) - 1));  //仮数部。正規化数のときは先頭の1を取り除く
 10419:     }  //efp.getf0(int)
 10420: 
 10421:     //------------------------------------------------------------------------
 10422:     //i = x.geti ()
 10423:     //i = x.geti (roundingMode)
 10424:     //  int値
 10425:     //
 10426:     //  丸めモードを省略したときは小数点以下を切り捨てる(RZ)
 10427:     //  2^31-1よりも大きい数は2^31-1に、-2^31よりも小さい数は-2^31に変換する(飽和変換)
 10428:     //  NaNは-1に変換する
 10429:     //
 10430:     public int geti () {
 10431:       int xf = this.flg;
 10432:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 10433:         if (xf << 1 < 0) {  //±0
 10434:           return 0;
 10435:         } else if (xf << 2 < 0) {  //±Inf
 10436:           epbFpsr |= EPB_FPSR_OE;
 10437:           epbExceptionOperandExponent = xf & M | 0x7fff << 16;
 10438:           epbExceptionOperandMantissa = 0x0000000000000000L;
 10439:           return xf >> 31 ^ 0x7fffffff;  //+Infは0x7fffffff,-Infは0x80000000
 10440:         } else {  //NaN
 10441:           epbFpsr |= EPB_FPSR_OE | EPB_FPSR_AV;
 10442:           epbExceptionOperandExponent = 0x7fff << 16;
 10443:           epbExceptionOperandMantissa = 0xffffffffffffffffL;
 10444:           return -1;  //NaNは-1
 10445:         }
 10446:       }
 10447:       //±0,±Inf,NaN以外
 10448:       int xe = this.epp;
 10449:       long xd = this.dvl;
 10450:       long xc = this.cvl;
 10451:       if (xe < 0) {  //0<|x|<1
 10452:         if (false) {
 10453:           epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 10454:           epbExceptionOperandExponent = xf | 0x3fff + xe << 16;
 10455:           epbExceptionOperandMantissa = xd;
 10456:         }
 10457:         return 0;
 10458:       }
 10459:       //1<=|x|
 10460:       if (xe < 31) {  //1<=|x|<2^31
 10461:         if (false) {
 10462:           if ((xd << 1 + xe | xc) != 0L) {  //端数がある
 10463:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 10464:             epbExceptionOperandExponent = xf | 0x3fff + xe << 16;
 10465:             epbExceptionOperandMantissa = xd;
 10466:           }
 10467:         }
 10468:         return xf >= 0 ? (int) (xd >>> ~xe) : -(int) (xd >>> ~xe);
 10469:       }
 10470:       //2^31<=|x|
 10471:       if (xf >= 0) {  //2^31<=x
 10472:         epbFpsr |= EPB_FPSR_OE;
 10473:         epbExceptionOperandExponent = 0x3fff + xe << 16;
 10474:         epbExceptionOperandMantissa = xd;
 10475:         return 0x7fffffff;
 10476:       }
 10477:       //x<=-2^31
 10478:       if (xe != 31 || xd != MSB || xc != 0L) {  //x!=-2^31
 10479:         epbFpsr |= EPB_FPSR_OE;
 10480:         epbExceptionOperandExponent = M | 0x3fff + xe << 16;
 10481:         epbExceptionOperandMantissa = this.dvl;
 10482:       }
 10483:       return 0x80000000;
 10484:     }  //efp.geti()
 10485:     public int geti (int roundingMode) {
 10486:       return (roundingMode == EPB_MODE_RN ? new EFP ().inner ().rint (this).outer ().geti () :
 10487:               roundingMode == EPB_MODE_RM ? new EFP ().inner ().floor (this).outer ().geti () :
 10488:               roundingMode == EPB_MODE_RP ? new EFP ().inner ().ceil (this).outer ().geti () :
 10489:               new EFP ().inner ().trunc (this).outer ().geti ());
 10490:     }  //efp.geti(int)
 10491: 
 10492:     //------------------------------------------------------------------------
 10493:     //i = x.geti32 ()
 10494:     //  x&0xffffffff
 10495:     //  整数部の下位32bit
 10496:     //
 10497:     public int geti32 () {
 10498:       int xf = this.flg;
 10499:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 10500:         return 0;
 10501:       }
 10502:       int t = this.geti32abs ();
 10503:       return xf < 0 ? -t : t;
 10504:     }  //efp.geti32
 10505: 
 10506:     //------------------------------------------------------------------------
 10507:     //i = x.geti32abs ()
 10508:     //  abs(x)&0xffffffff
 10509:     //  絶対値の整数部の下位32bit
 10510:     //
 10511:     public int geti32abs () {
 10512:       int xf = this.flg;
 10513:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 10514:         return 0;
 10515:       }
 10516:       //±0,±Inf,NaN以外
 10517:       //   -2                               | 0.0ddd dddd dccc cccc c000 0000 0
 10518:       //   -1                             0 + 0.dddd dddd cccc cccc 0000 0000
 10519:       //    0                d>>>63 +         d.dddd dddc cccc ccc0 0000 000
 10520:       //   30                       |       ddd.dddd dccc cccc c000 0000 0
 10521:       //   31                       |      dddd.dddd cccc cccc 0000 0000
 10522:       //   32                       |    d dddd.dddc cccc ccc0 0000 000
 10523:       //   62                       |  ddd dddd.dccc cccc c000 0000 0
 10524:       //   63                 d>>>0 + dddd dddd.cccc cccc 0000 0000
 10525:       //   64       d<<1|c>>>63 +   d dddd dddc.cccc ccc0 0000 000
 10526:       //   94      d<<31|c>>>33 + ddd dddd dccc.cccc c000 0000 0
 10527:       //   95      c>>>32 +      dddd dddd cccc.cccc 0000 0000
 10528:       //   96             |    d dddd dddc cccc.ccc0 0000 000
 10529:       //  126       c>>>1 +  ddd dddd dccc cccc.c000 0000 0
 10530:       //  127               dddd dddd cccc cccc.0000 0000 + c<<0
 10531:       //  128             d dddd dddc cccc ccc0.0000 000  |
 10532:       //  158           ddd dddd dccc cccc c000.0000 0    + c<<31
 10533:       //  159          dddd dddd cccc cccc 0000.0000 + 0
 10534:       //  160        d dddd dddc cccc ccc0 0000.000  |
 10535:       //  190      ddd dddd dccc cccc c000 0000.0    |
 10536:       //  191     dddd dddd cccc cccc 0000 0000.0    |
 10537:       //  192   d dddd dddc cccc ccc0 0000 0000.0    |
 10538:       //                                   ^^^^
 10539:       int xe = this.epp;
 10540:       long xd = this.dvl;
 10541:       long xc = this.cvl;
 10542:       return (xe <= -1 ? 0 :
 10543:               xe <= 63 ? (int) (xd >>> (63 - xe)) :
 10544:               xe <= 94 ? (int) (xd << (xe - 63) | xc >>> (127 - xe)) :
 10545:               xe <= 126 ? (int) (xc >>> (127 - xe)) :
 10546:               xe <= 158 ? (int) (xc << (xe - 127)) :
 10547:               0);
 10548:     }  //efp.geti32abs
 10549: 
 10550:     //------------------------------------------------------------------------
 10551:     //l = x.geti64 ()
 10552:     //  x&0xffffffffffffffffL
 10553:     //  整数部の下位64bit
 10554:     //
 10555:     public long geti64 () {
 10556:       int xf = this.flg;
 10557:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 10558:         return 0L;
 10559:       }
 10560:       long t = this.geti64abs ();
 10561:       return xf < 0 ? -t : t;
 10562:     }  //efp.geti64
 10563: 
 10564:     //------------------------------------------------------------------------
 10565:     //l = x.geti64abs ()
 10566:     //  abs(x)&0xffffffffffffffffL
 10567:     //  絶対値の整数部の下位64bit
 10568:     //
 10569:     public long geti64abs () {
 10570:       int xf = this.flg;
 10571:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 10572:         return 0L;
 10573:       }
 10574:       //±0,±Inf,NaN以外
 10575:       //   -2                               | 0.0ddd dddd dccc cccc c000 0000 0
 10576:       //   -1                             0 + 0.dddd dddd cccc cccc 0000 0000
 10577:       //    0                d>>>63 +         d.dddd dddc cccc ccc0 0000 000
 10578:       //   30                       |       ddd.dddd dccc cccc c000 0000 0
 10579:       //   31                       |      dddd.dddd cccc cccc 0000 0000
 10580:       //   32                       |    d dddd.dddc cccc ccc0 0000 000
 10581:       //   62                       |  ddd dddd.dccc cccc c000 0000 0
 10582:       //   63                 d>>>0 + dddd dddd.cccc cccc 0000 0000
 10583:       //   64  d<<1|c>>>63 +        d dddd dddc.cccc ccc0 0000 000
 10584:       //   94              |      ddd dddd dccc.cccc c000 0000 0
 10585:       //   95              |     dddd dddd cccc.cccc 0000 0000
 10586:       //   96              |   d dddd dddc cccc.ccc0 0000 000
 10587:       //  126  d<<63|c>>>1 + ddd dddd dccc cccc.c000 0000 0
 10588:       //  127               dddd dddd cccc cccc.0000 0000 + c<<0
 10589:       //  128             d dddd dddc cccc ccc0.0000 000  |
 10590:       //  158           ddd dddd dccc cccc c000.0000 0    |
 10591:       //  159          dddd dddd cccc cccc 0000.0000      |
 10592:       //  160        d dddd dddc cccc ccc0 0000.000       |
 10593:       //  190      ddd dddd dccc cccc c000 0000.0         + c<<63
 10594:       //  191     dddd dddd cccc cccc 0000 0000.0 + 0
 10595:       //  192   d dddd dddc cccc ccc0 0000 0000.0 |
 10596:       //                              ^^^^ ^^^^
 10597:       int xe = this.epp;
 10598:       long xd = this.dvl;
 10599:       long xc = this.cvl;
 10600:       return (xe <= -1 ? 0L :
 10601:               xe <= 63 ? (xd >>> (63 - xe)) :
 10602:               xe <= 126 ? (xd << (xe - 63) | xc >>> (127 - xe)) :
 10603:               xe <= 190 ? (xc << (xe - 127)) :
 10604:               0L);
 10605:     }  //efp.geti64abs
 10606: 
 10607:     //------------------------------------------------------------------------
 10608:     //l = x.getl ()
 10609:     //  long値
 10610:     //
 10611:     //  丸めモードを省略したときは小数点以下を切り捨てる(RZ)
 10612:     //  2^63-1よりも大きい数は2^63-1に、-2^63よりも小さい数は-2^63に変換する(飽和変換)
 10613:     //  NaNは0に変換する
 10614:     //
 10615:     public long getl () {
 10616:       int xf = this.flg;
 10617:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 10618:         if (xf << 1 < 0) {  //±0
 10619:           return 0L;
 10620:         } else if (xf << 2 < 0) {  //±Inf
 10621:           epbFpsr |= EPB_FPSR_OE;
 10622:           epbExceptionOperandExponent = xf & M | 0x7fff << 16;
 10623:           epbExceptionOperandMantissa = 0x0000000000000000L;
 10624:           return xf < 0 ? MSB : ~MSB;  //+Infは0x7fffffffffffffffL,-Infは0x8000000000000000L
 10625:         } else {  //NaN
 10626:           epbFpsr |= EPB_FPSR_OE;
 10627:           epbExceptionOperandExponent = 0x7fff << 16;
 10628:           epbExceptionOperandMantissa = 0xffffffffffffffffL;
 10629:           return 0L;  //NaNは0L
 10630:         }
 10631:       }
 10632:       //±0,±Inf,NaN以外
 10633:       int xe = this.epp;
 10634:       if (xe < 0) {  //0<|x|<1
 10635:         return 0L;
 10636:       }
 10637:       //1<=|x|
 10638:       if (xe < 63) {  //1<=|x|<2^63
 10639:         return xf >= 0 ? this.dvl >>> ~xe : -(this.dvl >>> ~xe);
 10640:       }
 10641:       //2^63<=|x|
 10642:       if (xf >= 0) {  //2^63<=x
 10643:         epbFpsr |= EPB_FPSR_OE;
 10644:         epbExceptionOperandExponent = 0x3fff + xe << 16;
 10645:         epbExceptionOperandMantissa = this.dvl;
 10646:         return 0x7fffffffffffffffL;
 10647:       }
 10648:       //x<=-2^63
 10649:       if (xe != 63 || this.dvl != MSB || this.cvl != 0L) {  //x!=-2^63
 10650:         epbFpsr |= EPB_FPSR_OE;
 10651:         epbExceptionOperandExponent = M | 0x3fff + xe << 16;
 10652:         epbExceptionOperandMantissa = this.dvl;
 10653:       }
 10654:       return 0x8000000000000000L;
 10655:     }  //efp.getl()
 10656:     public long getl (int roundingMode) {
 10657:       return (roundingMode == EPB_MODE_RN ? new EFP ().inner ().rint (this).outer ().getl () :
 10658:               roundingMode == EPB_MODE_RM ? new EFP ().inner ().floor (this).outer ().getl () :
 10659:               roundingMode == EPB_MODE_RP ? new EFP ().inner ().ceil (this).outer ().getl () :
 10660:               this.getl ());
 10661:     }  //efp.getl(int)
 10662: 
 10663:     //------------------------------------------------------------------------
 10664:     //x = x.getman ()
 10665:     //y = y.getman (x)
 10666:     //  仮数部
 10667:     //
 10668:     //  getman(±0)=±0, getman(±Inf)=NaN, getman(NaN)=NaN
 10669:     //
 10670:     public final EFP getman () {
 10671:       return this.getman (this);
 10672:     }  //efp.getman()
 10673:     public final EFP getman (EFP x) {
 10674:       int xf = x.flg;
 10675:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 10676:         if (xf << 2 < 0) {  //±Inf
 10677:           epbFpsr |= EPB_FPSR_OE;
 10678:           epbExceptionOperandExponent = xf & M | 0x7fff << 16;
 10679:           epbExceptionOperandMantissa = 0x0000000000000000L;
 10680:           this.flg = N;  //getman(±Inf)=NaN
 10681:         } else {  //±0,NaN
 10682:           this.flg = xf;  //getman(±0)=±0, getman(NaN)=NaN
 10683:         }
 10684:         return this;
 10685:       }
 10686:       this.flg = xf;  //仮数部
 10687:       this.epp = 0;
 10688:       this.dvl = x.dvl;
 10689:       this.cvl = x.cvl;
 10690:       return this;
 10691:     }  //efp.getman(EFP)
 10692: 
 10693:     //------------------------------------------------------------------------
 10694:     //b = x.getp012 (b, a)
 10695:     //b = x.getp012 (b, a, k)
 10696:     //ib = x.getp012 (ib, ia)
 10697:     //ib = x.getp012 (ib, ia, k)
 10698:     //  packed値
 10699:     //
 10700:     //  0
 10701:     //    bit31     仮数部の符号(0=+,1=-)
 10702:     //    bit30     指数部の符号(0=+,1=-)
 10703:     //    bit29-28  ±Inf,NaNのときはすべて1、それ以外はすべて0
 10704:     //    bit27-16  指数部(BCD)、±0のときはすべて0、±Inf,NaNのときはすべて1
 10705:     //    bit15-12  出力するときは指数部の1000の位、入力するときは不定。±Infのときはすべて0にしておかないとFLOAT4.Xが誤動作する
 10706:     //    bit11-4   不定。±Infのときはすべて0にしておかないとFLOAT4.Xが誤動作する
 10707:     //    bit3-0    整数部(BCD)、±0,±Infのときはすべて0、NaNのときはすべて1
 10708:     //  12
 10709:     //    bit63-0   小数部(BCD)、±0,±Infのときはすべて0、NaNのときはすべて1、ただしSNaNのときはbit63だけ0
 10710:     //
 10711:     //  k-factor
 10712:     //    -64..0   -小数点以下の桁数(%f)。0ではない先頭の数字から小数点以下-k桁目までの桁数(1桁以上17桁以下)を有効桁数とする
 10713:     //      1..17  有効桁数(%e)
 10714:     //     18..63  OPERR
 10715:     //
 10716:     public byte[] getp012 (byte[] b, int a) {
 10717:       return getp012 (b, a, 17);
 10718:     }  //efp.getp012(byte[],int)
 10719:     public byte[] getp012 (byte[] b, int a, int k) {
 10720:       int[] ib = getp012 (new int[3], 0, k);
 10721:       int i = ib[0];
 10722:       b[a] = (byte) (i >> 24);
 10723:       b[a + 1] = (byte) (i >> 16);
 10724:       b[a + 2] = (byte) (i >> 8);
 10725:       b[a + 3] = (byte) i;
 10726:       i = ib[1];
 10727:       b[a + 4] = (byte) (i >> 24);
 10728:       b[a + 5] = (byte) (i >> 16);
 10729:       b[a + 6] = (byte) (i >> 8);
 10730:       b[a + 7] = (byte) i;
 10731:       i = ib[2];
 10732:       b[a + 8] = (byte) (i >> 24);
 10733:       b[a + 9] = (byte) (i >> 16);
 10734:       b[a + 10] = (byte) (i >> 8);
 10735:       b[a + 11] = (byte) i;
 10736:       return b;
 10737:     }  //efp.getp012(byte[],int,int)
 10738:     public int[] getp012 (int[] ib, int ia) {
 10739:       return getp012 (ib, ia, 17);
 10740:     }  //efp.getp012(int[],int)
 10741:     public int[] getp012 (int[] ib, int ia, int k) {
 10742:       k = k << -7 >> -7;  //下位7bitを符号拡張する
 10743:       int u;
 10744:       long v;
 10745:       int xf = this.flg;
 10746:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 10747:         if (xf << 1 < 0) {  //±0
 10748:           u = xf & M;
 10749:           v = 0L;
 10750:         } else if (xf << 2 < 0) {  //±Inf
 10751:           u = (xf & M) | 0x7fff0000;
 10752:           v = 0L;
 10753:         } else {  //NaN
 10754:           u = 0x7fff0000;
 10755:           v = 0xffffffffffffffffL;
 10756:         }
 10757:       } else {  //±0,±Inf,NaN以外
 10758:         if (k > 17) {
 10759:           epbFpsr |= EPB_FPSR_OE;
 10760:           epbExceptionOperandExponent = this.flg & M | 0x3fff + this.epp << 16;
 10761:           epbExceptionOperandMantissa = this.dvl;
 10762:           k = 17;
 10763:         }
 10764:         //  2進数で仮数部が64桁のextendedは2^n*5^27を正確に表現できる
 10765:         //  10進数で仮数部が17桁のpackedは2^56*10^nを正確に表現できる
 10766:         //  どちらも正確に表現できる2^56*10^27=2^83*5^27のextendedとpackedの相互変換は誤差なしで行われなければならない
 10767:         //    2^56*10^27=72057594037927936000000000000000000000000000(44桁)
 10768:         //      extended  40900000CECB8F27F4200F3A
 10769:         //      packed    004300072057594037927936
 10770:         //  同様に2^56*10^34=2^90*5^34のtripleとpackedの相互変換は誤差なしで行われなければならない
 10771:         //    2^56*10^34=720575940379279360000000000000000000000000000000000(51桁)
 10772:         //      triple    40A7C732F684DF56C3E01BC6
 10773:         //      packed    005000072057594037927936
 10774:         int xe = this.epp;
 10775:         long xd = this.dvl;
 10776:         long xc = this.cvl;
 10777:         EFP x = new EFP (P, xe, xd, xc);  //絶対値のコピー
 10778:         int savedFpsr = epbFpsr;
 10779:         this.inner ();
 10780:         //10の指数を決める
 10781:         //  1.0*2^xe <= x < 2.0*2^xe
 10782:         //  1.0*10^(log10(2)*xe) <= x < 2.0*10^(log10(2)*xe)
 10783:         //  e=floor(log10(2)*xe)
 10784:         //  1.0*10^e <= x < 2.0*10^(e+1)
 10785:         //  1.0*10^e <= x < 20.0*10^e
 10786:         int e = (int) Math.floor (0.30102999566398119521373889472449302677 * xe);
 10787:         //整数部を0桁から20桁にする
 10788:         //  常に1桁まで割ってしまうとpackedで表現できる整数の処理中に端数が生じてX2がセットされてしまう
 10789:         if (e < 0) {  //10^-eを掛ける。結果は10^0<=x<2*10^1で整数部が1桁または2桁になる。誤差で0桁になる場合がある
 10790:           int o = -e;
 10791:           EFP t = new EFP (ONE);
 10792:           for (int i = 0; o != 0; i++, o >>>= 1) {
 10793:             if ((o & 1) != 0) {
 10794:               t.imul (EFP_TEN_POWER_P[i]);
 10795:             }
 10796:           }
 10797:           x.imul (t);
 10798:         } else if (e <= 18) {  //そのまま。10^0<=x<20*10^18で整数部は1桁から20桁
 10799:           e = 0;
 10800:         } else {  //10^(e-18)で割る。結果は10^18<=x<20*10^18で整数部が19桁または20桁になる。誤差で18桁になる場合がある
 10801:           int o = e -= 18;
 10802:           EFP t = new EFP (ONE);
 10803:           for (int i = 0; o != 0; i++, o >>>= 1) {
 10804:             if ((o & 1) != 0) {
 10805:               t.imul (EFP_TEN_POWER_P[i]);
 10806:             }
 10807:           }
 10808:           x.div (t);
 10809:         }
 10810:         //整数部を展開する
 10811:         //  最大65bitの整数を10000で割って16桁の商と4桁の余りに分けてそれぞれBCDに変換する
 10812:         //  20^10^18-1=0x1158E460913CFFFFF(65bit)
 10813:         u = 0;
 10814:         v = 0L;
 10815:         if (0 <= x.epp) {  //整数部が1..65bit
 10816:           //整数部をs,tに取り出す
 10817:           long s, t;
 10818:           if (x.epp <= 63) {  //1..64bit
 10819:             s = 0L;
 10820:             t = x.dvl >>> ~x.epp;
 10821:           } else {  //65bit
 10822:             s = 1L;  //最上位は1
 10823:             t = x.dvl << 1 | x.cvl >>> -1;
 10824:           }
 10825:           //最大65bitの整数を10000で割る
 10826:           long r = s << 32 | t >>> 32;  //上位の被除数
 10827:           s = r / 10000L;  //上位の商
 10828:           r = r - s * 10000L << 32 | t & 0xffffffffL;  //下位の被除数
 10829:           t = r / 10000L;  //下位の商
 10830:           v = XEiJ.FMT_BCD4[(int) (r - t * 10000L)];  //下位の余り→下位4桁
 10831:           t = XEiJ.fmtBcd16 (s << 32 | t);  //全体の商→上位16桁
 10832:           u = (int) (t >>> 48);
 10833:           v |= t << 16;
 10834:         }
 10835:         //小数部を展開する
 10836:         //  整数部が18桁以上になるまで小数部を10000倍して整数部を4桁のBCDに変換することを繰り返す
 10837:         while ((u & 0xfffffff0) == 0) {
 10838:           u = u << 16 | (int) (v >>> -16);
 10839:           v = v << 16 | XEiJ.FMT_BCD4[x.frac ().muli (10000).geti32abs ()];
 10840:           e -= 4;
 10841:         }
 10842:         long rest = x.frac ().iszero () ? 0L : 1L;  //k+2桁目以降の端数の有無
 10843:         this.outer ();
 10844:         epbFpsr = savedFpsr;
 10845:         //四捨五入する位を確認する
 10846:         //   lz(u)  >>>2  24-
 10847:         //  12..15     3   21
 10848:         //  16..19     4   20
 10849:         //  20..23     5   19
 10850:         //  24..27     6   18
 10851:         int w = 24 - (Integer.numberOfLeadingZeros (u) >>> 2);  //展開された桁数。18桁以上21桁以下
 10852:         //  w桁のBCD値がu:vの96bitに右寄せで格納されている
 10853:         //  値はw桁のBCD値*10^e
 10854:         if (k <= 0) {  //固定小数点形式のとき
 10855:           //  先頭の数字の左側は右からw桁の位置
 10856:           //  小数点は右から-e桁の位置
 10857:           //  小数点以下-k桁の数字の右側は右から-e+k桁の位置
 10858:           //  先頭から小数点以下-k桁までの桁数はw-(-e+k)桁
 10859:           k = Math.max (1, Math.min (17, w + e - k));
 10860:         }
 10861:         //k+2桁目以降の端数の有無を確認する
 10862:         int i = w - k - 1 << 2;  //k+1桁目の右から数えたbit位置
 10863:         if (0 < i) {  //k+2桁目が展開されている
 10864:           if (i < 64) {  //k+1桁目がvにある。k+2桁目以降はvの右端からvの途中まで
 10865:             long mask = -1L << i;
 10866:             rest |= v & ~mask;  //k+2桁目以降の端数の有無
 10867:             v &= mask;
 10868:           } else {  //k+1桁目がuにある。k+2桁目以降はvの全体のみまたはvの全体とuの右端から途中まで
 10869:             int mask = -1 << i - 64;
 10870:             rest |= (long) (u & ~mask) | v;  //k+2桁目以降の端数の有無
 10871:             u &= mask;
 10872:             v = 0L;
 10873:           }
 10874:         }
 10875:         //k+1桁目を四捨五入する
 10876:         int d = (i < 64 ? (int) (v >>> i) : u >>> i - 64) & 15;  //k+1桁目の数字
 10877:         if (d != 0 || rest != 0L) {  //k+1桁目以降に端数がある
 10878:           epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 10879:           epbExceptionOperandExponent = xf & M | 0x3fff + xe << 16;
 10880:           epbExceptionOperandMantissa = xd;
 10881:           if (i < 64) {
 10882:             v &= ~(15L << i);
 10883:           } else {
 10884:             u &= ~(15 << i);
 10885:           }
 10886:           i += 4;  //k桁目の右から数えたbit位置
 10887:           if ((epbRoundingMode == EPB_MODE_RN &&
 10888:                (5 < d ||  //k+1桁目以降に端数があってRNでk+1桁目が5より大きいか、
 10889:                 (d == 5 && (rest != 0L ||  //k+1桁目が5でk+2桁目以降に端数があるか、
 10890:                             ((i < 64 ? (int) (v >>> i) : u >>> i - 64) & 1) != 0)))) ||  //k+1桁目が5でk+2桁目以降に端数がなくてk桁目が奇数または
 10891:               (epbRoundingMode == EPB_MODE_RM && xf < 0) ||  //k+1桁目以降に端数があってRMで負または
 10892:               (epbRoundingMode == EPB_MODE_RP && 0 <= xf)) {  //k+1桁目以降に端数があってRPで正のとき切り上げる
 10893:             //k桁目が9のとき0に変えて切り上げる
 10894:             //  切り上げたときk-1桁目が9のとき0に変えて切り上げる
 10895:             //    先頭に0があるので必ず止まる
 10896:             while (((i < 64 ? (int) (v >>> i) : u >>> i - 64) & 15) == 9) {
 10897:               if (i < 64) {
 10898:                 v &= ~(15L << i);
 10899:               } else {
 10900:                 u &= ~(15 << i);
 10901:               }
 10902:               i += 4;
 10903:             }
 10904:             //9でなければ1を加える
 10905:             //  先頭の0が1に変わって1桁増える場合がある
 10906:             if (i < 64) {
 10907:               v += 1L << i;
 10908:             } else {
 10909:               u += 1 << i;
 10910:             }
 10911:           }  //切り上げる
 10912:         }  //if 端数がある
 10913:         //小数点の位置を合わせる
 10914:         w = 7 - (Integer.numberOfLeadingZeros (u) >>> 2);  //四捨五入した後の多すぎる小数点以下の桁数
 10915:         e += 16 + w;
 10916:         i = w << 2;  //多すぎるbit数
 10917:         v = (long) u << -i | v >>> i;
 10918:         u >>>= i - 64;
 10919:         //指数部を展開する
 10920:         if (e < 0) {
 10921:           u |= 0x40000000;  //指数部の符号
 10922:           e = -e;
 10923:         }
 10924:         e = XEiJ.fmtBcd8 (e);
 10925:         if ((e & ~0xfff) != 0) {  //指数部が3桁に収まっていない
 10926:           epbFpsr |= EPB_FPSR_OE;
 10927:           epbExceptionOperandExponent = xf & M | 0x3fff + xe << 16;
 10928:           epbExceptionOperandMantissa = xd;
 10929:         }
 10930:         u |= (e & 0xfff) << 16 | (e & 0xf000);
 10931:         //符号を付ける
 10932:         u |= xf & M;  //仮数部の符号
 10933:       }
 10934:       ib[ia] = u;
 10935:       ib[ia + 1] = (int) (v >> 32);
 10936:       ib[ia + 2] = (int) v;
 10937:       return ib;
 10938:     }  //efp.getp012(int[],int,int)
 10939: 
 10940:     //------------------------------------------------------------------------
 10941:     //i = x.gets ()
 10942:     //i = x.gets (roundingMode)
 10943:     //  short値
 10944:     //
 10945:     //  丸めモードを省略したときは小数点以下を切り捨てる(RZ)
 10946:     //  2^15-1よりも大きい数は2^15-1に、-2^15よりも小さい数は-2^15に変換する(飽和変換)
 10947:     //  NaNは-1に変換する
 10948:     //
 10949:     //  Javaのdoubleからshortへのキャストは飽和変換ではない(intに飽和変換してから下位16bitを取り出す)ことに注意
 10950:     //
 10951:     public int gets () {
 10952:       int xf = this.flg;
 10953:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 10954:         if (xf << 1 < 0) {  //±0
 10955:           return 0;
 10956:         } else if (xf << 2 < 0) {  //±Inf
 10957:           epbFpsr |= EPB_FPSR_OE;
 10958:           epbExceptionOperandExponent = xf & M | 0x7fff << 16;
 10959:           epbExceptionOperandMantissa = 0x0000000000000000L;
 10960:           return xf >> 31 ^ 0x00007fff;  //+Infは0x00007fff,-Infは0xffff8000
 10961:         } else {  //NaN
 10962:           epbFpsr |= EPB_FPSR_OE | EPB_FPSR_AV;
 10963:           epbExceptionOperandExponent = 0x7fff << 16;
 10964:           epbExceptionOperandMantissa = 0xffffffffffffffffL;
 10965:           return -1;  //NaNは-1
 10966:         }
 10967:       }
 10968:       //±0,±Inf,NaN以外
 10969:       int xe = this.epp;
 10970:       long xd = this.dvl;
 10971:       long xc = this.cvl;
 10972:       if (xe < 0) {  //0<|x|<1
 10973:         if (false) {
 10974:           epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 10975:           epbExceptionOperandExponent = xf | 0x3fff + xe << 16;
 10976:           epbExceptionOperandMantissa = xd;
 10977:         }
 10978:         return 0;
 10979:       }
 10980:       //1<=|x|
 10981:       if (xe < 15) {  //1<=|x|<2^15
 10982:         if (false) {
 10983:           if ((xd << 1 + xe | xc) != 0L) {  //端数がある
 10984:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 10985:             epbExceptionOperandExponent = xf | 0x3fff + xe << 16;
 10986:             epbExceptionOperandMantissa = xd;
 10987:           }
 10988:         }
 10989:         return xf >= 0 ? (int) (xd >>> ~xe) : -(int) (xd >>> ~xe);
 10990:       }
 10991:       //2^15<=|x|
 10992:       if (xf >= 0) {  //2^15<=x
 10993:         epbFpsr |= EPB_FPSR_OE;
 10994:         epbExceptionOperandExponent = 0x3fff + xe << 16;
 10995:         epbExceptionOperandMantissa = xd;
 10996:         return 0x00007fff;
 10997:       }
 10998:       //x<=-2^15
 10999:       if (xe != 15 || xd != MSB || xc != 0L) {  //x!=-2^15
 11000:         epbFpsr |= EPB_FPSR_OE;
 11001:         epbExceptionOperandExponent = M | 0x3fff + xe << 16;
 11002:         epbExceptionOperandMantissa = this.dvl;
 11003:       }
 11004:       return 0xffff8000;
 11005:     }  //efp.gets()
 11006:     public int gets (int roundingMode) {
 11007:       return (roundingMode == EPB_MODE_RN ? new EFP ().inner ().rint (this).outer ().gets () :
 11008:               roundingMode == EPB_MODE_RM ? new EFP ().inner ().floor (this).outer ().gets () :
 11009:               roundingMode == EPB_MODE_RP ? new EFP ().inner ().ceil (this).outer ().gets () :
 11010:               new EFP ().inner ().trunc (this).outer ().gets ());
 11011:     }  //efp.gets(int)
 11012: 
 11013:     //------------------------------------------------------------------------
 11014:     //i = x.getx0 ()
 11015:     //i = x.getx0 (roundingMode)
 11016:     //l = x.getx12 ()
 11017:     //l = x.getx12 (roundingMode)
 11018:     //b = x.getx012 (b, a)
 11019:     //b = x.getx012 (b, a, roundingMode)
 11020:     //ib = x.getx012 (ib, ia)
 11021:     //ib = x.getx012 (ib, ia, roundingMode)
 11022:     //  extended値
 11023:     //
 11024:     //         0          1       2
 11025:     //    0x7fff0000,0xffffffffffffffffL  Non-Signaling NaN
 11026:     //    0x7fff0000,0xbfffffffffffffffL  Signaling NaN
 11027:     //    0x7fff0000,0x0000000000000000L  +Inf
 11028:     //    0x7ffe0000,0xffffffffffffffffL  2^16384-2^16320   = 1.1897314953572317650212638530309702052 E4932   正規化数の最大値
 11029:     //    0x3fff0000,0x8000000000000000L  2^0               = 1
 11030:     //    0x00000000,0x8000000000000000L  2^-16383          = 1.6810515715560467531313389086608763013 E-4932  正規化数の最小値
 11031:     //    0x00000000,0x7fffffffffffffffL  2^-16383-2^-16446 = 1.6810515715560467529490789320667525712 E-4932  非正規化数の最大値
 11032:     //    0x00000000,0x0000000000000001L  2^-16446          = 1.8225997659412373012642029668097099082 E-4951  非正規化数の最小値
 11033:     //    0x00000000,0x0000000000000000L  +0
 11034:     //    NaNの符号はDon't Care、出力は0
 11035:     //    NaNの整数部はDon't Care、出力は1
 11036:     //    Non-Signaling NaNの小数部の先頭は1
 11037:     //    Signaling NaNの小数部の先頭は0
 11038:     //      Signaling NaNが返ることはない
 11039:     //    NaNの小数部の先頭以外はNon-Zero、出力はすべて1
 11040:     //    ±Infの整数部はDon't Care、出力は0
 11041:     //    ±Infの小数部はすべて0
 11042:     //    正規化数の整数部は1
 11043:     //    非正規化数の整数部は0
 11044:     //
 11045:     //  メモ
 11046:     //    M68000PRMとMC68881UMにはextendedの正規化数の最大値と正規化数の最小値と非正規化数の最小値の記述が間違っているものがある
 11047:     //
 11048:     public final int getx0 () {
 11049:       int[] ib = getx012 (new int[3], 0, EPB_MODE_RN);
 11050:       return ib[0];
 11051:     }  //efp.getx0()
 11052:     public final int getx0 (int roundingMode) {
 11053:       int[] ib = getx012 (new int[3], 0, roundingMode);
 11054:       return ib[0];
 11055:     }  //efp.getx0(int)
 11056:     public final long getx12 () {
 11057:       int[] ib = getx012 (new int[3], 0, EPB_MODE_RN);
 11058:       return (long) ib[1] << 32 | (0xffffffffL & ib[2]);
 11059:     }  //efp.getx12()
 11060:     public final long getx12 (int roundingMode) {
 11061:       int[] ib = getx012 (new int[3], 0, roundingMode);
 11062:       return (long) ib[1] << 32 | (0xffffffffL & ib[2]);
 11063:     }  //efp.getx12(int)
 11064:     public final byte[] getx012 (byte[] b, int a) {
 11065:       return getx012 (b, a, EPB_MODE_RN);
 11066:     }  //efp.getx012(byte[],int)
 11067:     public final byte[] getx012 (byte[] b, int a, int roundingMode) {
 11068:       int[] ib = getx012 (new int[3], 0, roundingMode);
 11069:       int i = ib[0];
 11070:       b[a] = (byte) (i >> 24);
 11071:       b[a + 1] = (byte) (i >> 16);
 11072:       b[a + 2] = (byte) (i >> 8);
 11073:       b[a + 3] = (byte) i;
 11074:       i = ib[1];
 11075:       b[a + 4] = (byte) (i >> 24);
 11076:       b[a + 5] = (byte) (i >> 16);
 11077:       b[a + 6] = (byte) (i >> 8);
 11078:       b[a + 7] = (byte) i;
 11079:       i = ib[2];
 11080:       b[a + 8] = (byte) (i >> 24);
 11081:       b[a + 9] = (byte) (i >> 16);
 11082:       b[a + 10] = (byte) (i >> 8);
 11083:       b[a + 11] = (byte) i;
 11084:       return b;
 11085:     }  //efp.getx012(byte[],int,int)
 11086:     public final int[] getx012 (int[] ib, int ia) {
 11087:       return this.getx012 (ib, ia, EPB_MODE_RN);
 11088:     }  //efp.getx012(int[],int)
 11089:     public final int[] getx012 (int[] ib, int ia, int roundingMode) {
 11090:       int xf = this.flg;
 11091:       int xe = this.epp;  //正規化数は-16383<=xe<=16383、非正規化数は-16446<=xe<=-16384
 11092:       long xd = this.dvl;
 11093:       long xc = this.cvl;
 11094:     xfxd:
 11095:       {
 11096:         if (xf << 1 != 0) {  //±0,±Inf,NaN
 11097:           if (xf << 1 < 0) {  //±0
 11098:             xf &= M;  //符号部1bit、指数部15bit、空き16bit
 11099:             xd = 0x0000000000000000L;  //整数部1bit、小数部63bit
 11100:           } else if (xf << 2 < 0) {  //±Inf
 11101:             xf = (xf & M) | 0x7fff0000;  //符号部1bit、指数部15bit、空き16bit
 11102:             xd = 0x0000000000000000L;  //整数部1bit、小数部63bit
 11103:           } else {  //NaN
 11104:             xf = 0x7fff0000;  //符号部1bit、指数部15bit、空き16bit
 11105:             xd = 0xffffffffffffffffL;  //整数部1bit、小数部63bit
 11106:           }
 11107:           break xfxd;
 11108:         }
 11109:         //±0,±Inf,NaN以外
 11110:         if (xe < -16447) {  //指数部が小さすぎる。非正規化数の最小値は2^-16446だが丸めで繰り上がる場合があるので一旦2^-16447まで受け入れる
 11111:           epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 11112:           epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 11113:           epbExceptionOperandMantissa = xd;
 11114:           if (0 <= xf) {  //+x
 11115:             if (roundingMode == EPB_MODE_RP) {  //RPのとき+eps
 11116:               xf = 0x00000000;  //符号部1bit、指数部15bit、空き16bit
 11117:               xd = 0x0000000000000001L;  //整数部1bit、小数部63bit
 11118:             } else {  //RN,RZ,RMのとき+0
 11119:               xf = 0x00000000;  //符号部1bit、指数部15bit、空き16bit
 11120:               xd = 0x0000000000000000L;  //整数部1bit、小数部63bit
 11121:             }
 11122:           } else {  //-x
 11123:             if (roundingMode == EPB_MODE_RM) {  //RMのとき-eps
 11124:               xf = 0x80000000;  //符号部1bit、指数部15bit、空き16bit
 11125:               xd = 0x0000000000000001L;  //整数部1bit、小数部63bit
 11126:             } else {  //RN,RZ,RPのとき-0
 11127:               xf = 0x80000000;  //符号部1bit、指数部15bit、空き16bit
 11128:               xd = 0x0000000000000000L;  //整数部1bit、小数部63bit
 11129:             }
 11130:           }
 11131:           break xfxd;
 11132:         }
 11133:         if (16383 < xe) {  //指数部が大きすぎる
 11134:           if (true) {
 11135:             epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 11136:             if (xc != 0L) {  //端数が0ではない
 11137:               epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 11138:             }
 11139:           } else {
 11140:             epbFpsr |= EPB_FPSR_OF | EPB_FPSR_X2;  //オーバーフロー、不正確な結果
 11141:           }
 11142:           epbExceptionOperandExponent = xf | 0x3fff - 0x6000 + xe << 16;
 11143:           epbExceptionOperandMantissa = xd;
 11144:           if (0 <= xf) {  //+x
 11145:             if (roundingMode == EPB_MODE_RM) {  //RMのとき+max
 11146:               xf = 0x7ffe0000;  //符号部1bit、指数部15bit、空き16bit
 11147:               xd = 0xffffffffffffffffL;  //整数部1bit、小数部63bit
 11148:             } else {  //RN,RZ,RPのとき+Inf
 11149:               xf = 0x7fff0000;  //符号部1bit、指数部15bit、空き16bit
 11150:               xd = 0x0000000000000000L;  //整数部1bit、小数部63bit
 11151:             }
 11152:           } else {  //-x
 11153:             if (roundingMode == EPB_MODE_RP) {  //RPのとき-max
 11154:               xf = 0xfffe0000;  //符号部1bit、指数部15bit、空き16bit
 11155:               xd = 0xffffffffffffffffL;  //整数部1bit、小数部63bit
 11156:             } else {  //RN,RZ,RMのとき-Inf
 11157:               xf = 0xffff0000;  //符号部1bit、指数部15bit、空き16bit
 11158:               xd = 0x0000000000000000L;  //整数部1bit、小数部63bit
 11159:             }
 11160:           }
 11161:           break xfxd;
 11162:         }
 11163:         long xb = 0L;
 11164:         int o = xe <= -16384 ? 0 + -16383 - xe : 0;  //右にずらすbit数。正規化数は0、非正規化数は0+1<=o<=0+64
 11165:         if (o == 0) {
 11166:         } else if (o < 64) {
 11167:           xb = xc << -o;
 11168:           xc = xd << -o | xc >>> o;
 11169:           xd >>>= o;
 11170:         } else {
 11171:           xb = xc;
 11172:           xc = xd;
 11173:           xd = 0L;
 11174:         }
 11175:         if ((xc | xb) != 0L) {  //端数が0ではない
 11176:           epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 11177:           if (roundingMode == EPB_MODE_RN && xc < 0L && (xd << 63 | xc << 1 | xb) != 0L ||  //RNでguard bitが1かつLSBまたはguard bit以外の端数が0ではないまたは
 11178:               roundingMode == EPB_MODE_RM && xf < 0 ||  //端数が0ではなくてRMで-または
 11179:               roundingMode == EPB_MODE_RP && 0 <= xf) {  //端数が0ではなくてRPで+のとき
 11180:             xd++;  //繰り上げる
 11181:             if (xd == 0L) {  //繰り上がって溢れたとき
 11182:               xd = MSB;
 11183:               xe++;  //指数部をインクリメントする。ここでxe=16384になる場合がある
 11184:               if (16383 < xe) {  //指数部が大きすぎる
 11185:                 epbFpsr |= EPB_FPSR_OF | EPB_FPSR_X2;  //オーバーフロー、不正確な結果
 11186:                 epbExceptionOperandExponent = xf | 0x3fff - 0x6000 + xe << 16;
 11187:                 epbExceptionOperandMantissa = xd;
 11188:                 if (0 <= xf) {  //+x
 11189:                   if (roundingMode == EPB_MODE_RM) {  //RMのとき+max
 11190:                     xf = 0x7ffe0000;  //符号部1bit、指数部15bit、空き16bit
 11191:                     xd = 0xffffffffffffffffL;  //整数部1bit、小数部63bit
 11192:                   } else {  //RN,RZ,RPのとき+Inf
 11193:                     xf = 0x7fff0000;  //符号部1bit、指数部15bit、空き16bit
 11194:                     xd = 0x0000000000000000L;  //整数部1bit、小数部63bit
 11195:                   }
 11196:                 } else {  //-x
 11197:                   if (roundingMode == EPB_MODE_RP) {  //RPのとき-max
 11198:                     xf = 0xfffe0000;  //符号部1bit、指数部15bit、空き16bit
 11199:                     xd = 0xffffffffffffffffL;  //整数部1bit、小数部63bit
 11200:                   } else {  //RN,RZ,RMのとき-Inf
 11201:                     xf = 0xffff0000;  //符号部1bit、指数部15bit、空き16bit
 11202:                     xd = 0x0000000000000000L;  //整数部1bit、小数部63bit
 11203:                   }
 11204:                 }
 11205:                 break xfxd;
 11206:               }  //if 指数部が大きすぎる
 11207:             } else if (0 < o) {  //非正規化数のとき
 11208:               if (xd << o - 1 < 0L) {  //1bit増えたとき
 11209:                 xe++;  //指数部をインクリメントする
 11210: /* getx012
 11211:                 if (xe == -16383) {  //非正規化数が繰り上がって正規化数になったとき
 11212:                   //xd = 1L << 15;
 11213:                   epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 11214:                   epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 11215:                   epbExceptionOperandMantissa = xd;
 11216:                 }
 11217: */
 11218:               }
 11219:             }
 11220:           }
 11221:           //RZ toward zeroのときは端数を切り捨てるだけなので何もしなくてよい
 11222:           if (xe <= -16384) {  //非正規化数
 11223:             epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 11224:             epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 11225:             epbExceptionOperandMantissa = xd;
 11226:             if (xd == 0L) {  //非正規化数でxe==-16447だったとき、先頭の1がxcにあって丸めで繰り上がらなかった
 11227:               if (0 <= xf) {  //+x
 11228:                 if (roundingMode == EPB_MODE_RP) {  //RPのとき+eps
 11229:                   xf = 0x00000000;  //符号部1bit、指数部15bit、空き16bit
 11230:                   xd = 0x0000000000000001L;  //整数部1bit、小数部63bit
 11231:                 } else {  //RN,RZ,RMのとき+0
 11232:                   xf = 0x00000000;  //符号部1bit、指数部15bit、空き16bit
 11233:                   xd = 0x0000000000000000L;  //整数部1bit、小数部63bit
 11234:                 }
 11235:               } else {  //-x
 11236:                 if (roundingMode == EPB_MODE_RM) {  //RMのとき-eps
 11237:                   xf = 0x80000000;  //符号部1bit、指数部15bit、空き16bit
 11238:                   xd = 0x0000000000000001L;  //整数部1bit、小数部63bit
 11239:                 } else {  //RN,RZ,RPのとき-0
 11240:                   xf = 0x80000000;  //符号部1bit、指数部15bit、空き16bit
 11241:                   xd = 0x0000000000000000L;  //整数部1bit、小数部63bit
 11242:                 }
 11243:               }
 11244:               break xfxd;
 11245:             }
 11246:           }  //if 非正規化数
 11247:         } else {  //端数が0
 11248:           if (xe <= -16384) {  //非正規化数
 11249:             epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 11250:             epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 11251:             epbExceptionOperandMantissa = xd;
 11252:             if (xd == 0L) {  //非正規化数でxe==-16447だったとき、先頭の1がxcにあって丸めで繰り上がらなかった
 11253:               if (0 <= xf) {  //+x
 11254:                 if (roundingMode == EPB_MODE_RP) {  //RPのとき+eps
 11255:                   xf = 0x00000000;  //符号部1bit、指数部15bit、空き16bit
 11256:                   xd = 0x0000000000000001L;  //整数部1bit、小数部63bit
 11257:                 } else {  //RN,RZ,RMのとき+0
 11258:                   xf = 0x00000000;  //符号部1bit、指数部15bit、空き16bit
 11259:                   xd = 0x0000000000000000L;  //整数部1bit、小数部63bit
 11260:                 }
 11261:               } else {  //-x
 11262:                 if (roundingMode == EPB_MODE_RM) {  //RMのとき-eps
 11263:                   xf = 0x80000000;  //符号部1bit、指数部15bit、空き16bit
 11264:                   xd = 0x0000000000000001L;  //整数部1bit、小数部63bit
 11265:                 } else {  //RN,RZ,RPのとき-0
 11266:                   xf = 0x80000000;  //符号部1bit、指数部15bit、空き16bit
 11267:                   xd = 0x0000000000000000L;  //整数部1bit、小数部63bit
 11268:                 }
 11269:               }
 11270:               break xfxd;
 11271:             }
 11272:           }  //if 非正規化数
 11273:         }  //if 端数が0ではない/端数が0
 11274:         xf |= Math.max (0, 16383 + xe) << 16;  //符号とバイアスを加えた指数部
 11275:       }  //xfxd
 11276:       //結果
 11277:       ib[ia] = xf;
 11278:       ib[ia + 1] = (int) (xd >> 32);
 11279:       ib[ia + 2] = (int) xd;
 11280:       return ib;
 11281:     }  //efp.getx012(int[],int,int)
 11282: 
 11283:     //------------------------------------------------------------------------
 11284:     //i = x.gety0 ()
 11285:     //i = x.gety0 (roundingMode)
 11286:     //l = x.gety12 ()
 11287:     //l = x.gety12 (roundingMode)
 11288:     //b = x.gety012 (b, a)
 11289:     //b = x.gety012 (b, a, roundingMode)
 11290:     //ib = x.gety012 (ib, ia)
 11291:     //ib = x.gety012 (ib, ia, roundingMode)
 11292:     //  triple値
 11293:     //
 11294:     //         0          1       2
 11295:     //    0x7fffffff,0xffffffffffffffffL  Non-Signaling NaN
 11296:     //    0x7fffffff,0xbfffffffffffffffL  Signaling NaN
 11297:     //    0x7fff0000,0x0000000000000000L  +Inf
 11298:     //    0x7ffeffff,0xffffffffffffffffL  2^16384-2^16304   = 1.1897314953572317650857583425051800275 E4932   正規化数の最大値
 11299:     //    0x3fff0000,0x8000000000000000L  2^0               = 1
 11300:     //    0x00000000,0x8000000000000000L  2^-16383          = 1.6810515715560467531313389086608763013 E-4932  正規化数の最小値
 11301:     //    0x0000ffff,0x7fffffffffffffffL  2^-16383-2^-16462 = 1.6810515715560467531313361275943389154 E-4932  非正規化数の最大値
 11302:     //    0x00000001,0x0000000000000000L  2^-16462          = 2.7810665373859211750247237652736052066 E-4956  非正規化数の最小値
 11303:     //    0x00000000,0x0000000000000000L  +0
 11304:     //    NaNの符号はDon't Care、出力は0
 11305:     //    NaNの整数部はDon't Care、出力は1
 11306:     //    Non-Signaling NaNの小数部の先頭は1
 11307:     //    Signaling NaNの小数部の先頭は0
 11308:     //      Signaling NaNが返ることはない
 11309:     //    NaNの小数部の先頭以外はNon-Zero、出力はすべて1
 11310:     //    ±Infの整数部はDon't Care、出力は0
 11311:     //    ±Infの小数部はすべて0
 11312:     //    正規化数の整数部は1
 11313:     //    非正規化数の整数部は0
 11314:     //
 11315:     public final int gety0 () {
 11316:       int[] ib = gety012 (new int[3], 0, EPB_MODE_RN);
 11317:       return ib[0];
 11318:     }  //efp.gety0()
 11319:     public final int gety0 (int roundingMode) {
 11320:       int[] ib = gety012 (new int[3], 0, roundingMode);
 11321:       return ib[0];
 11322:     }  //efp.gety0(int)
 11323:     public final long gety12 () {
 11324:       int[] ib = gety012 (new int[3], 0, EPB_MODE_RN);
 11325:       return (long) ib[1] << 32 | (0xffffffffL & ib[2]);
 11326:     }  //efp.gety12()
 11327:     public final long gety12 (int roundingMode) {
 11328:       int[] ib = gety012 (new int[3], 0, roundingMode);
 11329:       return (long) ib[1] << 32 | (0xffffffffL & ib[2]);
 11330:     }  //efp.gety12(int)
 11331:     public final byte[] gety012 (byte[] b, int a) {
 11332:       return gety012 (b, a, EPB_MODE_RN);
 11333:     }  //efp.gety012(byte[],int)
 11334:     public final byte[] gety012 (byte[] b, int a, int roundingMode) {
 11335:       int[] ib = gety012 (new int[3], 0, roundingMode);
 11336:       int i = ib[0];
 11337:       b[a] = (byte) (i >> 24);
 11338:       b[a + 1] = (byte) (i >> 16);
 11339:       b[a + 2] = (byte) (i >> 8);
 11340:       b[a + 3] = (byte) i;
 11341:       i = ib[1];
 11342:       b[a + 4] = (byte) (i >> 24);
 11343:       b[a + 5] = (byte) (i >> 16);
 11344:       b[a + 6] = (byte) (i >> 8);
 11345:       b[a + 7] = (byte) i;
 11346:       i = ib[2];
 11347:       b[a + 8] = (byte) (i >> 24);
 11348:       b[a + 9] = (byte) (i >> 16);
 11349:       b[a + 10] = (byte) (i >> 8);
 11350:       b[a + 11] = (byte) i;
 11351:       return b;
 11352:     }  //efp.gety012(byte[],int,int)
 11353:     public final int[] gety012 (int[] ib, int ia) {
 11354:       return this.gety012 (ib, ia, EPB_MODE_RN);
 11355:     }  //efp.gety012(int[],int)
 11356:     public final int[] gety012 (int[] ib, int ia, int roundingMode) {
 11357:       int xf = this.flg;
 11358:       int xe = this.epp;  //正規化数は-16383<=xe<=16383、非正規化数は-16462<=xe<=-16384
 11359:       long xd = this.dvl;
 11360:       long xc = this.cvl;
 11361:     xfxd:
 11362:       {
 11363:         if (xf << 1 != 0) {  //±0,±Inf,NaN
 11364:           if (xf << 1 < 0) {  //±0
 11365:             xf &= M;  //符号部1bit、指数部15bit、小数部の下位16bit
 11366:             xd = 0x0000000000000000L;  //整数部1bit、小数部の上位63bit
 11367:           } else if (xf << 2 < 0) {  //±Inf
 11368:             xf = (xf & M) | 0x7fff0000;  //符号部1bit、指数部15bit、小数部の下位16bit
 11369:             xd = 0x0000000000000000L;  //整数部1bit、小数部の上位63bit
 11370:           } else {  //NaN
 11371:             xf = 0x7fffffff;  //符号部1bit、指数部15bit、小数部の下位16bit
 11372:             xd = 0xffffffffffffffffL;  //整数部1bit、小数部の上位63bit
 11373:           }
 11374:           break xfxd;
 11375:         }
 11376:         //±0,±Inf,NaN以外
 11377:         if (xe < -16463) {  //指数部が小さすぎる。非正規化数の最小値は2^-16462だが丸めで繰り上がる場合があるので一旦2^-16463まで受け入れる
 11378:           epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 11379:           epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 11380:           epbExceptionOperandMantissa = xd;
 11381:           if (0 <= xf) {  //+x
 11382:             if (roundingMode == EPB_MODE_RP) {  //RPのとき+eps
 11383:               xf = 0x00000001;  //符号部1bit、指数部15bit、小数部の下位16bit
 11384:               xd = 0x0000000000000000L;  //整数部1bit、小数部の上位63bit
 11385:             } else {  //RN,RZ,RMのとき+0
 11386:               xf = 0x00000000;  //符号部1bit、指数部15bit、小数部の下位16bit
 11387:               xd = 0x0000000000000000L;  //整数部1bit、小数部の上位63bit
 11388:             }
 11389:           } else {  //-x
 11390:             if (roundingMode == EPB_MODE_RM) {  //RMのとき-eps
 11391:               xf = 0x80000001;  //符号部1bit、指数部15bit、小数部の下位16bit
 11392:               xd = 0x0000000000000000L;  //整数部1bit、小数部の上位63bit
 11393:             } else {  //RN,RZ,RPのとき-0
 11394:               xf = 0x80000000;  //符号部1bit、指数部15bit、小数部の下位16bit
 11395:               xd = 0x0000000000000000L;  //整数部1bit、小数部の上位63bit
 11396:             }
 11397:           }
 11398:           break xfxd;
 11399:         }
 11400:         if (16383 < xe) {  //指数部が大きすぎる
 11401:           if (true) {
 11402:             epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 11403:             if (xc << 16 != 0L) {  //端数が0ではない
 11404:               epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 11405:             }
 11406:           } else {
 11407:             epbFpsr |= EPB_FPSR_OF | EPB_FPSR_X2;  //オーバーフロー、不正確な結果
 11408:           }
 11409:           epbExceptionOperandExponent = xf | 0x3fff - 0x6000 + xe << 16;
 11410:           epbExceptionOperandMantissa = xd;
 11411:           if (0 <= xf) {  //+x
 11412:             if (roundingMode == EPB_MODE_RM) {  //RMのとき+max
 11413:               xf = 0x7ffeffff;  //符号部1bit、指数部15bit、小数部の下位16bit
 11414:               xd = 0xffffffffffffffffL;  //整数部1bit、小数部の上位63bit
 11415:             } else {  //RN,RZ,RPのとき+Inf
 11416:               xf = 0x7fff0000;  //符号部1bit、指数部15bit、小数部の下位16bit
 11417:               xd = 0x0000000000000000L;  //整数部1bit、小数部の上位63bit
 11418:             }
 11419:           } else {  //-x
 11420:             if (roundingMode == EPB_MODE_RP) {  //RPのとき-max
 11421:               xf = 0xfffeffff;  //符号部1bit、指数部15bit、小数部の下位16bit
 11422:               xd = 0xffffffffffffffffL;  //整数部1bit、小数部の上位63bit
 11423:             } else {  //RN,RZ,RMのとき-Inf
 11424:               xf = 0xffff0000;  //符号部1bit、指数部15bit、小数部の下位16bit
 11425:               xd = 0x0000000000000000L;  //整数部1bit、小数部の上位63bit
 11426:             }
 11427:           }
 11428:           break xfxd;
 11429:         }
 11430:         long xb = 0L;
 11431:         long xa = 0L;
 11432:         int o = xe <= -16384 ? 48 + -16383 - xe : 48;  //右にずらすbit数。正規化数は48、非正規化数は48+1<=o<=48+80
 11433:         if (o < 64) {
 11434:           xb = xc << -o;
 11435:           xc = xd << -o | xc >>> o;
 11436:           xd >>>= o;
 11437:         } else if (o == 64) {
 11438:           xb = xc;
 11439:           xc = xd;
 11440:           xd = 0L;
 11441:         } else if (o < 128) {
 11442:           xa = xc << -o;
 11443:           xb = xd << -o | xc >>> o;
 11444:           xc = xd >>> o;
 11445:           xd = 0L;
 11446:         } else {
 11447:           xa = xc;
 11448:           xb = xd;
 11449:           xc = 0L;
 11450:           xd = 0L;
 11451:         }
 11452:         if ((xb | xa) != 0L) {  //端数が0ではない
 11453:           epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 11454:           if (roundingMode == EPB_MODE_RN && xb < 0L && (xc << 63 | xb << 1 | xa) != 0L ||  //RNでguard bitが1かつLSBまたはguard bit以外の端数が0ではないまたは
 11455:               roundingMode == EPB_MODE_RM && xf < 0 ||  //端数が0ではなくてRMで-または
 11456:               roundingMode == EPB_MODE_RP && 0 <= xf) {  //端数が0ではなくてRPで+のとき
 11457:             xc++;  //繰り上げる
 11458:             if (xc == 0L) {  //繰り上がって溢れたとき
 11459:               xd++;  //繰り上げる
 11460:               if (xd >>> 16 != 0L) {  //繰り上がって溢れたとき
 11461:                 //xd = 1L << 15;
 11462:                 xe++;  //指数部をインクリメントする。ここでxe=16384になる場合がある
 11463:                 if (16383 < xe) {  //指数部が大きすぎる
 11464:                   epbFpsr |= EPB_FPSR_OF | EPB_FPSR_X2;  //オーバーフロー、不正確な結果
 11465:                   epbExceptionOperandExponent = xf | 0x3fff - 0x6000 + xe << 16;
 11466:                   epbExceptionOperandMantissa = xd;
 11467:                   if (0 <= xf) {  //+x
 11468:                     if (roundingMode == EPB_MODE_RM) {  //RMのとき+max
 11469:                       xf = 0x7ffeffff;  //符号部1bit、指数部15bit、小数部の下位16bit
 11470:                       xd = 0xffffffffffffffffL;  //整数部1bit、小数部の上位63bit
 11471:                     } else {  //RN,RZ,RPのとき+Inf
 11472:                       xf = 0x7fff0000;  //符号部1bit、指数部15bit、小数部の下位16bit
 11473:                       xd = 0x0000000000000000L;  //整数部1bit、小数部の上位63bit
 11474:                     }
 11475:                   } else {  //-x
 11476:                     if (roundingMode == EPB_MODE_RP) {  //RPのとき-max
 11477:                       xf = 0xfffeffff;  //符号部1bit、指数部15bit、小数部の下位16bit
 11478:                       xd = 0xffffffffffffffffL;  //整数部1bit、小数部の上位63bit
 11479:                     } else {  //RN,RZ,RMのとき-Inf
 11480:                       xf = 0xffff0000;  //符号部1bit、指数部15bit、小数部の下位16bit
 11481:                       xd = 0x0000000000000000L;  //整数部1bit、小数部の上位63bit
 11482:                     }
 11483:                   }
 11484:                   break xfxd;
 11485:                 }  //if 指数部が大きすぎる
 11486:               } else if (48 < o) {  //非正規化数のとき
 11487:                 if (xd << o - 1 < 0L) {  //1bit増えたとき
 11488:                   xe++;  //指数部をインクリメントする
 11489: /* gety012
 11490:                   if (xe == -16383) {  //非正規化数が繰り上がって正規化数になったとき
 11491:                     //xd = 1L << 15;
 11492:                     epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 11493:                     epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 11494:                     epbExceptionOperandMantissa = xd;
 11495:                   }
 11496: */
 11497:                 }
 11498:               }
 11499:             }
 11500:           }
 11501:           //RZ toward zeroのときは端数を切り捨てるだけなので何もしなくてよい
 11502:           if (xe <= -16384) {  //非正規化数
 11503:             epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 11504:             epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 11505:             epbExceptionOperandMantissa = xd;
 11506:             if ((xd | xc) == 0L) {  //非正規化数でxe==-16463だったとき、先頭の1がxbにあって丸めで繰り上がらなかった
 11507:               if (0 <= xf) {  //+x
 11508:                 if (roundingMode == EPB_MODE_RP) {  //RPのとき+eps
 11509:                   xf = 0x00000001;  //符号部1bit、指数部15bit、小数部の下位16bit
 11510:                   xd = 0x0000000000000000L;  //整数部1bit、小数部の上位63bit
 11511:                 } else {  //RN,RZ,RMのとき+0
 11512:                   xf = 0x00000000;  //符号部1bit、指数部15bit、小数部の下位16bit
 11513:                   xd = 0x0000000000000000L;  //整数部1bit、小数部の上位63bit
 11514:                 }
 11515:               } else {  //-x
 11516:                 if (roundingMode == EPB_MODE_RM) {  //RMのとき-eps
 11517:                   xf = 0x80000001;  //符号部1bit、指数部15bit、小数部の下位16bit
 11518:                   xd = 0x0000000000000000L;  //整数部1bit、小数部の上位63bit
 11519:                 } else {  //RN,RZ,RPのとき-0
 11520:                   xf = 0x80000000;  //符号部1bit、指数部15bit、小数部の下位16bit
 11521:                   xd = 0x0000000000000000L;  //整数部1bit、小数部の上位63bit
 11522:                 }
 11523:               }
 11524:               break xfxd;
 11525:             }
 11526:           }  //if 非正規化数
 11527:         } else {  //端数が0
 11528:           if (xe <= -16384) {  //非正規化数
 11529:             epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 11530:             epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 11531:             epbExceptionOperandMantissa = xd;
 11532:             if ((xd | xc) == 0L) {  //非正規化数でxe==-16463だったとき、先頭の1がxbにあって丸めで繰り上がらなかった
 11533:               if (0 <= xf) {  //+x
 11534:                 if (roundingMode == EPB_MODE_RP) {  //RPのとき+eps
 11535:                   xf = 0x00000001;  //符号部1bit、指数部15bit、小数部の下位16bit
 11536:                   xd = 0x0000000000000000L;  //整数部1bit、小数部の上位63bit
 11537:                 } else {  //RN,RZ,RMのとき+0
 11538:                   xf = 0x00000000;  //符号部1bit、指数部15bit、小数部の下位16bit
 11539:                   xd = 0x0000000000000000L;  //整数部1bit、小数部の上位63bit
 11540:                 }
 11541:               } else {  //-x
 11542:                 if (roundingMode == EPB_MODE_RM) {  //RMのとき-eps
 11543:                   xf = 0x80000001;  //符号部1bit、指数部15bit、小数部の下位16bit
 11544:                   xd = 0x0000000000000000L;  //整数部1bit、小数部の上位63bit
 11545:                 } else {  //RN,RZ,RPのとき-0
 11546:                   xf = 0x80000000;  //符号部1bit、指数部15bit、小数部の下位16bit
 11547:                   xd = 0x0000000000000000L;  //整数部1bit、小数部の上位63bit
 11548:                 }
 11549:               }
 11550:               break xfxd;
 11551:             }
 11552:           }  //if 非正規化数
 11553:         }  //if 端数が0ではない/端数が0
 11554:         xd = xd << 48 | xc >>> -48;
 11555:         xc <<= 48;
 11556:         xf |= Math.max (0, 16383 + xe) << 16;  //符号とバイアスを加えた指数部
 11557:       }  //xfxd
 11558:       //結果
 11559:       ib[ia] = xf | (int) (xc >> 48);
 11560:       ib[ia + 1] = (int) (xd >> 32);
 11561:       ib[ia + 2] = (int) xd;
 11562:       return ib;
 11563:     }  //efp.gety012(byte[],int,int)
 11564: 
 11565:     //------------------------------------------------------------------------
 11566:     //b = x.gt (y)
 11567:     //  b=x>y
 11568:     //  より大きいか
 11569:     //
 11570:     //  -Inf==-Inf<-x<-0==+0<+x<+Inf==+Inf
 11571:     //
 11572:     //  NaNの扱い
 11573:     //    どちらかがNaNのときはfalseを返す
 11574:     //
 11575:     public boolean gt (EFP y) {
 11576:       int xf = this.flg;
 11577:       int yf = y.flg;
 11578:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
 11579:         return EFP_GT_TABLE[xf >>> 28] << (yf >>> 28 - 1) < 0;
 11580:       }
 11581:       //両方±0,±Inf,NaN以外
 11582:       if (xf != yf) {  //両方±0,±Inf,NaN以外で符号が違う
 11583:         return xf > yf;
 11584:       }
 11585:       //両方±0,±Inf,NaN以外で符号が同じ
 11586:       int s;
 11587:       long t;
 11588:       return (xf >= 0 ? 1 : -1) * ((s = this.epp - y.epp) != 0 ? s >= 0 ? 1 : -1 :
 11589:                                    (t = this.dvl - y.dvl) != 0L ? t >= 0L ? 1 : -1 :
 11590:                                    (t = (this.cvl >>> 1) - (y.cvl >>> 1)) != 0L ? t >= 0L ? 1 : -1 :
 11591:                                    0) > 0;
 11592:     }  //efp.gt(EFP)
 11593: 
 11594:     //------------------------------------------------------------------------
 11595:     //i = x.hashCode ()
 11596:     //  ハッシュコード
 11597:     //
 11598:     //  equalsであるオブジェクトはhashCodeが同じでなければならない
 11599:     //  equalsでないオブジェクトはhashCodeがなるべく違う方がよい
 11600:     //
 11601:     public int hashCode () {
 11602:       return (this.flg ^
 11603:               this.epp ^
 11604:               (int) (this.dvl >> 32) ^
 11605:               (int) this.dvl ^
 11606:               (int) (this.cvl >> 32));
 11607:     }  //efp.hashCode()
 11608: 
 11609:     //------------------------------------------------------------------------
 11610:     //x = x.ieeerem (y)
 11611:     //  x=IEEEremainder(x,y)
 11612:     //z = z.ieeerem (x, y)
 11613:     //  z=IEEEremainder(x,y)
 11614:     //  剰余(round-to-nearest)
 11615:     //
 11616:     //  JavaのMath.IEEEremainder(x,y)と同じ
 11617:     //  IEEEremainder(x,y)=isNaN(x)||isNaN(y)||isInfinite(x)?NaN:isInfinite(y)?x:x-rint(x/y)*y
 11618:     //  被除数から最も近い除数の倍数を引いた結果を返す
 11619:     //  倍数の符号は任意なので除数の符号は結果に影響しない
 11620:     //    IEEEremainder ( 5.0,  3.0) ==  5.0 - rint ( 5.0 /  3.0) *  3.0 == -1.0
 11621:     //    IEEEremainder ( 5.0, -3.0) ==  5.0 - rint ( 5.0 / -3.0) * -3.0 == -1.0
 11622:     //    IEEEremainder (-5.0,  3.0) == -5.0 - rint (-5.0 /  3.0) *  3.0 ==  1.0
 11623:     //    IEEEremainder (-5.0, -3.0) == -5.0 - rint (-5.0 / -3.0) * -3.0 ==  1.0
 11624:     //
 11625:     public final EFP ieeerem (EFP y) {
 11626:       return this.ieeerem (this, y);
 11627:     }  //efp.ieeerem(EFP)
 11628:     public final EFP ieeerem (EFP x, EFP y) {
 11629:       int xf = x.flg;
 11630:       int yf = y.flg;
 11631:       epbFpsr &= 0xff00ffff;  //quotient byteをクリアする
 11632:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
 11633:         if ((xf | yf) << 3 < 0) {  //ieeerem(NaN,y)=NaN, ieeerem(x,NaN)=NaN
 11634:           this.flg = N;
 11635:         } else if (xf << 2 < 0 ||  //ieeerem(±Inf,y)=NaN
 11636:                    yf << 1 < 0) {  //ieeerem(x,±0)=NaN
 11637:           //除数が±0でもゼロ除算にはならない
 11638:           epbFpsr |= EPB_FPSR_OE;
 11639:           if (yf << 1 < 0) {  //±0
 11640:             epbExceptionOperandExponent = yf & M;
 11641:             epbExceptionOperandMantissa = 0x0000000000000000L;
 11642:           } else if (yf << 2 < 0) {  //±Inf
 11643:             epbExceptionOperandExponent = yf & M | 0x7fff << 16;
 11644:             epbExceptionOperandMantissa = 0x0000000000000000L;
 11645:           } else {  //±y
 11646:             epbExceptionOperandExponent = yf & M | 0x3fff + y.epp << 16;
 11647:             epbExceptionOperandMantissa = y.dvl;
 11648:           }
 11649:           this.flg = N;
 11650:         } else if (xf << 1 < 0) {  //ieeerem(±0,y)=±0
 11651:           epbFpsr |= ((xf ^ yf) & M) >>> 8;  //quotient byteに商の符号を入れる
 11652:           this.flg = xf;
 11653:         } else {  //ieeerem(x,±Inf)=x
 11654:           epbFpsr |= ((xf ^ yf) & M) >>> 8;  //quotient byteに商の符号を入れる
 11655:           this.finish (xf, x.epp, x.dvl, x.cvl, 0L);  //xが非正規化数のときUFをセットする
 11656:         }
 11657:         return this;
 11658:       }
 11659:       //両方±0,±Inf,NaN以外
 11660:       epbFpsr |= ((xf ^ yf) & M) >>> 8;  //quotient byteに商の符号を入れる
 11661:       if (false) {
 11662:         this.inner ();
 11663:         //this.sub (x, new EFP ().div (x, y).rint ().imul (y));  //x-rint(x/y)*y。this==x||this==yの場合に注意
 11664:         EFP q = new EFP ().quo (x, y);  //商
 11665:         int qi = q.geti32abs ();  //商の絶対値の下位32bit
 11666:         EFP w = new EFP ();
 11667:         this.imulw (w, q, y).negsub (x).sub (w);  //余り。桁落ちを避けるため倍精度で計算する
 11668:         int k = w.imul2 (this).cmpabs (y);  //|余り*2|<=>|除数|
 11669:         if (k > 0 || k == 0 && (qi & 1) != 0) {  //余りの絶対値が除数の絶対値の1/2よりも大きいか、ちょうど1/2で商が奇数のとき
 11670:           qi++;  //商の絶対値を1増やす
 11671:           if ((xf ^ yf) >= 0) {
 11672:             this.sub (y);
 11673:           } else {
 11674:             this.iadd (y);
 11675:           }
 11676:         }
 11677:         epbQuotient = qi;
 11678:         epbFpsr |= (qi & 127) << 16;  //商の絶対値の下位7bit
 11679:         if (this.flg << 1 < 0) {  //余りが0
 11680:           this.flg = xf | Z;  //0にxの符号を付ける
 11681:         }
 11682:         return this.outer ().finish ();
 11683:       } else {
 11684:         this.inner ();
 11685:         int ye = y.epp;  //this==yの場合があるので順序に注意する
 11686:         long yd = y.dvl;
 11687:         long yc = y.cvl;
 11688:         long yc1 = yc >>> 1;
 11689:         this.epp = x.epp;
 11690:         this.dvl = x.dvl;
 11691:         this.cvl = x.cvl;
 11692:         int i;
 11693:         long l;
 11694:         int q = 0;
 11695:         if ((i = this.epp - ye) > 0 ||
 11696:             i == 0 && ((l = this.dvl - yd) > 0L ||
 11697:                        l == 0L && this.cvl >>> 1 >= yc1)) {  //|x|>=|y|。商は0ではない
 11698:           this.flg = P;  //|x|。余りの初期値
 11699:           EFP t = new EFP (P, 0, yd, yc);
 11700:           do {
 11701:             t.epp = i = (l = this.dvl - yd) > 0L || l == 0L && this.cvl >>> 1 >= yc1 ? this.epp : this.epp - 1;  //指数部を揃えて
 11702:             if ((i -= ye) <= 31) {
 11703:               q |= 1 << i;
 11704:             }
 11705:             this.sub (t);  //引く。アンダーフローのチェックは後で行う
 11706:           } while (this.flg == 0 &&  //0ではない
 11707:                    ((i = this.epp - ye) > 0 ||
 11708:                     i == 0 && ((l = this.dvl - yd) > 0L ||
 11709:                                l == 0L && this.cvl >>> 1 >= yc1)));  //this>=|y|。まだ引ける。指数部が極端に違うと繰り返す回数が大きくなる
 11710:           this.flg |= xf;  //余りが0の場合も含めてyの符号に関係なくxの符号を付ける
 11711:         } else {  //|x|<|y|。商は0
 11712:           this.flg = xf;  //被除数がそのまま余りになる
 11713:         }
 11714:         if (this.flg << 1 >= 0) {  //余りが0ではないとき
 11715:           if ((i = this.epp - ye + 1) > 0 ||
 11716:               i == 0 && ((l = this.dvl - yd) > 0L ||
 11717:                          l == 0L && ((l = (this.cvl >>> 1) - yc1) > 0L ||  //|r|>|y|/2または
 11718:                                      l == 0L && (q & 1) != 0))) {  //|r|==|y|/2かつ商が奇数
 11719:             this.sub (new EFP (this.flg, ye, yd, yc));  //符号を合わせて引く。アンダーフローのチェックは後で行う
 11720:             q++;
 11721:           }
 11722:           if ((short) this.epp != this.epp) {  //アンダーフロー
 11723:             this.outer ();
 11724:             epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 11725:             epbExceptionOperandExponent = this.flg & M;
 11726:             epbExceptionOperandMantissa = this.dvl;
 11727:             return this.sete (UNFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | xf >>> 31]).finish ();  //±0
 11728:           }
 11729:         }
 11730:         epbQuotient = q;
 11731:         epbFpsr |= (q & 127) << 16;  //商の絶対値の下位7bit
 11732:         return this.outer ().finish ();
 11733:       }
 11734:     }  //efp.ieeerem(EFP,EFP)
 11735: 
 11736:     //------------------------------------------------------------------------
 11737:     //k = x.ieeerempi2 ()
 11738:     //  k=rint(x/(pi/2))&3
 11739:     //  x=x-rint(x/(pi/2))*(pi/2)
 11740:     //k = y.ieeerempi2 (x)
 11741:     //  k=rint(x/(pi/2))&3
 11742:     //  y=x-rint(x/(pi/2))*(pi/2)
 11743:     //  ラジアンの象限分類
 11744:     //
 11745:     //  引数をpi/2で割った余りを[-pi/4..pi/4]の範囲で求めて商の下位2bitを返す
 11746:     //                     k=1
 11747:     //               │    ←
 11748:     //    k=2↓＼    │    ／
 11749:     //           ＼  │  ／
 11750:     //             ＼│／
 11751:     //       ────・────
 11752:     //             ／│＼
 11753:     //           ／  │  ＼
 11754:     //         ／    │    ＼↑k=0
 11755:     //         →    │
 11756:     //        k=3
 11757:     //
 11758:     //  三角関数に与えられた引数が大きすぎる場合は何かの間違いでその引数と結果は意味を持たないと考えられる
 11759:     //  しかし実装としてはどのような引数が与えられても可能な限り真の値に近い結果を返したい
 11760:     //  sin(2^n)の象限分類を行うにはおよそ(n)bitの円周率を静的または動的に調達する必要がある
 11761:     //    xをyで割った余りx%y=x-trunc(x/y)*yを正確に求めるには商trunc(x/y)を1の位まで正確に求めなければならない
 11762:     //    xの指数部に対してyの有効桁数が少ないと商を1の位まで正確に求めることができない
 11763:     //    yがpi/2のときxが2^nならばyのpi/2もおよそ(n)bitなければならない
 11764:     //  除数が定数のときは除算を逆数乗算で置き換えることができる
 11765:     //    除数yがpi/2なのでxの指数部の最大値と同じ桁数の2/piの値があればよい
 11766:     //    象限分類で必要なのは商の下位2bitと余りの先頭LENbitだけである
 11767:     //    2/piの値の配列が大きくても1回の呼び出しで使用するのはその一部分に限られる
 11768:     //
 11769:     //  echo lm=32767;lw=9;default(realprecision,floor(lm*0.30103)+200);pi2=Pi/2;twopi=2/Pi;ln2=log(2);eval("hex(s)={my(v,h,i,c);v=Vecsmall(s);h=0;for(i=1,#v,c=v[i];if(c!=95,h=(h<<4)+if(48<=c&&c<=57,c-48,65<=c&&c<=70,c-55,97<=c&&c<=102,c-87,error)));h}");p=eval("twopi/2^(31*3)");a=vector((3+(lm+600)\31)\10*10,i,p=p*eval("2^31");w=floor(p);p=frac(p);printf("%s0x%08x,%s",if(i%10==1,"      ",""),w,if(i%10==0,"\n"," "));w);for(ee=0,lm,xx=hex("80000000000000000000000");tx=eval("xx/2^(91-ee)");tk=bitand(tx\pi2,3);ty=tx%pi2;yy=sum(i=1,lw,shift(a[ee\31+i],31*(lw-i)));ay=frac(xx*yy\eval("2^31")/eval("2^(31*(lw-1)-ee%31)"))*4;ak=floor(ay);ay=frac(ay)*pi2;dist=if(tk!=ak,-999,-log(abs((ay-ty)/ty))/ln2);printf("      //  %6d  %023x  %d  %32.30f  %d  %32.30f  %6.2f  %s%c",ee,xx,tk,ty,ak,ay,dist,if(eval("dist<96"),"ERROR","OK"),10)) | gp -q | grep "ERROR"
 11770:     //  エラーなし
 11771:     //  echo lm=32767;lw=9;default(realprecision,floor(lm*0.30103)+200);pi2=Pi/2;twopi=2/Pi;ln2=log(2);eval("hex(s)={my(v,h,i,c);v=Vecsmall(s);h=0;for(i=1,#v,c=v[i];if(c!=95,h=(h<<4)+if(48<=c&&c<=57,c-48,65<=c&&c<=70,c-55,97<=c&&c<=102,c-87,error)));h}");p=eval("twopi/2^(31*3)");a=vector((3+(lm+600)\31)\10*10,i,p=p*eval("2^31");w=floor(p);p=frac(p);printf("%s0x%08x,%s",if(i%10==1,"      ",""),w,if(i%10==0,"\n"," "));w);for(ee=0,lm,xx=hex("fffffffffffffffffffffff");tx=eval("xx/2^(91-ee)");tk=bitand(tx\pi2,3);ty=tx%pi2;yy=sum(i=1,lw,shift(a[ee\31+i],31*(lw-i)));ay=frac(xx*yy\eval("2^31")/eval("2^(31*(lw-1)-ee%31)"))*4;ak=floor(ay);ay=frac(ay)*pi2;dist=if(tk!=ak,-999,-log(abs((ay-ty)/ty))/ln2);printf("      //  %6d  %023x  %d  %32.30f  %d  %32.30f  %6.2f  %s%c",ee,xx,tk,ty,ak,ay,dist,if(eval("dist<96"),"ERROR","OK"),10)) | gp -q | grep "ERROR"
 11772:     //  エラーなし
 11773:     //
 11774:     //2/piの値
 11775:     //  echo lm=32767;lw=9;default(realprecision,floor(lm*0.30103)+200);pi2=Pi/2;twopi=2/Pi;ln2=log(2);eval("hex(s)={my(v,h,i,c);v=Vecsmall(s);h=0;for(i=1,#v,c=v[i];if(c!=95,h=(h<<4)+if(48<=c&&c<=57,c-48,65<=c&&c<=70,c-55,97<=c&&c<=102,c-87,error)));h}");p=eval("twopi/2^(31*3)");a=vector((3+(lm+600)\31)\10*10,i,p=p*eval("2^31");w=floor(p);p=frac(p);printf("%s0x%08x,%s",if(i%10==1,"      ",""),w,if(i%10==0,"\n"," "));w);for(ee=0,lm,xx=hex("c90fdaa22168c234c4c6629");tx=eval("xx/2^(91-ee)");tk=bitand(tx\pi2,3);ty=tx%pi2;yy=sum(i=1,lw,shift(a[ee\31+i],31*(lw-i)));ay=frac(xx*yy\eval("2^31")/eval("2^(31*(lw-1)-ee%31)"))*4;ak=floor(ay);ay=frac(ay)*pi2;dist=if(tk!=ak,-999,-log(abs((ay-ty)/ty))/ln2);printf("      //  %6d  %023x  %d  %32.30f  %d  %32.30f  %6.2f  %s%c",ee,xx,tk,ty,ak,ay,dist,if(eval("dist<96"),"ERROR","OK"),10)) | gp -q > two_pi_array.out
 11776:     //  エラーなし
 11777:     //
 11778:     public int ieeerempi2 () {
 11779:       return this.ieeerempi2 (this);
 11780:     }  //efp.ieeerempi2()
 11781:     public int ieeerempi2 (EFP x) {
 11782:       int xf = x.flg;
 11783:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 11784:         this.flg = xf;  //そのまま
 11785:         return 0;
 11786:       }
 11787:       //±0,±Inf,NaN以外
 11788:       int xe = x.epp;
 11789:       long xd = x.dvl;
 11790:       long xc = x.cvl;
 11791:       int o;
 11792:       long t;
 11793:       if ((o = xe + 1) < 0 || o == 0 && ((t = xd - 0xc90fdaa22168c234L) < 0L ||
 11794:                                          t == 0L && xc >>> 1 <= 0xc4c6629L >>> 1)) {  //|x|<=pi/4
 11795:         this.flg = xf;  //そのまま
 11796:         this.epp = xe;
 11797:         this.dvl = xd;
 11798:         this.cvl = xc;
 11799:         return 0;
 11800:       }
 11801:       if ((o = xe - 1) < 0 || o == 0 && ((t = xd - 0x96cbe3f9990e91a7L) < 0L ||
 11802:                                          t == 0L && xc >>> 1 <= 0x9394c9fL >>> 1)) {  //|x|<=3*pi/4
 11803:         if (xf >= 0) {
 11804:           this.inner ().sub (x, PI_2).outer ().sub (PI_2A);  //x-pi/2
 11805:           return 1;
 11806:         } else {
 11807:           this.inner ().iadd (x, PI_2).outer ().add (PI_2A);  //x+pi/2
 11808:           return 3;
 11809:         }
 11810:       }
 11811:       //以下はxe>=1
 11812:       //92bitの仮数部を30bit,31bit,31bitに3分割する
 11813:       long x0 = xd >>> -30;  //上位30bit
 11814:       long x1 = xd >>> 3 & 0x7fffffffL;  //中位31bit
 11815:       long x2 = (xd << 28 | xc >>> -28) & 0x7fffffffL;  //下位31bit
 11816:       //  perl optdiv.pl 32767 31
 11817:       //  x/31==x*16913>>>19 (0<=x<=34966) [32767*16913==554188271]
 11818:       o = xe * 16913 >>> 19;  //xe/31。xe<0は不可
 11819:       long y0 = TWO_PI_ARRAY[o    ];
 11820:       long y1 = TWO_PI_ARRAY[o + 1];
 11821:       long y2 = TWO_PI_ARRAY[o + 2];
 11822:       long y3 = TWO_PI_ARRAY[o + 3];
 11823:       long y4 = TWO_PI_ARRAY[o + 4];
 11824:       long y5 = TWO_PI_ARRAY[o + 5];
 11825:       long y6 = TWO_PI_ARRAY[o + 6];
 11826:       long y7 = TWO_PI_ARRAY[o + 7];
 11827:       long y8 = TWO_PI_ARRAY[o + 8];
 11828:       //xとyを掛けて62bit左詰め4要素にする
 11829:       //                             x0 x1 x2
 11830:       //  *        y0 y1 y2 y3 y4 y5 y6 y7 y8
 11831:       //  -----------------------------------
 11832:       //          |     |     |     |   x2*y8
 11833:       //          |     |     |     |x1*y8|
 11834:       //          |     |     |     |x2*y7|
 11835:       //          |     |     |   x0*y8   |
 11836:       //          |     |     |   x1*y7   |
 11837:       //          |     |     |   x2*y6   |
 11838:       //          |     |     |x0*y7|     |
 11839:       //          |     |     |x1*y6|     |
 11840:       //          |     |     |x2*y5|     |
 11841:       //          |     |   x0*y6   |     |
 11842:       //          |     |   x1*y5   |     |
 11843:       //          |     |   x2*y4   |     |
 11844:       //          |     |x0*y5|     |     |
 11845:       //          |     |x1*y4|     |     |
 11846:       //          |     |x2*y3|     |     |
 11847:       //          |   x0*y4   |     |     |
 11848:       //          |   x1*y3   |     |     |
 11849:       //          |   x2*y2   |     |     |
 11850:       //          |x0*y3|     |     |     |
 11851:       //          |x1*y2|     |     |     |
 11852:       //          |x2*y1|     |     |     |
 11853:       //        x0*y2   |     |     |     |
 11854:       //        x1*y1   |     |     |     |
 11855:       //        x2*y0   |     |     |     |
 11856:       //     x0*y1|     |     |     |     |
 11857:       //     x1*y0|     |     |     |     |
 11858:       //  x0*y0   |     |     |     |     |
 11859:       //  -----------------------------------
 11860:       //           z0    z1    z2    z3
 11861:       long z3 = (x2 * y8 >>> 31) + x1 * y8 + x2 * y7;  //x2*y8の下位は捨てる
 11862:       long z2 = (z3 >>> 31) + x0 * y8 + x1 * y7 + x2 * y6;
 11863:       z3 = (z3 & 0x7fffffffL) + (z2 << 33 >>> 2) << 2;
 11864:       z2 = (z2 >>> 31) + x0 * y7 + x1 * y6 + x2 * y5;
 11865:       long z1 = (z2 >>> 31) + x0 * y6 + x1 * y5 + x2 * y4;
 11866:       z2 = (z2 & 0x7fffffffL) + (z1 << 33 >>> 2) << 2;
 11867:       z1 = (z1 >>> 31) + x0 * y5 + x1 * y4 + x2 * y3;
 11868:       long z0 = (z1 >>> 31) + x0 * y4 + x1 * y3 + x2 * y2;
 11869:       z1 = (z1 & 0x7fffffffL) + (z0 << 33 >>> 2) << 2;
 11870:       z0 = (z0 >>> 31) + x0 * y3 + x1 * y2 + x2 * y1 + (x0 * y2 + x1 * y1 + x2 * y0 << 31) << 2;  //溢れは無視する。x0*y1+x1*y0とx0*y0は不要
 11871:       //248bit左詰めにする
 11872:       z0 |= z1 >>> -2;
 11873:       z1 = z1 << 2 | z2 >>> -4;
 11874:       z2 = z2 << 4 | z3 >>> -6;
 11875:       z3 <<= 6;
 11876:       //左にxe%31bitずらす
 11877:       o = xe - o * 31;  //xe%31
 11878:       if (o != 0) {
 11879:         z0 = z0 << o | z1 >>> -o;
 11880:         z1 = z1 << o | z2 >>> -o;
 11881:         z2 = z2 << o | z3 >>> -o;
 11882:         z3 <<= o;
 11883:       }
 11884:       //商の下位2bitを取り出す
 11885:       o = (int) (z0 >>> -2);
 11886:       if (xf < 0) {
 11887:         o = -o;
 11888:       }
 11889:       //商の下位2bitを押し出して小数点以下だけにする
 11890:       z0 = z0 << 2 | z1 >>> -2;
 11891:       z1 = z1 << 2 | z2 >>> -2;
 11892:       z2 = z2 << 2 | z3 >>> -2;
 11893:       z3 <<= 2;
 11894:       //余りの絶対値が0.5以上のときは商の絶対値を1増やして余りの絶対値を1減らす
 11895:       //  左端が0.5の位なので左端が1ならば符号を反転する
 11896:       if (z0 < 0L) {
 11897:         o = xf >= 0 ? o + 1 : o - 1;
 11898:         t = z3 = -z3;
 11899:         t |= z2 = t == 0L ? -z2 : ~z2;
 11900:         t |= z1 = t == 0L ? -z1 : ~z1;
 11901:         z0 = t == 0L ? -z0 : ~z0;  //左端が0になるとは限らない。100...のときは符号反転しても100...のまま
 11902:         xf ^= M;
 11903:       }
 11904:       o &= 3;
 11905:       //正規化する
 11906:       if (z0 < 0L) {
 11907:         xe = -1;  //-1
 11908:       } else if (z0 != 0L) {
 11909:         xe = Long.numberOfLeadingZeros (z0);  //1..63。左にシフトするbit数
 11910:         z0 = z0 << xe | z1 >>> -xe;
 11911:         z1 = z1 << xe | z2 >>> -xe;
 11912:         z2 = z2 << xe | z3 >>> -xe;
 11913:         z3 <<= xe;
 11914:         xe = ~xe;  //-1-xe。-2..-64。指数
 11915:       } else if (z1 < 0L) {
 11916:         xe = -65;  //-65。指数
 11917:         z0 = z1;
 11918:         z1 = z2;
 11919:         z2 = z3;
 11920:         z3 = 0L;
 11921:       } else if (z1 != 0L) {
 11922:         xe = Long.numberOfLeadingZeros (z1) + 64;  //65..127。左にシフトするbit数
 11923:         z0 = z1 << xe | z2 >>> -xe;
 11924:         z1 = z2 << xe | z3 >>> -xe;
 11925:         z2 = z3 << xe;
 11926:         z3 = 0L;
 11927:         xe = ~xe;  //-1-xe。-66..-128。指数
 11928:       } else if (z2 < 0L) {
 11929:         xe = -129;  //-129。指数
 11930:         z0 = z2;
 11931:         z1 = z3;
 11932:         z2 = 0L;
 11933:         z3 = 0L;
 11934:       } else if (z2 != 0L) {
 11935:         xe = Long.numberOfLeadingZeros (z2) + 128;  //129..191。左にシフトするbit数
 11936:         z0 = z2 << xe | z3 >>> -xe;
 11937:         z1 = z3 << xe;
 11938:         z2 = 0L;
 11939:         z3 = 0L;
 11940:         xe = ~xe;  //-1-xe。-130..-192。指数
 11941:       } else if (z3 != 0L) {
 11942:         xe = Long.numberOfLeadingZeros (z3) + 192;  //192..255。左にシフトするbit数
 11943:         z0 = z3 << xe;
 11944:         z1 = 0L;
 11945:         z2 = 0L;
 11946:         z3 = 0L;
 11947:         xe = ~xe;  //-1-xe。-193..-256。指数
 11948:       } else {
 11949:         this.flg = xf | Z;
 11950:         return o;
 11951:       }
 11952:       //丸めの処理
 11953:       this.ifinish (xf, xe, z0, z1, z2 | z3);
 11954:       //pi/2を掛ける
 11955:       this.mul (PI_2);
 11956:       //商の下位2bitを返す
 11957:       return o;
 11958:     }  //efp.ieeerempi2(EFP)
 11959: 
 11960:     //------------------------------------------------------------------------
 11961:     //x = x.inc ()
 11962:     //  x+=1
 11963:     //y = y.inc (x)
 11964:     //  y=x+1
 11965:     //  1を加える(インクリメント)
 11966:     //
 11967:     //  グラフ
 11968:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{$_[0]+1});print$g"
 11969:     //    echo read("../misc/efp.gp");eval("inc(x)=x+1");graph(inc) | gp -q
 11970:     //    +---------+---------+---------+---------+---------+---------+--------***--------+
 11971:     //    |                                       |                          ***          |
 11972:     //    |                                       |                        ***            |
 11973:     //    |                                       |                      ***              |
 11974:     //    |                                       |                    ***                |
 11975:     //    +                                       +                  ***                  +
 11976:     //    |                                       |                ***                    |
 11977:     //    |                                       |              ***                      |
 11978:     //    |                                       |            ***                        |
 11979:     //    |                                       |          ***                          |
 11980:     //    +                                       +        ***                            +
 11981:     //    |                                       |      ***                              |
 11982:     //    |                                       |    ***                                |
 11983:     //    |                                       |  ***                                  |
 11984:     //    |                                       |***                                    |
 11985:     //    +                                      ***                                      +
 11986:     //    |                                    ***|                                       |
 11987:     //    |                                  ***  |                                       |
 11988:     //    |                                ***    |                                       |
 11989:     //    |                              ***      |                                       |
 11990:     //    +---------+---------+--------***--------+---------+---------+---------+---------+
 11991:     //    |                          ***          |                                       |
 11992:     //    |                        ***            |                                       |
 11993:     //    |                      ***              |                                       |
 11994:     //    |                    ***                |                                       |
 11995:     //    +                  ***                  +                                       +
 11996:     //    |                ***                    |                                       |
 11997:     //    |              ***                      |                                       |
 11998:     //    |            ***                        |                                       |
 11999:     //    |          ***                          |                                       |
 12000:     //    +        ***                            +                                       +
 12001:     //    |      ***                              |                                       |
 12002:     //    |    ***                                |                                       |
 12003:     //    |  ***                                  |                                       |
 12004:     //    |***                                    |                                       |
 12005:     //    **                                      +                                       +
 12006:     //    |                                       |                                       |
 12007:     //    |                                       |                                       |
 12008:     //    |                                       |                                       |
 12009:     //    |                                       |                                       |
 12010:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 12011:     //
 12012:     public final EFP inc () {
 12013:       return this.inc (this);
 12014:     }  //efp.inc()
 12015:     public final EFP inc (EFP x) {
 12016:       //return this.add (x, ONE);  //7.6ns
 12017:       //6.2ns
 12018:       int xf = x.flg;
 12019:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 12020:         if (xf << 1 < 0) {  //±0
 12021:           this.flg = P;  //+1
 12022:           this.epp = 0;
 12023:           this.dvl = MSB;
 12024:           this.cvl = 0L;
 12025:         } else {  //±Inf,NaN
 12026:           this.flg = xf;
 12027:         }
 12028:         return this;
 12029:       }
 12030:       //±0,±Inf,NaN以外
 12031:       int xe = x.epp;
 12032:       if (xe < -LEN) {  //..-LEN-1。xの先頭がguard bitよりも右
 12033:         //絶対値は1の方が大きいのでxを右にシフトするがxの絶対値が小さすぎるので1になる
 12034:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 12035:         this.flg = P;  //+1
 12036:         this.epp = 0;
 12037:         this.dvl = MSB;
 12038:         this.cvl = 0L;
 12039:         return this;
 12040:       }
 12041:       long xd = x.dvl;
 12042:       long xc = x.cvl;
 12043:       if (LEN < xe) {  //LEN+1..。1がguard bitよりも右
 12044:         //絶対値はxの方が大きいので1を右にシフトするが1の絶対値が小さすぎるのでxになる
 12045:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 12046:         return this.finish (xf, xe, xd, xc, 0L);  //x
 12047:       }
 12048:       long xb = 0L;
 12049:       if (xe == 0) {  //0。xの最上位bitと1が重なる
 12050:         //絶対値はxの方が大きいか等しいが小数点の位置は同じ
 12051:         if (xf < 0) {  //-x
 12052:           //絶対値から1を引く
 12053:           xd -= MSB;
 12054:         } else {  //+x
 12055:           //絶対値に1を加える
 12056:           xb = xc << -1;
 12057:           xc = xd << -1 | xc >>> 1;
 12058:           xd = (xd >>> 1) + (MSB >>> 1);
 12059:           xe++;
 12060:         }
 12061:       } else if (0 < xe) {  //1..LEN
 12062:         //絶対値はxの方が大きいので1を右にシフトする
 12063:         if (xf < 0) {  //-x
 12064:           //絶対値から1を引く
 12065:           if (xe <= 63) {  //1..63。xの上位の2bit目以降と1が重なる
 12066:             xd -= MSB >>> xe;  //最上位bitが1なのでボローはなく0にもならない
 12067:           } else {  //64..LEN。xの下位またはguard bitと1が重なる
 12068:             if (xc >>> ~xe != 0L) {  //下位の引く位置から上が0ではない。下位だけで引ける
 12069:               xc -= MSB >>> xe;
 12070:             } else {  //下位の引く位置から上が0なのでボローが発生する
 12071:               xc |= MSB >> xe;  //下位の引く位置から上は-1になる
 12072:               xd--;  //ボローを上位から引く
 12073:             }
 12074:           }
 12075:         } else {  //+x
 12076:           //絶対値に1を加える
 12077:           if (xe <= 63) {  //1..63。xの上位と1が重なる
 12078:             if ((xd += MSB >>> xe) >>> ~xe == 0L) {  //絶対値に1を加えたら加えたbitから上がすべて0になって溢れた
 12079:               xb = xc << -1;
 12080:               xc = xd << -1 | xc >>> 1;
 12081:               xd = MSB | xd >>> 1;
 12082:               xe++;
 12083:             }
 12084:           } else {  //64..LEN。xの下位またはguard bitと1が重なる
 12085:             if ((xc += MSB >>> xe) >>> ~xe == 0L && ++xd == 0L) {  //絶対値に1を加えたら加えたbitから上がすべて0になって溢れた
 12086:               xb = xc << -1;
 12087:               xc = xc >>> 1;
 12088:               xd = MSB;
 12089:               xe++;
 12090:             }
 12091:           }
 12092:         }
 12093:       } else {  //-LEN..-1
 12094:         //絶対値は1の方が大きいのでxを右にシフトする
 12095:         if (-63 <= xe) {  //-63..-1。xの先頭が1の右隣から上位の最下位bitまで
 12096:           xb = xc << xe;
 12097:           xc = xd << xe | xc >>> -xe;
 12098:           xd >>>= -xe;
 12099:         } else if (-64 == xe) {  //-64。xの先頭が下位の最上位bit
 12100:           xb = xc;
 12101:           xc = xd;
 12102:           xd = 0L;
 12103:         } else {  //-LEN..-65。xの先頭が下位の上から2bit目からguard bitまで
 12104:           xb = xd << xe | xc >>> -xe;
 12105:           xc = xd >>> -xe;
 12106:           xd = 0L;
 12107:         }
 12108:         xe = 0;
 12109:         if (xf < 0) {  //-x
 12110:           //絶対値を1から引く
 12111:           if (xb != 0L) {
 12112:             xb = -xb;
 12113:             xc = -1L - xc;
 12114:             xd = MSB - 1L - xd;
 12115:           } else if (xc != 0L) {
 12116:             xc = -xc;
 12117:             xd = MSB - 1L - xd;
 12118:           } else {
 12119:             xd = MSB - xd;
 12120:           }
 12121:           xf ^= M;  //符号反転
 12122:         } else {  //+x
 12123:           //絶対値に1を加える
 12124:           xd |= MSB;
 12125:         }
 12126:       }
 12127:       //正規化する
 12128:       if (xd >= 0L) {
 12129:         if (xd != 0L) {
 12130:           int o = Long.numberOfLeadingZeros (xd);  //1..63。左にシフトするbit数
 12131:           xe -= o;
 12132:           xd = xd << o | xc >>> -o;
 12133:           xc = xc << o | xb >>> -o;
 12134:           xb <<= o;
 12135:         } else if (xc < 0L) {
 12136:           xe -= 64;
 12137:           xd = xc;
 12138:           xc = xb;
 12139:           xb = 0L;
 12140:         } else if (xc != 0L) {
 12141:           int o = 64 + Long.numberOfLeadingZeros (xc);  //65..127。左にシフトするbit数
 12142:           xe -= o;
 12143:           xd = xc << o | xb >>> -o;
 12144:           xc = xb << o;
 12145:           xb = 0L;
 12146:         } else if (xb < 0L) {
 12147:           xe -= 128;
 12148:           xd = xb;
 12149:           xc = 0L;
 12150:           xb = 0L;
 12151:         } else if (xb != 0L) {
 12152:           int o = 128 + Long.numberOfLeadingZeros (xb);  //129..191。左にシフトするbit数
 12153:           xe -= o;
 12154:           xd = xb << o;
 12155:           xc = 0L;
 12156:           xb = 0L;
 12157:         } else {
 12158:           this.flg = P | Z;  //-1+1=+0
 12159:           return this;
 12160:         }
 12161:       }
 12162:       return this.finish (xf, xe, xd, xc, xb);
 12163:     }  //efp.inc(EFP)
 12164: 
 12165:     //------------------------------------------------------------------------
 12166:     //b = x.iseven ()
 12167:     //  偶数の整数か
 12168:     //
 12169:     //  NaNは偶数ではない
 12170:     //  ±0,±Infは偶数
 12171:     //  ±0,±Inf,NaN以外は1の位のbitがないか1の位のbitが0ならば偶数
 12172:     //
 12173:     public boolean iseven () {
 12174:       int xf = this.flg;
 12175:       int xe = this.epp;
 12176:       return (xf << 1 != 0 ? xf << 3 >= 0 :  //±0,±Infは偶数。NaNは整数ではない
 12177:               xe < 0 ? false :  //整数部の1が小数点よりも右側にあるということは小数点以下が0ではないので整数ではない
 12178:               xe > LEN - 1 ? true : //1の位が小数部よりも右側にあるということは1の位が0なので偶数
 12179:               xe <= 63 ? this.dvl << xe == 0L && this.cvl == 0L : this.cvl << xe == 0L);  //1の位と小数点以下がすべて0ならば偶数
 12180:     }  //efp.iseven()
 12181: 
 12182:     //------------------------------------------------------------------------
 12183:     //b = x.isinf ()
 12184:     //  ±Infか
 12185:     //
 12186:     public boolean isinf () {
 12187:       return this.flg << 2 < 0;  //±Inf
 12188:     }  //efp.isinf()
 12189: 
 12190:     //------------------------------------------------------------------------
 12191:     //b = x.isint ()
 12192:     //  整数か
 12193:     //
 12194:     //  NaNは整数ではない
 12195:     //  ±0,±Infは整数
 12196:     //  ±0,±Inf,NaN以外は小数点よりも右側にセットされているbitがなければ整数
 12197:     //
 12198:     public boolean isint () {
 12199:       int xf = this.flg;
 12200:       int xe = this.epp;
 12201:       return (xf << 1 != 0 ? xf << 3 >= 0 :  //±0,±Infは整数。NaNは整数ではない
 12202:               xe < 0 ? false :  //整数部の1が小数点よりも右側にあるということは小数点以下が0ではないので整数ではない
 12203:               xe >= LEN - 1 ? true : //小数点が小数部よりも右側にあるので整数
 12204:               xe <= 63 ? this.dvl << 1 << xe == 0L && this.cvl == 0L : this.cvl << xe == 0L);  //小数点以下がすべて0ならば偶数
 12205:     }  //efp.isint()
 12206: 
 12207:     //------------------------------------------------------------------------
 12208:     //b = x.isnan ()
 12209:     //  NaNか
 12210:     //
 12211:     public boolean isnan () {
 12212:       return this.flg << 3 < 0;  //NaN
 12213:     }  //efp.isnan()
 12214: 
 12215:     //------------------------------------------------------------------------
 12216:     //b = x.isodd ()
 12217:     //  奇数の整数か
 12218:     //
 12219:     //  NaNは奇数ではない
 12220:     //  ±0,±Infは奇数ではない
 12221:     //  ±0,±Inf,NaN以外は1の位のbitが1ならば奇数
 12222:     //
 12223:     public boolean isodd () {
 12224:       int xf = this.flg;
 12225:       int xe = this.epp;
 12226:       return (xf << 1 != 0 ? false :  //±0,±Infは奇数ではない。NaNは整数ではない
 12227:               xe < 0 ? false :  //整数部の1が小数点よりも右側にあるということは小数点以下が0ではないので整数ではない
 12228:               xe > LEN - 1 ? false : //1の位が小数部よりも右側にあるということは1の位が0なので奇数ではない
 12229:               xe <= 63 ? this.dvl << xe == MSB && this.cvl == 0L : this.cvl << xe == MSB);  //1の位が1で小数点以下がすべて0ならば奇数
 12230:     }  //efp.isodd()
 12231: 
 12232:     //------------------------------------------------------------------------
 12233:     //b = x.isone ()
 12234:     //  +1か
 12235:     //
 12236:     public boolean isone () {
 12237:       return (this.flg == P &&
 12238:               this.epp == 0 &&
 12239:               this.dvl == MSB &&
 12240:               this.cvl == 0L);  //1
 12241:     }  //efp.isone()
 12242: 
 12243:     //------------------------------------------------------------------------
 12244:     //b = x.iszero ()
 12245:     //  ±0か
 12246:     //
 12247:     public boolean iszero () {
 12248:       return this.flg << 1 < 0;  //±0
 12249:     }  //efp.iszero()
 12250: 
 12251:     //------------------------------------------------------------------------
 12252:     //b = x.le (y)
 12253:     //  b=x<=y
 12254:     //  より小さいか等しいか
 12255:     //
 12256:     //  -Inf==-Inf<-x<-0==+0<+x<+Inf==+Inf
 12257:     //
 12258:     //  NaNの扱い
 12259:     //    どちらかがNaNのときはfalseを返す
 12260:     //
 12261:     public boolean le (EFP y) {
 12262:       int xf = this.flg;
 12263:       int yf = y.flg;
 12264:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
 12265:         return EFP_LE_TABLE[xf >>> 28] << (yf >>> 28 - 1) < 0;
 12266:       }
 12267:       //両方±0,±Inf,NaN以外
 12268:       if (xf != yf) {  //両方±0,±Inf,NaN以外で符号が違う
 12269:         return xf < yf;
 12270:       }
 12271:       //両方±0,±Inf,NaN以外で符号が同じ
 12272:       int s;
 12273:       long t;
 12274:       return (xf >= 0 ? 1 : -1) * ((s = this.epp - y.epp) != 0 ? s >= 0 ? 1 : -1 :
 12275:                                    (t = this.dvl - y.dvl) != 0L ? t >= 0L ? 1 : -1 :
 12276:                                    (t = (this.cvl >>> 1) - (y.cvl >>> 1)) != 0L ? t >= 0L ? 1 : -1 :
 12277:                                    0) <= 0;
 12278:     }  //efp.le(EFP)
 12279: 
 12280:     //------------------------------------------------------------------------
 12281:     //x = x.log ()
 12282:     //  x=log(x)
 12283:     //y = y.log (x)
 12284:     //  y=log(x)
 12285:     //  自然対数 natural logarithm
 12286:     //
 12287:     //  グラフ
 12288:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{log($_[0])});print$g"
 12289:     //    echo read("../misc/efp.gp");graph(log) | gp -q
 12290:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 12291:     //    |                                       |                                       |
 12292:     //    |                                       |                                       |
 12293:     //    |                                       |                                       |
 12294:     //    |                                       |                                       |
 12295:     //    +                                       +                                       +
 12296:     //    |                                       |                                       |
 12297:     //    |                                       |                                       |
 12298:     //    |                                       |                                       |
 12299:     //    |                                       |                                       |
 12300:     //    +                                       +                                       +
 12301:     //    |                                       |                                       |
 12302:     //    |                                       |                                       |
 12303:     //    |                                       |                                    ****
 12304:     //    |                                       |                             ********  |
 12305:     //    +                                       +                        ******         +
 12306:     //    |                                       |                   ******              |
 12307:     //    |                                       |               *****                   |
 12308:     //    |                                       |            ****                       |
 12309:     //    |                                       |          ***                          |
 12310:     //    +---------+---------+---------+---------+--------***--------+---------+---------+
 12311:     //    |                                       |      ***                              |
 12312:     //    |                                       |     **                                |
 12313:     //    |                                       |    **                                 |
 12314:     //    |                                       |   **                                  |
 12315:     //    +                                       +  **                                   +
 12316:     //    |                                       |  *                                    |
 12317:     //    |                                       | **                                    |
 12318:     //    |                                       | *                                     |
 12319:     //    |                                       |**                                     |
 12320:     //    +                                       +*                                      +
 12321:     //    |                                       |*                                      |
 12322:     //    |                                       |*                                      |
 12323:     //    |                                       |*                                      |
 12324:     //    |                                       |*                                      |
 12325:     //    +                                       **                                      +
 12326:     //    |                                       *                                       |
 12327:     //    |                                       *                                       |
 12328:     //    |                                       *                                       |
 12329:     //    |                                       *                                       |
 12330:     //    +---------+---------+---------+---------*---------+---------+---------+---------+
 12331:     //
 12332:     //  定義域
 12333:     //    0<x<=inf
 12334:     //
 12335:     //  値域
 12336:     //    -inf<=y<=inf
 12337:     //
 12338:     //  テイラー展開
 12339:     //    > coeff(sub(a=0,for n:=0:8 sum sub(x=a,df(log(1+x),x,n))/factorial(n)*(x-a)^n),x);
 12340:     //           - 1   1    - 1   1    - 1   1    - 1
 12341:     //    {0,1,------,---,------,---,------,---,------}
 12342:     //           2     3    4     5    6     7    8
 12343:     //    log(1+x)=sum[n=1..inf]{(-1)^(n+1)*x^n/n}
 12344:     //    1<xのときはlog(x)=-log(1/x)で計算する
 12345:     //
 12346:     //  テイラー展開2
 12347:     //    log(1+x)=sum[n=1..inf]{(-1)^(n+1)*x^n/n}
 12348:     //    xに-xを代入すると偶数次の項は係数が負のままで奇数次の項は係数が正から負に変わるので
 12349:     //    log(1-x)=sum[n=1..inf]{-x^n/n}
 12350:     //    > coeff(sub(a=0,for n:=0:8 sum sub(x=a,df(log(1-x),x,n))/factorial(n)*(x-a)^n),x);
 12351:     //            - 1    - 1    - 1    - 1    - 1    - 1    - 1
 12352:     //    {0,-1,------,------,------,------,------,------,------}
 12353:     //            2      3      4      5      6      7      8
 12354:     //    これらを引くと偶数次の項が消えて
 12355:     //    log(1+x)-log(1-x)=2*sum[k=0..inf]{x^(2*k+1)/(2*k+1)}
 12356:     //    すなわち
 12357:     //    log((1+x)/(1-x))=2*sum[k=0..inf]{x^(2*k+1)/(2*k+1)}
 12358:     //    > coeff(sub(a=0,for n:=0:14 sum sub(x=a,df(log((1+x)/(1-x)),x,n))/factorial(n)*(x-a)^n),x);
 12359:     //            2     2     2     2     2      2
 12360:     //    {0,2,0,---,0,---,0,---,0,---,0,----,0,----}
 12361:     //            3     5     7     9     11     13
 12362:     //    ここで
 12363:     //    u=(x-1)/(x+1)
 12364:     //    とおくと
 12365:     //    x=(1+u)/(1-u)
 12366:     //    であるから
 12367:     //    log(x)=2*sum[k=0..inf]{u^(2*k+1)/(2*k+1)}
 12368:     //    0<x<infのとき-1<u<1なので定義域のほぼ全域で収束する
 12369:     //    それでもxが1から離れると収束が遅い
 12370:     //    式からわかるように、log(x)のグラフと2*(x-1)/(x+1)のグラフは1付近の形がよく似ている
 12371:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{my($x)=@_;2*($x-1)/($x+1)});print$g"
 12372:     //    +--------***--------+---------+---------+---------+---------+---------+---------+
 12373:     //    |     ****                              |                                       |
 12374:     //    |  ****                                 |                                       |
 12375:     //    ****                                    |                                       |
 12376:     //    |                                       |                                       |
 12377:     //    +                                       +                                       +
 12378:     //    |                                       |                                       |
 12379:     //    |                                       |                                       |
 12380:     //    |                                       |                                       |
 12381:     //    |                                       |                                       |
 12382:     //    +                                       +                                       +
 12383:     //    |                                       |                                       |
 12384:     //    |                                       |                                       |
 12385:     //    |                                       |                                       |
 12386:     //    |                                       |                                 *******
 12387:     //    +                                       +                         *********     +
 12388:     //    |                                       |                    ******             |
 12389:     //    |                                       |                *****                  |
 12390:     //    |                                       |             ****                      |
 12391:     //    |                                       |          ****                         |
 12392:     //    +---------+---------+---------+---------+--------***--------+---------+---------+
 12393:     //    |                                       |      ***                              |
 12394:     //    |                                       |     **                                |
 12395:     //    |                                       |    **                                 |
 12396:     //    |                                       |   **                                  |
 12397:     //    +                                       +  **                                   +
 12398:     //    |                                       | **                                    |
 12399:     //    |                                       |**                                     |
 12400:     //    |                                       |*                                      |
 12401:     //    |                                       **                                      |
 12402:     //    +                                       *                                       +
 12403:     //    |                                      **                                       |
 12404:     //    |                                      *|                                       |
 12405:     //    |                                      *|                                       |
 12406:     //    |                                     **|                                       |
 12407:     //    +                                     * +                                       +
 12408:     //    |                                     * |                                       |
 12409:     //    |                                    ** |                                       |
 12410:     //    |                                    *  |                                       |
 12411:     //    |                                    *  |                                       |
 12412:     //    +---------+---------+---------+------*--+---------+---------+---------+---------+
 12413:     //    差を10倍してみる
 12414:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{my($x)=@_;10*(2*($x-1)/($x+1)-log($x))});print$g"
 12415:     //    +---------+---------+---------+---------+-*-------+---------+---------+---------+
 12416:     //    |                                       | *                                     |
 12417:     //    |                                       | *                                     |
 12418:     //    |                                       | *                                     |
 12419:     //    |                                       | *                                     |
 12420:     //    +                                       + *                                     +
 12421:     //    |                                       | *                                     |
 12422:     //    |                                       | *                                     |
 12423:     //    |                                       | *                                     |
 12424:     //    |                                       | *                                     |
 12425:     //    +                                       + *                                     +
 12426:     //    |                                       | **                                    |
 12427:     //    |                                       |  *                                    |
 12428:     //    |                                       |  *                                    |
 12429:     //    |                                       |  *                                    |
 12430:     //    +                                       +  *                                    +
 12431:     //    |                                       |  **                                   |
 12432:     //    |                                       |   *                                   |
 12433:     //    |                                       |   **                                  |
 12434:     //    |                                       |    **                                 |
 12435:     //    +---------+---------+---------+---------+-----***********---+---------+---------+
 12436:     //    |                                       |               ******                  |
 12437:     //    |                                       |                    ****               |
 12438:     //    |                                       |                       ***             |
 12439:     //    |                                       |                         ****          |
 12440:     //    +                                       +                            ***        +
 12441:     //    |                                       |                              ****     |
 12442:     //    |                                       |                                 ***   |
 12443:     //    |                                       |                                   *** |
 12444:     //    |                                       |                                     ***
 12445:     //    +                                       +                                       +
 12446:     //    |                                       |                                       |
 12447:     //    |                                       |                                       |
 12448:     //    |                                       |                                       |
 12449:     //    |                                       |                                       |
 12450:     //    +                                       +                                       +
 12451:     //    |                                       |                                       |
 12452:     //    |                                       |                                       |
 12453:     //    |                                       |                                       |
 12454:     //    |                                       |                                       |
 12455:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 12456:     //
 12457:     //  テイラー展開3
 12458:     //    浮動小数点数の特性を利用して指数部を分離する
 12459:     //    x=2^k*vのとき
 12460:     //    log(x)=log(2^k*v)
 12461:     //          =k*log(2)+log(v)
 12462:     //    sqrt(2)/2<=v<=sqrt(2)
 12463:     //    となるようにkを選ぶと
 12464:     //    2*sqrt(2)-3<=(v-1)/(v+1)<=3-2*sqrt(2)
 12465:     //    -0.17157...<=(v-1)/(v+1)<=0.17157...
 12466:     //    となる
 12467:     //    1/(3-2*sqrt(2))^2=33.97...であるから1項増やす毎に5bit以上増える
 12468:     //    多倍長の場合はxと同じ精度のlog(2)を他の方法で求めなければならない
 12469:     //    echo read("../misc/efp.gp");eval("f(n,x)={my(u=(x-1)/(x+1));2*sum(k=0,n,u^(2*k+1)/(2*k+1))}");for(n=0,30,printf("%4d",floor(closeness2(log,f(n,x),sqrt(2)/2,sqrt(2))))) | gp -q
 12470:     //       0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28  29  30
 12471:     //       6  12  18  23  28  34  39  44  49  55  60  65  70  76  81  86  91  96 101 107 112 117 122 127 132 137 143 148 153 158 163
 12472:     //
 12473:     //  連分数展開
 12474:     //    log(1+x)=x/(1+x/(2+x/(3+4*x/(4+4*x/(5+9*x/(6+9*x/(7+...
 12475:     //      echo eval("h(k)=if(k==1,1/2,bitand(k,1)==0,k/(k+1)/4,(k+1)/k/4)");eval("g(n,x,k)=h(k)*x/(1+if(k<n,g(n,x,k+1),0))");eval("f(n,x)=x/(1+if(n<1,0,g(n,x,1)))");for(n=0,10,print("    //      f(",n,",x)=",f(n,x))) | gp -q
 12476:     //      f(0,x)=x
 12477:     //      f(1,x)=2*x/(x + 2)
 12478:     //      f(2,x)=(x^2 + 6*x)/(4*x + 6)
 12479:     //      f(3,x)=(3*x^2 + 6*x)/(x^2 + 6*x + 6)
 12480:     //      f(4,x)=(x^3 + 21*x^2 + 30*x)/(9*x^2 + 36*x + 30)
 12481:     //      f(5,x)=(11*x^3 + 60*x^2 + 60*x)/(3*x^3 + 36*x^2 + 90*x + 60)
 12482:     //      f(6,x)=(3*x^4 + 140*x^3 + 510*x^2 + 420*x)/(48*x^3 + 360*x^2 + 720*x + 420)
 12483:     //      f(7,x)=(25*x^4 + 260*x^3 + 630*x^2 + 420*x)/(6*x^4 + 120*x^3 + 540*x^2 + 840*x + 420)
 12484:     //      f(8,x)=(6*x^5 + 505*x^4 + 3360*x^3 + 6510*x^2 + 3780*x)/(150*x^4 + 1800*x^3 + 6300*x^2 + 8400*x + 3780)
 12485:     //      f(9,x)=(137*x^5 + 2310*x^4 + 9870*x^3 + 15120*x^2 + 7560*x)/(30*x^5 + 900*x^4 + 6300*x^3 + 16800*x^2 + 18900*x + 7560)
 12486:     //      f(10,x)=(5*x^6 + 672*x^5 + 7035*x^4 + 23520*x^3 + 30870*x^2 + 13860*x)/(180*x^5 + 3150*x^4 + 16800*x^3 + 37800*x^2 + 37800*x + 13860)
 12487:     //      echo read("../misc/efp.gp");eval("log1p(x)=log(1+x)");eval("h(k)=if(k==1,1/2,k%2==0,k/(k+1)/4,(k+1)/k/4)");eval("g(n,x,k)=h(k)*x/(1+if(k<n,g(n,x,k+1),0))");eval("f(n,x)=x/(1+if(n<1,0,g(n,x,1)))");for(n=0,30,printf("%4d",floor(closeness2(log1p,f(n,x),sqrt(2)/2-1,sqrt(2)-1)))) | gp -q
 12488:     //       0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28  29  30
 12489:     //       2   6   9  13  16  20  23  27  31  34  38  41  45  48  52  55  59  62  66  70  73  77  80  84  87  91  94  98 101 105 108
 12490:     //
 12491:     //  チェビシェフ展開
 12492:     //    x=(1+u)/(1-u)
 12493:     //    u=(x-1)/(x+1)
 12494:     //    log((1+u)/(1-u))=2*sum[k=0..inf]{u^(2*k+1)/(2*k+1)}
 12495:     //    の係数を調整する
 12496:     //    sqrt(2)/2<=x<=sqrt(2)
 12497:     //    のとき
 12498:     //    2*sqrt(2)-3<=u<=3-2*sqrt(2)
 12499:     //    であるから
 12500:     //    echo read("../misc/efp.gp");eval("f(u)=log((1+u)/(1-u))");a=2*sqrt(2)-3;b=3-2*sqrt(2);for(k=0,30,printf("%4d",floor(closeness2(f,chebyshev(f,a,b,2*k+1),a,b)))) | gp -q
 12501:     //       0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28  29  30
 12502:     //       7  14  21  28  35  42  49  56  63  70  77  84  91  98 105 113 120 127 134 141 148 155 162 169 176 183 190 197 204 211 219
 12503:     //
 12504:     //  expm1を高速に計算できる場合
 12505:     //    組み込み関数を使ってlog(x)=log1p(x-1)の近似値y'を求める
 12506:     //    expm1を使ってx'-1=expm1(y')を正確に求める。これは正確なのでlog(x')=y'である
 12507:     //    log(x)=log(x'*(x/x'))
 12508:     //          =log(x')+log(x/x')
 12509:     //          =y'+log((x'+x-x')/x')
 12510:     //          =y'+log(1+(x-x')/x')
 12511:     //          =y'+log1p((x'-x)/x)
 12512:     //    (x-x')/xは小さいのでlog1p((x-x')/x')は速く収束する
 12513:     //
 12514:     //  AGM
 12515:     //    I(a,b)=int[0..pi/2]{dt/sqrt(a^2*cos(t)^2+b^2*sin(t)^2)}
 12516:     //    T(a,b)=2/pi*I(a,b)=1/M(a,b)
 12517:     //    M(a[0],b[0])=lim[n=inf]{a[n]}=lim[n=inf]{b[n]}
 12518:     //    a[n+1]=(a[n]+b[n])/2
 12519:     //    b[n+1]=sqrt(a[n]*b[n])
 12520:     //    abs(log(x)-[I(1,10^-n)-I(1,10^-n*x)])<n*10^(2-2*n)  (0<x<1)
 12521:     //    echo read("../misc/efp.gp");eval("fi(a,b)=intnum(t=0,Pi/2,1/sqrt(a^2*cos(t)^2+b^2*sin(t)^2))");eval("f(n,x)=fi(1,2^-n)-fi(1,2^-n*x)");printf("%.30f",f(100,2)/f(100,10)) | gp -q
 12522:     //    0.301029995663981195213738894724
 12523:     //    echo read("../misc/efp.gp");eval("g(a,b)=Pi/2/agm(a,b)");eval("f(n,x)=g(1,2^-n)-g(1,2^-n*x)");printf("%.30f",f(100,2)/f(100,10)) | gp -q
 12524:     //    0.301029995663981195213738894724
 12525:     //    perl -e "sub mm{my($a,$b)=@_;while(1){my$t=($a+$b)/2;$t<$a or last;$b=sqrt($a*$b);$a=$t}$a};sub ii{my($a,$b)=@_;atan2(1,1)*2/mm($a,$b)}sub ll{my($x,$n)=@_;ii(1,2**-$n)-ii(1,2**-$n*$x)}printf'    //    %14s  %22s  %22s  %22s%c','x','log(x)','ll(x,31)','abs(ll(x,31)-log(x))',10;for my$k(-10..10){my$x=10**$k;printf'    //    %14.14g  %22.16g  %22.16g  %22.16g%c',$x,log($x),ll($x,31),abs(log($x)-ll($x,31)),10}"
 12526:     //                 x                  log(x)                ll(x,31)    abs(ll(x,31)-log(x))
 12527:     //             1e-10      -23.02585092994046      -23.02585092994045   3.552713678800501e-15
 12528:     //             1e-09      -20.72326583694641       -20.7232658369464   7.105427357601002e-15
 12529:     //             1e-08      -18.42068074395237      -18.42068074395237                       0
 12530:     //             1e-07      -16.11809565095832      -16.11809565095832   3.552713678800501e-15
 12531:     //             1e-06      -13.81551055796427      -13.81551055796427                       0
 12532:     //             1e-05      -11.51292546497023      -11.51292546497024   8.881784197001252e-15
 12533:     //            0.0001      -9.210340371976182       -9.21034037197618    1.77635683940025e-15
 12534:     //             0.001      -6.907755278982137      -6.907755278982144   7.105427357601002e-15
 12535:     //              0.01      -4.605170185988091      -4.605170185988086   4.440892098500626e-15
 12536:     //               0.1      -2.302585092994045       -2.30258509299405   4.884981308350689e-15
 12537:     //                 1                       0                       0                       0
 12538:     //                10       2.302585092994046       2.302585092994047   8.881784197001252e-16
 12539:     //               100       4.605170185988092       4.605170185988079   1.243449787580175e-14
 12540:     //              1000       6.907755278982137       6.907755278981323   8.135714324453147e-13
 12541:     //             10000       9.210340371976184       9.210340371907533   6.865086277230148e-11
 12542:     //            100000       11.51292546497023       11.51292545935356   5.616673348640688e-09
 12543:     //           1000000       13.81551055796427       13.81551012112039   4.368438872859315e-07
 12544:     //          10000000       16.11809565095832       16.11806444854419   3.120241413512304e-05
 12545:     //         100000000       18.42068074395237       18.41880659707298    0.001874146879391247
 12546:     //        1000000000       20.72326583694641        20.6532968557838     0.06996898116260653
 12547:     //       10000000000       23.02585092994046       21.30306063168329       1.722790298257163
 12548:     //    1<xのときはlog(x)=-log(1/x)で計算する
 12549:     //    収束は速いがsqrtが必要なので桁数が少ないときは効率が悪い
 12550:     //
 12551:     public final EFP log () {
 12552:       return this.log (this);
 12553:     }  //efp.log()
 12554:     public final EFP log (EFP x) {
 12555:       int xf = x.flg;
 12556:       if (xf != 0) {  //-x,±0,±Inf,NaN
 12557:         if (xf << 3 < 0) {  //NaN
 12558:           this.flg = N;  //log(NaN)=NaN
 12559:         } else if (xf << 1 < 0) {  //±0
 12560:           epbFpsr |= EPB_FPSR_DZ;
 12561:           epbExceptionOperandExponent = xf & M;
 12562:           epbExceptionOperandMantissa = 0x0000000000000000L;
 12563:           this.flg = M | I;  //log(±0)=-Inf
 12564:         } else if (xf >= 0) {  //+Inf
 12565:           this.flg = P | I;  //log(+Inf)=+Inf
 12566:         } else {  //-x,-Inf
 12567:           epbFpsr |= EPB_FPSR_OE;
 12568:           if (xf << 2 < 0) {  //log(-Inf)=NaN
 12569:             epbExceptionOperandExponent = M | 0x7fff << 16;
 12570:             epbExceptionOperandMantissa = 0x0000000000000000L;
 12571:           } else {  //log(-x)=NaN
 12572:             epbExceptionOperandExponent = M | 0x3fff + x.epp << 16;
 12573:             epbExceptionOperandMantissa = x.dvl;
 12574:           }
 12575:           this.flg = N;  //log(-x)=NaN, log(-Inf)=NaN
 12576:         }
 12577:         return this;
 12578:       }
 12579:       //-x,±0,±Inf,NaN以外
 12580:       if (x.epp == 0 && x.dvl == MSB && x.cvl == 0L) {  //+1
 12581:         this.flg = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //log(1)=±0。RMのときだけ-0
 12582:         return this;
 12583:       }
 12584:       //-x,±0,+1,±Inf,NaN以外
 12585:       this.inner ();
 12586:       if (true) {
 12587:         //1の近くだけlog1p()を使う
 12588:         if ((x.epp == -1 && x.dvl >>> 32 == 0xffffffff00000000L >>> 32) ||  //1-2^32<=x<1
 12589:             (x.epp == 0 && x.dvl >>> 31 == 0x8000000000000000L >>> 31)) {  //1<=x<1+2^-32
 12590:           //return this.inner ().dec (x).outer ().log1p ();
 12591:           //log(1+x)=x-x^2/2+x^3/3
 12592:           EFP t = new EFP ().dec (x);
 12593:           return this.cub (t).div3 ().sub (new EFP ().squ (t).div2 ()).outer ().add (t);
 12594:         }
 12595:       }
 12596:       epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 12597:       EFP v = new EFP (x);
 12598:       v.epp = v.dvl >= 0xb504f333f9de6484L ? -1 : 0;  //SQRT2
 12599:       int k = x.epp - v.epp;  //x=2^k*v, sqrt(2)/2<=v<=sqrt(2)
 12600:       if (true) {  //チェビシェフ展開。[90] 420ns
 12601:         EFP u = new EFP ().dec (v).div (v.inc ());  //u=(v-1)/(v+1)
 12602:         v.isqu (u);  //u^2
 12603:         /*
 12604:         this.imul (LOG_C25, v)
 12605:           .iadd (LOG_C23).imul (v)
 12606:             .iadd (LOG_C21).imul (v)
 12607:               .iadd (LOG_C19).imul (v)
 12608:                 .iadd (LOG_C17).imul (v)
 12609:                   .iadd (LOG_C15).imul (v)
 12610:                     .iadd (LOG_C13).imul (v)
 12611:                       .iadd (LOG_C11).imul (v)
 12612:                         .iadd (LOG_C9).imul (v)
 12613:                           .iadd (LOG_C7).imul (v)
 12614:                             .iadd (LOG_C5).imul (v)
 12615:                               .iadd (LOG_C3).imul (v)
 12616:                                 .iadd (LOG_C1).imul (u)
 12617:                                   .iadd (v.muli (LOG_2, k)).iadd (v.muli (LOG_2A, k));  //log(x)=log(2^k*v)=k*log(2)+log(v)
 12618:          */
 12619:         this.imul (LOG_C27, v)
 12620:           .iadd (LOG_C25).imul (v)
 12621:             .iadd (LOG_C23).imul (v)
 12622:               .iadd (LOG_C21).imul (v)
 12623:                 .iadd (LOG_C19).imul (v)
 12624:                   .iadd (LOG_C17).imul (v)
 12625:                     .iadd (LOG_C15).imul (v)
 12626:                       .iadd (LOG_C13).imul (v)
 12627:                         .iadd (LOG_C11).imul (v)
 12628:                           .iadd (LOG_C9).imul (v)
 12629:                             .iadd (LOG_C7).imul (v)
 12630:                               .iadd (LOG_C5).imul (v)
 12631:                                 .iadd (LOG_C3).imul (v)
 12632:                                   .iadd (LOG_C1).imul (u)
 12633:                                     .iadd (v.muli (LOG_2, k)).iadd (v.muli (LOG_2A, k));  //log(x)=log(2^k*v)=k*log(2)+log(v)
 12634:       } else {  //expm1を使う。[89] 520ns
 12635:         EFP vv1 = new EFP ().dec (v);
 12636:         if (vv1.flg << 1 < 0) {  //log(2^k*1)
 12637:           this.muli (LOG_2, k);  //log(2^k)=k*log(2)
 12638:         } else {
 12639:           EFP yy = ZERO;
 12640:           if (-1023 < vv1.epp) {
 12641:             //  Math.log1p(double)を使ってlog(v)の近似値y'を求める
 12642:             long s = Double.doubleToLongBits (Math.log1p (Double.longBitsToDouble ((long) (vv1.flg | 1023 + vv1.epp << 20) << 32 | vv1.dvl << 1 >>> 12)));
 12643:             if (s != 0L) {
 12644:               int sh = (int) (s >>> 32);
 12645:               yy = new EFP (sh & M, (sh >>> 20 & 2047) - 1023, MSB | s << 12 >>> 1, 0L);  //log(v)の近似値y'
 12646:             }
 12647:           }
 12648:           //  expm1を使ってlog(v')=y'を満たすv'を求める
 12649:           vv1.expm1 (yy);  //v'-1=expm1(y')
 12650:           //  log(v)=log(v')+log1p((v-v')/v')を使ってlog(v)を計算する
 12651:           //  (v-v')/v'は小さいので1次の項だけ加える
 12652:           v.dec ().sub (vv1);  //(v-1)-(v'-1)=v-v'
 12653:           this.rcp (vv1.inc ()).imul (v).iadd (yy)  //y'+(v-v')/v'≒log(v')+log1p((v-v')/v')=log(v)
 12654:             .iadd (v.muli (LOG_2, k)).iadd (v.muli (LOG_2A, k));  //log(x)=log(2^k*v)=k*log(2)+log(v)
 12655:         }
 12656:       }
 12657:       return outer ().finish ();
 12658:     }  //efp.log(EFP)
 12659: 
 12660:     //------------------------------------------------------------------------
 12661:     //x = x.log10 ()
 12662:     //  x=log10(x)
 12663:     //y = y.log10 (x)
 12664:     //  y=log10(x)
 12665:     //  常用対数 common logarithm
 12666:     //
 12667:     //  グラフ
 12668:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{log($_[0])/log(10)});print$g"
 12669:     //    echo read("../misc/efp.gp");eval("log10(x)=log(x)/log(10)");graph(log10) | gp -q
 12670:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 12671:     //    |                                       |                                       |
 12672:     //    |                                       |                                       |
 12673:     //    |                                       |                                       |
 12674:     //    |                                       |                                       |
 12675:     //    +                                       +                                       +
 12676:     //    |                                       |                                       |
 12677:     //    |                                       |                                       |
 12678:     //    |                                       |                                       |
 12679:     //    |                                       |                                       |
 12680:     //    +                                       +                                       +
 12681:     //    |                                       |                                       |
 12682:     //    |                                       |                                       |
 12683:     //    |                                       |                                       |
 12684:     //    |                                       |                                       |
 12685:     //    +                                       +                                       +
 12686:     //    |                                       |                                       |
 12687:     //    |                                       |                               *********
 12688:     //    |                                       |                   *************       |
 12689:     //    |                                       |            ********                   |
 12690:     //    +---------+---------+---------+---------+-------******------+---------+---------+
 12691:     //    |                                       |    ****                               |
 12692:     //    |                                       |  ***                                  |
 12693:     //    |                                       | **                                    |
 12694:     //    |                                       |**                                     |
 12695:     //    +                                       +*                                      +
 12696:     //    |                                       |*                                      |
 12697:     //    |                                       **                                      |
 12698:     //    |                                       *                                       |
 12699:     //    |                                       *                                       |
 12700:     //    +                                       *                                       +
 12701:     //    |                                       *                                       |
 12702:     //    |                                       *                                       |
 12703:     //    |                                       *                                       |
 12704:     //    |                                       *                                       |
 12705:     //    +                                       *                                       +
 12706:     //    |                                       *                                       |
 12707:     //    |                                       *                                       |
 12708:     //    |                                       *                                       |
 12709:     //    |                                       |                                       |
 12710:     //    +---------+---------+---------+---------*---------+---------+---------+---------+
 12711:     //
 12712:     //  対数関数との関係
 12713:     //    log10(x)=log(x)/log(10)
 12714:     //
 12715:     public final EFP log10 () {
 12716:       return this.log10 (this);
 12717:     }  //efp.log10()
 12718:     public final EFP log10 (EFP x) {
 12719:       //return this.log (x).div (LOG_10);  //log(x)/log(10) [90]
 12720:       int xf = x.flg;
 12721:       if (xf != 0) {  //-x,±0,±Inf,NaN
 12722:         if (xf << 3 < 0) {  //NaN
 12723:           this.flg = N;  //log10(NaN)=NaN
 12724:         } else if (xf << 1 < 0) {  //±0
 12725:           epbFpsr |= EPB_FPSR_DZ;
 12726:           epbExceptionOperandExponent = xf & M;
 12727:           epbExceptionOperandMantissa = 0x0000000000000000L;
 12728:           this.flg = M | I;  //log10(±0)=-Inf
 12729:         } else if (xf >= 0) {  //+Inf
 12730:           epbExceptionOperandExponent = 0x7fff << 16;
 12731:           epbExceptionOperandMantissa = 0x0000000000000000L;
 12732:           this.flg = P | I;  //log10(+Inf)=+Inf
 12733:         } else {  //-x,-Inf
 12734:           epbFpsr |= EPB_FPSR_OE;
 12735:           if (xf << 2 < 0) {  //-Inf
 12736:             epbExceptionOperandExponent = M | 0x7fff << 16;
 12737:             epbExceptionOperandMantissa = 0x0000000000000000L;
 12738:           } else {  //-x
 12739:             epbExceptionOperandExponent = M | 0x3fff + x.epp << 16;
 12740:             epbExceptionOperandMantissa = x.dvl;
 12741:           }
 12742:           this.flg = N;  //log10(-x)=NaN, log10(-Inf)=NaN
 12743:         }
 12744:         return this;
 12745:       }
 12746:       //-x,±0,±Inf,NaN以外
 12747:       int xe = x.epp;
 12748:       //log10(1)を特別扱いにする
 12749:       if (xe == 0 && x.dvl == MSB && x.cvl == 0L) {  //log10(1)
 12750:         this.flg = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //log10(1)=±0。RMのときは-0,RN,RZ,RPのときは+0
 12751:         return this;
 12752:       }
 12753:       //log10(10^n)(n>0)を特別扱いにする
 12754:       if (3 <= xe && xe <= 129) {
 12755:         EFP t = ACCURATE_LOG10_BASE[xe];
 12756:         if (t != null && x.dvl == t.dvl && x.cvl == t.cvl) {
 12757:           //結果は正確だがMC68882に合わせて不正確な結果をセットしておく
 12758:           epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 12759:           //  perl -e "for$e(0..129){$n=($e+1)*617>>11;if($e==int(log(10**$n)/log(2))){print$e,' ';}}"
 12760:           //  0 3 6 9 13 16 19 23 26 29 33 36 39 43 46 49 53 56 59 63 66 69 73 76 79 83 86 89 93 96 99 102 106 109 112 116 119 122 126 129 
 12761:           return this.seti ((xe + 1) * 617 >> 11);
 12762:         }
 12763:       }
 12764:       //-x,±0,10^n,±Inf,NaN以外
 12765:       this.inner ();
 12766:       epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 12767:       EFP v = new EFP (x);
 12768:       v.epp = v.dvl >= 0xb504f333f9de6484L ? -1 : 0;  //SQRT2
 12769:       int k = x.epp - v.epp;  //x=2^k*v, sqrt(2)/2<=v<=sqrt(2)
 12770:       EFP u = new EFP ().dec (v).div (v.inc ());  //u=(v-1)/(v+1)
 12771:       v.isqu (u);  //u^2
 12772:       this.imul (LOG10_C27, v)
 12773:         .iadd (LOG10_C25).imul (v)
 12774:           .iadd (LOG10_C23).imul (v)
 12775:             .iadd (LOG10_C21).imul (v)
 12776:               .iadd (LOG10_C19).imul (v)
 12777:                 .iadd (LOG10_C17).imul (v)
 12778:                   .iadd (LOG10_C15).imul (v)
 12779:                     .iadd (LOG10_C13).imul (v)
 12780:                       .iadd (LOG10_C11).imul (v)
 12781:                         .iadd (LOG10_C9).imul (v)
 12782:                           .iadd (LOG10_C7).imul (v)
 12783:                             .iadd (LOG10_C5).imul (v)
 12784:                               .iadd (LOG10_C3).imul (v)
 12785:                                 .iadd (LOG10_C1).imul (u)
 12786:                                   .iadd (u.muli (LOG10_2, k));
 12787:       u.muli (LOG10_2A, k);
 12788:       return this.outer ().add (u);  //log10(x)=log10(2^k*v)=k*log10(2)+log(v) [91]
 12789:     }  //efp.log10()
 12790: 
 12791:     //------------------------------------------------------------------------
 12792:     //x = x.log1p ()
 12793:     //  x=log(1+x)
 12794:     //y = y.log1p (x)
 12795:     //  y=log(1+x)
 12796:     //  1に近い数の自然対数 natural logarithm of number being close to 1
 12797:     //
 12798:     //  グラフ
 12799:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{log(1+$_[0])});print$g"
 12800:     //    echo read("../misc/efp.gp");eval("log1p(x)=log(1+x)");graph(log1p) | gp -q
 12801:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 12802:     //    |                                       |                                       |
 12803:     //    |                                       |                                       |
 12804:     //    |                                       |                                       |
 12805:     //    |                                       |                                       |
 12806:     //    +                                       +                                       +
 12807:     //    |                                       |                                       |
 12808:     //    |                                       |                                       |
 12809:     //    |                                       |                                       |
 12810:     //    |                                       |                                       |
 12811:     //    +                                       +                                       +
 12812:     //    |                                       |                                       |
 12813:     //    |                                       |                                  ******
 12814:     //    |                                       |                          *********    |
 12815:     //    |                                       |                   ********            |
 12816:     //    +                                       +              ******                   +
 12817:     //    |                                       |         ******                        |
 12818:     //    |                                       |     *****                             |
 12819:     //    |                                       |  ****                                 |
 12820:     //    |                                       |***                                    |
 12821:     //    +---------+---------+---------+--------***--------+---------+---------+---------+
 12822:     //    |                                    ***|                                       |
 12823:     //    |                                   **  |                                       |
 12824:     //    |                                  **   |                                       |
 12825:     //    |                                 **    |                                       |
 12826:     //    +                                **     +                                       +
 12827:     //    |                                *      |                                       |
 12828:     //    |                               **      |                                       |
 12829:     //    |                               *       |                                       |
 12830:     //    |                              **       |                                       |
 12831:     //    +                              *        +                                       +
 12832:     //    |                              *        |                                       |
 12833:     //    |                              *        |                                       |
 12834:     //    |                              *        |                                       |
 12835:     //    |                              *        |                                       |
 12836:     //    +                             **        +                                       +
 12837:     //    |                             *         |                                       |
 12838:     //    |                             *         |                                       |
 12839:     //    |                             *         |                                       |
 12840:     //    |                             *         |                                       |
 12841:     //    +---------+---------+---------*---------+---------+---------+---------+---------+
 12842:     //
 12843:     //  メモ
 12844:     //    log1p(x)の存在意義は1に極端に近い値の対数をlog(x)よりも正確に求められることだが、
 12845:     //    これは変数xに1に極端に近い値が入っているときlog(x)よりもlog1p(x-1)の方が正確な結果を返すという意味ではない
 12846:     //    例えば有効桁数が10桁のときxに1.000000001111111111を代入しようとするとxの値は1.000000001になってしまう
 12847:     //    x-1で桁落ちした引数をlog1pに与えたところで結果の精度が高くなるわけがない
 12848:     //    1に極端に近い値を経由せずにlog1p(1.111111111e-9)を計算すれば正確な結果が得られる
 12849:     //
 12850:     //  テイラー展開
 12851:     //    log(1+x)=sum[n=1..inf]{(-1)^(n+1)*x^n/n}
 12852:     //
 12853:     //  チェビシェフ展開
 12854:     //    sqrt(2)/2-1<=x<=sqrt(2)-1
 12855:     //    のとき
 12856:     //    u=x/(x+2)
 12857:     //    x=2*u/(1-u)
 12858:     //    とおくと
 12859:     //    2*sqrt(2)-3<=u<=3-2*sqrt(2)
 12860:     //    log(x)のときと同じ多項式を使う
 12861:     //
 12862:     //  メモ
 12863:     //    log1p(-0)=-0,log1p(+0)=+0に注意する
 12864:     //
 12865:     public final EFP log1p () {
 12866:       return this.log1p (this);
 12867:     }  //efp.log1p()
 12868:     public final EFP log1p (EFP x) {
 12869:       int xf = x.flg;
 12870:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 12871:         if (xf << 3 < 0) {  //NaN
 12872:           this.flg = N;  //log1p(NaN)=NaN
 12873:         } else if (xf << 1 < 0) {  //±0
 12874:           this.flg = xf;  //log1p(±0)=±0
 12875:         } else if (xf >= 0) {  //+Inf
 12876:           this.flg = P | I;  //log1p(+Inf)=+Inf
 12877:         } else {  //-Inf
 12878:           epbFpsr |= EPB_FPSR_OE;
 12879:           epbExceptionOperandExponent = M | 0x7fff << 16;
 12880:           epbExceptionOperandMantissa = 0x0000000000000000L;
 12881:           this.flg = N;  //log1p(-Inf)=NaN
 12882:         }
 12883:         return this;
 12884:       }
 12885:       //±0,±Inf,NaN以外
 12886:       if (xf < 0) {  //x<0
 12887:         if (x.epp == 0 && x.dvl == MSB && x.cvl == 0L) {  //x==-1
 12888:           epbFpsr |= EPB_FPSR_DZ;  //MC68882はlog1p(-1)でDZをセットする
 12889:           epbExceptionOperandExponent = M | 0x3fff << 16;
 12890:           epbExceptionOperandMantissa = 0x8000000000000000L;
 12891:           this.flg = M | I;  //log1p(-1)=-Inf
 12892:           return this;
 12893:         } else if (x.epp >= 0) {  //x<-1
 12894:           epbFpsr |= EPB_FPSR_OE;
 12895:           epbExceptionOperandExponent = M | 0x3fff + x.epp << 16;
 12896:           epbExceptionOperandMantissa = x.dvl;
 12897:           this.flg = N;  //log1p(x<-1)=NaN
 12898:           return this;
 12899:         }
 12900:       }
 12901:       epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 12902:       //if (x.epp < -2 || (x.epp == -2 && x.dvl <= (xf < 0 ? 0x95f619980c4336f7L : 0xd413cccfe7799211L))) {  //sqrt(2)/2-1<=x<=sqrt(2)-1
 12903:       if (LOG1P_A.le (x) && x.le (LOG1P_B)) {  //sqrt(2)/2-1<=x<=sqrt(2)-1
 12904:         int savedFpsr = epbFpsr;
 12905:         this.inner ();
 12906:         if (this == x) {
 12907:           x = new EFP (x);
 12908:         }
 12909:         EFP u = new EFP ().iadd (x, TWO).rcpdiv (x);  //u=x/(x+2)
 12910:         EFP v = new EFP ().isqu (u);  //u^2
 12911:         /*
 12912:         return this.imul (LOG_C25, v)
 12913:           .iadd (LOG_C23).imul (v)
 12914:             .iadd (LOG_C21).imul (v)
 12915:               .iadd (LOG_C19).imul (v)
 12916:                 .iadd (LOG_C17).imul (v)
 12917:                   .iadd (LOG_C15).imul (v)
 12918:                     .iadd (LOG_C13).imul (v)
 12919:                       .iadd (LOG_C11).imul (v)
 12920:                         .iadd (LOG_C9).imul (v)
 12921:                           .iadd (LOG_C7).imul (v)
 12922:                             .iadd (LOG_C5).imul (v)
 12923:                               .iadd (LOG_C3).imul (v)
 12924:                                 .iadd (LOG_C1).outer ().mul (u);
 12925:          */
 12926:         this.imul (LOG_C27, v)
 12927:           .iadd (LOG_C25).imul (v)
 12928:             .iadd (LOG_C23).imul (v)
 12929:               .iadd (LOG_C21).imul (v)
 12930:                 .iadd (LOG_C19).imul (v)
 12931:                   .iadd (LOG_C17).imul (v)
 12932:                     .iadd (LOG_C15).imul (v)
 12933:                       .iadd (LOG_C13).imul (v)
 12934:                         .iadd (LOG_C11).imul (v)
 12935:                           .iadd (LOG_C9).imul (v)
 12936:                             .iadd (LOG_C7).imul (v)
 12937:                               .iadd (LOG_C5).imul (v)
 12938:                                 .iadd (LOG_C3).imul (v)
 12939:                                   .iadd (LOG_C1).outer ().mul (u);
 12940:         return this.originLowerLower (x).correctUnderflow (savedFpsr);
 12941:       }
 12942:       return this.inner ().inc (x).outer ().log ();  //log(1+x)
 12943:     }  //efp.log1p()
 12944: 
 12945:     //------------------------------------------------------------------------
 12946:     //x = x.log2 ()
 12947:     //  x=log2(x)
 12948:     //y = y.log2 (x)
 12949:     //  y=log2(x)
 12950:     //  二進対数 binary logarithm
 12951:     //
 12952:     //  グラフ
 12953:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{log($_[0])/log(2)});print$g"
 12954:     //    echo read("../misc/efp.gp");eval("log2(x)=log(x)/log(2)");graph(log2) | gp -q
 12955:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 12956:     //    |                                       |                                       |
 12957:     //    |                                       |                                       |
 12958:     //    |                                       |                                       |
 12959:     //    |                                       |                                       |
 12960:     //    +                                       +                                       +
 12961:     //    |                                       |                                       |
 12962:     //    |                                       |                                       |
 12963:     //    |                                       |                                       |
 12964:     //    |                                       |                                       |
 12965:     //    +                                       +                                    ****
 12966:     //    |                                       |                               ******  |
 12967:     //    |                                       |                           *****       |
 12968:     //    |                                       |                        ****           |
 12969:     //    |                                       |                    *****              |
 12970:     //    +                                       +                  ***                  +
 12971:     //    |                                       |               ****                    |
 12972:     //    |                                       |             ***                       |
 12973:     //    |                                       |           ***                         |
 12974:     //    |                                       |          **                           |
 12975:     //    +---------+---------+---------+---------+--------***--------+---------+---------+
 12976:     //    |                                       |       **                              |
 12977:     //    |                                       |      **                               |
 12978:     //    |                                       |     **                                |
 12979:     //    |                                       |    **                                 |
 12980:     //    +                                       +    *                                  +
 12981:     //    |                                       |   **                                  |
 12982:     //    |                                       |   *                                   |
 12983:     //    |                                       |  **                                   |
 12984:     //    |                                       |  *                                    |
 12985:     //    +                                       + **                                    +
 12986:     //    |                                       | *                                     |
 12987:     //    |                                       | *                                     |
 12988:     //    |                                       | *                                     |
 12989:     //    |                                       |**                                     |
 12990:     //    +                                       +*                                      +
 12991:     //    |                                       |*                                      |
 12992:     //    |                                       |*                                      |
 12993:     //    |                                       |*                                      |
 12994:     //    |                                       |*                                      |
 12995:     //    +---------+---------+---------+---------+*--------+---------+---------+---------+
 12996:     //
 12997:     //  対数関数との関係
 12998:     //    log2(x)=log(x)/log(2)
 12999:     //
 13000:     //  チェビシェフ展開
 13001:     //    指数部を分離する
 13002:     //      log2(x)=log2(2^k*v)=k+log2(v)
 13003:     //      1<=v<2
 13004:     //    定義域を0に近付ける
 13005:     //      -(1-t)/(1+t)=(2-t)/(2+t)をtについて解くとt=sqrt(2)
 13006:     //      u=(v-sqrt(2))/(v+sqrt(2))
 13007:     //      2*sqrt(2)-3<=u<3-2*sqrt(2)
 13008:     //      v=sqrt(2)*(1+u)/(1-u)
 13009:     //      log2(v)=log2(sqrt(2)*(1+u)/(1-u))
 13010:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{my($u)=@_;log(sqrt(2)*(1+$u)/(1-$u))/log(2)});print$g"
 13011:     //    +---------+---------+---------+---------+-------*-+---------+---------+---------+
 13012:     //    |                                       |       *                               |
 13013:     //    |                                       |       *                               |
 13014:     //    |                                       |      **                               |
 13015:     //    |                                       |      *                                |
 13016:     //    +                                       +      *                                +
 13017:     //    |                                       |     **                                |
 13018:     //    |                                       |     *                                 |
 13019:     //    |                                       |     *                                 |
 13020:     //    |                                       |    **                                 |
 13021:     //    +                                       +    *                                  +
 13022:     //    |                                       |   **                                  |
 13023:     //    |                                       |  **                                   |
 13024:     //    |                                       |  *                                    |
 13025:     //    |                                       | **                                    |
 13026:     //    +                                       +**                                     +
 13027:     //    |                                       |*                                      |
 13028:     //    |                                       **                                      |
 13029:     //    |                                      **                                       |
 13030:     //    |                                      *|                                       |
 13031:     //    +---------+---------+---------+-------**+---------+---------+---------+---------+
 13032:     //    |                                    ** |                                       |
 13033:     //    |                                    *  |                                       |
 13034:     //    |                                   **  |                                       |
 13035:     //    |                                  **   |                                       |
 13036:     //    +                                  *    +                                       +
 13037:     //    |                                 **    |                                       |
 13038:     //    |                                 *     |                                       |
 13039:     //    |                                 *     |                                       |
 13040:     //    |                                **     |                                       |
 13041:     //    +                                *      +                                       +
 13042:     //    |                                *      |                                       |
 13043:     //    |                               **      |                                       |
 13044:     //    |                               *       |                                       |
 13045:     //    |                               *       |                                       |
 13046:     //    +                               *       +                                       +
 13047:     //    |                              **       |                                       |
 13048:     //    |                              *        |                                       |
 13049:     //    |                              *        |                                       |
 13050:     //    |                              *        |                                       |
 13051:     //    +---------+---------+---------+*--------+---------+---------+---------+---------+
 13052:     //    奇関数にするためlog2(v)-1/2をチェビシェフ展開する
 13053:     //    echo read("../misc/efp.gp");eval("f(u)=log(sqrt(2)*(1+u)/(1-u))/log(2)-1/2");a=2*sqrt(2)-3;b=3-2*sqrt(2);forstep(n=1,31,2,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))); | gp -q
 13054:     //       1   3   5   7   9  11  13  15  17  19  21  23  25  27  29  31
 13055:     //       7  14  21  28  35  42  49  56  63  70  77  84  91  98 105 113
 13056:     //
 13057:     public final EFP log2 () {
 13058:       return this.log2 (this);
 13059:     }  //efp.log2()
 13060:     public final EFP log2 (EFP x) {
 13061:       //return this.log (x).div (LOG_2);  //log(x)/log(2)
 13062:       int xf = x.flg;
 13063:       if (xf != 0) {  //-x,±0,±Inf,NaN
 13064:         if (xf << 3 < 0) {  //NaN
 13065:           this.flg = N;  //log2(NaN)=NaN
 13066:         } else if (xf << 1 < 0) {  //±0
 13067:           epbFpsr |= EPB_FPSR_DZ;
 13068:           epbExceptionOperandExponent = xf & M;
 13069:           epbExceptionOperandMantissa = 0x0000000000000000L;
 13070:           this.flg = M | I;  //log2(±0)=-Inf
 13071:         } else if (xf >= 0) {  //+Inf
 13072:           this.flg = P | I;  //log2(+Inf)=+Inf
 13073:         } else {  //-x,-Inf
 13074:           epbFpsr |= EPB_FPSR_OE;
 13075:           if (xf << 2 < 0) {  //-Inf
 13076:             epbExceptionOperandExponent = M | 0x7fff << 16;
 13077:             epbExceptionOperandMantissa = 0x0000000000000000L;
 13078:           } else {  //-x
 13079:             epbExceptionOperandExponent = M | 0x3fff + x.epp << 16;
 13080:             epbExceptionOperandMantissa = x.dvl;
 13081:           }
 13082:           this.flg = N;  //log2(-x)=NaN, log2(-Inf)=NaN
 13083:         }
 13084:         return this;
 13085:       }
 13086:       //-x,±0,±Inf,NaN以外
 13087:       //log2(2^n)を特別扱いにする
 13088:       if (x.dvl == MSB && x.cvl == 0L) {  //log2(2^n)
 13089:         if (x.epp == 0) {  //log2(1)
 13090:           this.flg = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //log2(1)=±0。RMのときは-0,RN,RZ,RPのときは+0
 13091:         } else {  //log2(2^n)(n>0)
 13092:           //結果は正確だがMC68882に合わせて不正確な結果をセットしておく
 13093:           epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 13094:           this.seti (x.epp);  //log2(2^n)=n
 13095:         }
 13096:         return this;
 13097:       }
 13098:       //-x,±0,2^n,±Inf,NaN以外
 13099:       this.inner ();
 13100:       epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 13101:       EFP v = new EFP (x);
 13102:       v.epp = v.dvl >= 0xb504f333f9de6484L ? -1 : 0;  //SQRT2
 13103:       int k = x.epp - v.epp;  //x=2^k*v, sqrt(2)/2<=v<=sqrt(2)
 13104:       EFP u = new EFP ().dec (v).div (v.inc ());  //u=(v-1)/(v+1)
 13105:       v.isqu (u);  //u^2
 13106:       this.imul (LOG2_C27, v)
 13107:         .iadd (LOG2_C25).imul (v)
 13108:           .iadd (LOG2_C23).imul (v)
 13109:             .iadd (LOG2_C21).imul (v)
 13110:               .iadd (LOG2_C19).imul (v)
 13111:                 .iadd (LOG2_C17).imul (v)
 13112:                   .iadd (LOG2_C15).imul (v)
 13113:                     .iadd (LOG2_C13).imul (v)
 13114:                       .iadd (LOG2_C11).imul (v)
 13115:                         .iadd (LOG2_C9).imul (v)
 13116:                           .iadd (LOG2_C7).imul (v)
 13117:                             .iadd (LOG2_C5).imul (v)
 13118:                               .iadd (LOG2_C3).imul (v)
 13119:                                 .iadd (LOG2_C1).imul (u);
 13120:       u.seti (k);
 13121:       return this.outer ().add (u);  //log2(x)=log2(2^k*v)=k+log2(v)
 13122:     }  //efp.log2()
 13123: 
 13124:     //------------------------------------------------------------------------
 13125:     //x = x.lgamma ()
 13126:     //  x=log(Γ(x))
 13127:     //y = y.lgamma (x)
 13128:     //  y=log(Γ(x))
 13129:     //  ログガンマ関数
 13130:     //
 13131:     //  グラフ
 13132:     //    echo read("../misc/efp.gp");graph(lngamma) | gp -q
 13133:     //    +---------+---------+---------+---------*---------+---------+---------+---------+
 13134:     //    |                                       *                                       |
 13135:     //    |                                       *                                       |
 13136:     //    |                                       *                                       |
 13137:     //    |                                       *                                       |
 13138:     //    +                                       **                                      +
 13139:     //    |                                       |*                                      |
 13140:     //    |                                       |*                                      |
 13141:     //    |                                       |*                                      |
 13142:     //    |                                       |*                                      |
 13143:     //    +                                       +*                                      +
 13144:     //    |                                       |**                                    **
 13145:     //    |                                       | *                                   **|
 13146:     //    |                                       | *                                 *** |
 13147:     //    |                                       | **                              ***   |
 13148:     //    +                                       +  **                           ***     +
 13149:     //    |                                       |   *                         ***       |
 13150:     //    |                                       |   **                      ***         |
 13151:     //    |                                       |    ***                 ****           |
 13152:     //    |                                       |      ***            ****              |
 13153:     //    +---------+---------+---------+---------+--------*****---******-------+---------+
 13154:     //    |                                       |            *****                      |
 13155:     //    |                                       |                                       |
 13156:     //    |                                       |                                       |
 13157:     //    |                                       |                                       |
 13158:     //    +                                       +                                       +
 13159:     //    |                                       |                                       |
 13160:     //    |                                       |                                       |
 13161:     //    |                                       |                                       |
 13162:     //    |                                       |                                       |
 13163:     //    +                                       +                                       +
 13164:     //    |                                       |                                       |
 13165:     //    |                                       |                                       |
 13166:     //    |                                       |                                       |
 13167:     //    |                                       |                                       |
 13168:     //    +                                       +                                       +
 13169:     //    |                                       |                                       |
 13170:     //    |                                       |                                       |
 13171:     //    |                                       |                                       |
 13172:     //    |                                       |                                       |
 13173:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 13174:     //
 13175:     //  0<x<13のとき
 13176:     //    Γ(x)=Γ(x+1)/x
 13177:     //    log(Γ(x))=log(Γ(x+1))-log(x)
 13178:     //    で13<=xまで持っていく
 13179:     //    log(Γ(12+α))=log(Γ(13+α))-log(12+α)
 13180:     //    log(Γ(11+α))=log(Γ(12+α))-log(11+α)
 13181:     //                =log(Γ(13+α))-log(12+α)-log(11+α)
 13182:     //                =log(Γ(13+α))-log((12+α)*(11+α))
 13183:     //    log(Γ(10+α))=log(Γ(11+α))-log(10+α)
 13184:     //                =log(Γ(13+α))-log((12+α)*(11+α))-log(10+α)
 13185:     //                =log(Γ(13+α))-log((12+α)*(11+α)*(10+α))
 13186:     //                :
 13187:     //    すなわち
 13188:     //    d=1
 13189:     //    while x<13
 13190:     //      d*=x
 13191:     //      x+=1
 13192:     //    としてからlog(Γ(x))を計算してlog(Γ(x))-log(d)を返す
 13193:     //
 13194:     //  13<=xのとき
 13195:     //    log(Γ(x))=(x-1/2)*log(x)-x+log(2*π)/2+Σ[n=1..∞]{B(2*n)/(2*n*(2*n-1)*x^(2*n-1))]
 13196:     //
 13197:     public final EFP lgamma () {
 13198:       return this.lgamma (this);
 13199:     }  //efp.lgamma()
 13200:     public final EFP lgamma (EFP x) {
 13201:       int xf = x.flg;
 13202:       if (xf != 0) {  //-x,±0,±Inf,NaN
 13203:         this.flg = (xf == (P | Z) || xf == (P | I) ? P | I :  //lgamma(+0)=lgamma(+Inf)=+Inf
 13204:                     N);  //lgamma(NaN)=lgamma(-Inf)=lgamma(-x)=lgamma(-0)=NaN
 13205:         return this;
 13206:       }
 13207:       //+x
 13208:       this.inner ();
 13209:       x = new EFP (x);
 13210:       EFP d = null;
 13211:       if (x.lt (THIRTEEN)) {
 13212:         d = new EFP (ONE);
 13213:         do {
 13214:           d.mul (x);
 13215:           x.inc ();
 13216:         } while (x.lt (THIRTEEN));
 13217:       }
 13218:       EFP t = new EFP ().rcp (x);  //1/x
 13219:       EFP t2 = new EFP ().squ (t);  //1/x^2
 13220:       this.mul (LGAMMA_C14, t2)
 13221:         .add (LGAMMA_C13).mul (t2)
 13222:           .add (LGAMMA_C12).mul (t2)
 13223:             .add (LGAMMA_C11).mul (t2)
 13224:               .add (LGAMMA_C10).mul (t2)
 13225:                 .add (LGAMMA_C9).mul (t2)
 13226:                   .add (LGAMMA_C8).mul (t2)
 13227:                     .add (LGAMMA_C7).mul (t2)
 13228:                       .add (LGAMMA_C6).mul (t2)
 13229:                         .add (LGAMMA_C5).mul (t2)
 13230:                           .add (LGAMMA_C4).mul (t2)
 13231:                             .add (LGAMMA_C3).mul (t2)
 13232:                               .add (LGAMMA_C2).mul (t2)
 13233:                                 .add (LGAMMA_C1).mul (t)
 13234:                                   .add (LOGTWOPI_2).sub (x);  //-x+log(2*π)/2+Σ[n=1..14]{B(2*n)/(2*n*(2*n-1)*x^(2*n-1))]
 13235:       t.sub (x, ONE_2);  //x-1/2
 13236:       this.add (x.log ().mul (t));  //(x-1/2)*log(x)-x+log(2*π)/2+Σ[n=1..14]{B(2*n)/(2*n*(2*n-1)*x^(2*n-1))]
 13237:       if (d != null) {
 13238:         this.sub (d.log ());  //log(Γ(x))-log(d)
 13239:       }
 13240:       return this.outer ().finish ();
 13241:     }  //efp.lgamma(EFP)
 13242: 
 13243:     //------------------------------------------------------------------------
 13244:     //b = x.lt (y)
 13245:     //  b=x<y
 13246:     //  より小さいか
 13247:     //
 13248:     //  -Inf==-Inf<-x<-0==+0<+x<+Inf==+Inf
 13249:     //
 13250:     //  NaNの扱い
 13251:     //    どちらかがNaNのときはfalseを返す
 13252:     //
 13253:     public boolean lt (EFP y) {
 13254:       int xf = this.flg;
 13255:       int yf = y.flg;
 13256:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
 13257:         return EFP_LT_TABLE[xf >>> 28] << (yf >>> 28 - 1) < 0;
 13258:       }
 13259:       //両方±0,±Inf,NaN以外
 13260:       if (xf != yf) {  //両方±0,±Inf,NaN以外で符号が違う
 13261:         return xf < yf;
 13262:       }
 13263:       //両方±0,±Inf,NaN以外で符号が同じ
 13264:       int s;
 13265:       long t;
 13266:       return (xf >= 0 ? 1 : -1) * ((s = this.epp - y.epp) != 0 ? s >= 0 ? 1 : -1 :
 13267:                                    (t = this.dvl - y.dvl) != 0L ? t >= 0L ? 1 : -1 :
 13268:                                    (t = (this.cvl >>> 1) - (y.cvl >>> 1)) != 0L ? t >= 0L ? 1 : -1 :
 13269:                                    0) < 0;
 13270:     }  //efp.lt(EFP)
 13271: 
 13272:     //------------------------------------------------------------------------
 13273:     //x = x.max (y)
 13274:     //  x=max(x,y)
 13275:     //z = z.max (x, y)
 13276:     //  z=max(x,y)
 13277:     //  最大値
 13278:     //
 13279:     //  どちらかがNaNのときはNaN
 13280:     //  -0<+0とみなされる
 13281:     //
 13282:     public final EFP max (EFP y) {
 13283:       return this.max (this, y);
 13284:     }  //efp.max(EFP)
 13285:     public final EFP max (EFP x, EFP y) {
 13286:       if ((x.flg | y.flg) << 3 < 0) {  //どちらかがNaN
 13287:         this.flg = N;  //NaN
 13288:       } else if (x.compareTo (y) >= 0) {  //両方NaN以外でx>=y。cmpは-0>=+0なので不可
 13289:         this.flg = x.flg;  //x
 13290:         this.epp = x.epp;
 13291:         this.dvl = x.dvl;
 13292:         this.cvl = x.cvl;
 13293:       } else {  //両方NaN以外でx<y
 13294:         this.flg = y.flg;  //y
 13295:         this.epp = y.epp;
 13296:         this.dvl = y.dvl;
 13297:         this.cvl = y.cvl;
 13298:       }
 13299:       return this;
 13300:     }  //efp.max(EFP)
 13301: 
 13302:     //------------------------------------------------------------------------
 13303:     //x = x.min (y)
 13304:     //  x=min(x,y)
 13305:     //z = z.min (x, y)
 13306:     //  z=min(x,y)
 13307:     //  最小値
 13308:     //
 13309:     //  どちらかがNaNのときはNaN
 13310:     //  -0<+0とみなされる
 13311:     //
 13312:     public final EFP min (EFP y) {
 13313:       return this.min (this, y);
 13314:     }  //efp.min(EFP)
 13315:     public final EFP min (EFP x, EFP y) {
 13316:       if ((x.flg | y.flg) << 3 < 0) {  //どちらかがNaN
 13317:         this.flg = N;  //NaN
 13318:       } else if (x.compareTo (y) <= 0) {  //両方NaN以外でx<=y。cmpは+0<=-0なので不可
 13319:         this.flg = x.flg;  //x
 13320:         this.epp = x.epp;
 13321:         this.dvl = x.dvl;
 13322:         this.cvl = x.cvl;
 13323:       } else {  //両方NaN以外でx<y
 13324:         this.flg = y.flg;  //y
 13325:         this.epp = y.epp;
 13326:         this.dvl = y.dvl;
 13327:         this.cvl = y.cvl;
 13328:       }
 13329:       return this;
 13330:     }  //efp.min(EFP)
 13331: 
 13332:     //------------------------------------------------------------------------
 13333:     //x = x.mul (y)
 13334:     //  x*=y
 13335:     //z = z.mul (x, y)
 13336:     //  z=x*y
 13337:     //  乗算
 13338:     //
 13339:     //  (xn/xd)*(yn/yd)
 13340:     //    =(xn*yn)/(xd*yd)
 13341:     //
 13342:     //  分割統治法による多倍長乗算
 13343:     //    2分割
 13344:     //      (a*x+b)*(c*x+d) = a*c*x^2+(a*d+b*c)*x+b*d
 13345:     //                        (1)      (2) (3)    (4)
 13346:     //                      = a*c*(x^2+x)+b*d*(x+1)-(a-b)*(c-d)*x
 13347:     //                        (1)         (2)           (3)
 13348:     //        (3)の積は(a,b),(c,d)の大小関係によって加える場合と引く場合がある
 13349:     //      桁数を2倍にしたとき乗算のコストが3倍になる
 13350:     //      桁数n=2^kのときのコストは3^k=3^log2(n)=n^log2(3)≒n^1.585
 13351:     //    3分割
 13352:     //      (a*x^2+b*x+c)*(d*x^2+e*x+f) = a*d*x^4+(a*e+b*d)*x^3+(a*f+b*e+c*d)*x^2+(b*f+c*e)*x+c*f
 13353:     //                                    (1)      (2) (3)       (4) (5) (6)       (7) (8)    (9)
 13354:     //                                  = a*d*(x^4+x^3+x^2)+b*e*(x^3+x^2+x)+c*f*(x^2+x+1)-(a-b)*(d-e)*x^3-(a-c)*(d-f)*x^2-(b-c)*(e-f)*x
 13355:     //                                    (1)               (2)             (3)               (4)             (5)             (6)
 13356:     //        (4),(5),(6)の積は(a,b,c),(d,e,f)の大小関係によって加える場合と引く場合がある
 13357:     //      桁数を3倍にしたとき乗算のコストが6倍になる
 13358:     //      桁数n=3^kのときのコストは6^k=6^log3(n)=n^log3(6)≒n^1.631
 13359:     //    分割統治法による多倍長乗算では3分割よりも2分割の方が効率が良い
 13360:     //
 13361:     //    32bit,30bit,30bitに分割する場合
 13362:     //       x^6    x^5    x^4    x^3    x^2    x^1    x^0
 13363:     //      +---------------+-------------+-------------+
 13364:     //      |      a*d      |     c*f     |     c*f     |
 13365:     //      +---------------+-------------+-------------+
 13366:     //             +---------------+-------------+
 13367:     //             |      a*d      |     c*f     |
 13368:     //             +---------------+-------------+
 13369:     //                    +---------------+
 13370:     //                    |      a*d      |
 13371:     //                    +---------------+
 13372:     //               +-------------+-------------+
 13373:     //               |     b*e     |     b*e     |
 13374:     //               +-------------+-------------+
 13375:     //                      +-------------+
 13376:     //                      |     b*e     |
 13377:     //                      +-------------+
 13378:     //             +---------------+-------------+
 13379:     //             | -(a-b)*(d-e)  |-(b-c)*(e-f) |
 13380:     //             +---------------+-------------+
 13381:     //                    +---------------+
 13382:     //                    | -(a-c)*(d-f)  |
 13383:     //                    +---------------+
 13384:     //       x^6    x^5    x^4    x^3    x^2    x^1    x^0
 13385:     //
 13386:     public final EFP mul (EFP y) {
 13387:       int xf = this.flg;
 13388:       int yf = y.flg;
 13389:       {
 13390:         int o;
 13391:         if ((o = xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
 13392:           if (o << 3 < 0) {  //どちらかがNaNのときNaN
 13393:             this.flg = N;
 13394:           } else if ((o &= (Z | I)) == (Z | I)) {  //±0*±InfのときNaN
 13395:             epbFpsr |= EPB_FPSR_OE;
 13396:             if (yf << 1 < 0) {  //±Inf*±0
 13397:               epbExceptionOperandExponent = yf & M;
 13398:               epbExceptionOperandMantissa = 0x0000000000000000L;
 13399:             } else {  //±0*±Inf
 13400:               epbExceptionOperandExponent = yf & M | 0x7fff << 16;
 13401:               epbExceptionOperandMantissa = 0x0000000000000000L;
 13402:             }
 13403:             this.flg = N;
 13404:           } else {  //両方±0,NaN以外でどちらかが±Infのとき±Inf、両方±Inf,NaN以外でどちらかが±0のとき±0
 13405:             this.flg = (xf ^ yf) & M | o;
 13406:           }
 13407:           return this;
 13408:         }
 13409:       }
 13410:       //符号
 13411:       int zf = xf ^ yf;  //符号が同じならばP、異なればM。ここでセットされるのはMだけ
 13412:       //指数部
 13413:       int ze = this.epp + y.epp;
 13414:       //以下はLEN<=92bitでなければならない
 13415:       //掛ける
 13416:       //  92bitの仮数部を32bit,30bit,30bitに3分割する
 13417:       //                                                                  111111111122222222223333333333444444444455555555556666
 13418:       //                                                        0123456789012345678901234567890123456789012345678901234567890123
 13419:       //                                                 x.dvl  HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMLL
 13420:       //                                                 x.cvl  LLLLLLLLLLLLLLLLLLLLLLLLLLLL000000000000000000000000000000000000
 13421:       long xh = this.dvl;  //                               xh  HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMLL
 13422:       long yh = y.dvl;
 13423:       long xl = (xh << -2 | this.cvl >>> 2) >>> -30;  //xh<<-2  LL00000000000000000000000000000000000000000000000000000000000000
 13424:       //                                             x.cvl>>>2  00LLLLLLLLLLLLLLLLLLLLLLLLLLLL0000000000000000000000000000000000
 13425:       //                                      xh<<-2|x.cvl>>>2  LLLLLLLLLLLLLLLLLLLLLLLLLLLLLL0000000000000000000000000000000000
 13426:       //                                                    xl  0000000000000000000000000000000000LLLLLLLLLLLLLLLLLLLLLLLLLLLLLL
 13427:       long yl = (yh << -2 | y.cvl >>> 2) >>> -30;
 13428:       long xm = xh << 32 >>> -30;  //                   xh<<32  MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMLL00000000000000000000000000000000
 13429:       //                                                    xm  0000000000000000000000000000000000MMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
 13430:       long ym = yh << 32 >>> -30;
 13431:       xh >>>= 32;  //                                       xh  00000000000000000000000000000000HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 13432:       yh >>>= 32;
 13433:       //           xh xm xl
 13434:       //  *        yh ym yl
 13435:       //  -----------------
 13436:       //              xl*yl
 13437:       //           xl*ym
 13438:       //           yl*xm
 13439:       //        xl*yh
 13440:       //        yl*xh
 13441:       //        xm*ym
 13442:       //     xm*yh
 13443:       //     ym*xh
 13444:       //  xh*yh
 13445:       //  -----------------
 13446:       //  zd    zc    zb
 13447:       long zb = xl * yl;  //60bit
 13448:       long zc = xl * yh + yl * xh + xm * ym;  //62bit*2+60bit
 13449:       long zd = xh * yh;  //64bit
 13450:       xl *= ym;  //xl*ym。60bit
 13451:       yl *= xm;  //yl*xm。60bit
 13452:       xm *= yh;  //xm*yh。62bit
 13453:       ym *= xh;  //ym*xh。62bit
 13454:       zb += (xl << -30 >>> 4) + (yl << -30 >>> 4);  //xl*ymの下位30bit<<30,yl*xmの下位30bit<<30。60bit*3
 13455:       zc += (xm << -30 >>> 4) + (ym << -30 >>> 4);  //xm*yhの下位30bit<<30,ym*xhの下位30bit<<30。62bit*2+60bit*3
 13456:       zc += (xl >>> 30) + (yl >>> 30) + (zb >>> -4);  //xl*ymの上位30bit,yl*xmの上位30bit,zbからのキャリー4bit。62bit*2+60bit*3+30bit*2+4bitで64bitに収まる
 13457:       zd += (xm >>> 30) + (ym >>> 30) + (zc >>> -4);  //xm*yhの上位32bit,ym*xhの上位32bit,zcからのキャリー4bit。積は92*2=184bitで64bit,60bit,60bitに収まる
 13458:       zb <<= 4;  //sticky bitにゴミが残っていると困るので使用済みのキャリーを押し出す
 13459:       zc <<= 4;  //使用済みのキャリーを押し出してzdとzcの隙間を詰める。zcの下位4bitに隙間ができるがsticky bitなのでzbを詰める必要はない
 13460:       //正規化する
 13461:       //  zdのMSBに隙間がないときは整数部が1+1=2bitになっているので指数部を1増やす
 13462:       if (zd < 0L) {
 13463:         ze++;
 13464:       } else {
 13465:         zd = zd << 1 | zc >>> -1;
 13466:         zc <<= 1;
 13467:       }
 13468:       return this.finish2 (zf, ze, zd, zc, zb);
 13469:     }  //efp.mul(EFP)
 13470:     public final EFP imul (EFP y) {
 13471:       int xf = this.flg;
 13472:       int yf = y.flg;
 13473:       {
 13474:         int o;
 13475:         if ((o = xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
 13476:           if (o << 3 < 0) {  //どちらかがNaNのときNaN
 13477:             this.flg = N;
 13478:           } else if ((o &= (Z | I)) == (Z | I)) {  //±0*±InfのときNaN
 13479:             epbFpsr |= EPB_FPSR_OE;
 13480:             if (yf << 1 < 0) {  //±Inf*±0
 13481:               epbExceptionOperandExponent = yf & M;
 13482:               epbExceptionOperandMantissa = 0x0000000000000000L;
 13483:             } else {  //±0*±Inf
 13484:               epbExceptionOperandExponent = yf & M | 0x7fff << 16;
 13485:               epbExceptionOperandMantissa = 0x0000000000000000L;
 13486:             }
 13487:             this.flg = N;
 13488:           } else {  //両方±0,NaN以外でどちらかが±Infのとき±Inf、両方±Inf,NaN以外でどちらかが±0のとき±0
 13489:             this.flg = (xf ^ yf) & M | o;
 13490:           }
 13491:           return this;
 13492:         }
 13493:       }
 13494:       //符号
 13495:       int zf = xf ^ yf;  //符号が同じならばP、異なればM。ここでセットされるのはMだけ
 13496:       //指数部
 13497:       int ze = this.epp + y.epp;
 13498:       //以下はLEN<=92bitでなければならない
 13499:       //掛ける
 13500:       //  92bitの仮数部を32bit,30bit,30bitに3分割する
 13501:       //                                                                  111111111122222222223333333333444444444455555555556666
 13502:       //                                                        0123456789012345678901234567890123456789012345678901234567890123
 13503:       //                                                 x.dvl  HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMLL
 13504:       //                                                 x.cvl  LLLLLLLLLLLLLLLLLLLLLLLLLLLL000000000000000000000000000000000000
 13505:       long xh = this.dvl;  //                               xh  HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMLL
 13506:       long yh = y.dvl;
 13507:       long xl = (xh << -2 | this.cvl >>> 2) >>> -30;  //xh<<-2  LL00000000000000000000000000000000000000000000000000000000000000
 13508:       //                                             x.cvl>>>2  00LLLLLLLLLLLLLLLLLLLLLLLLLLLL0000000000000000000000000000000000
 13509:       //                                      xh<<-2|x.cvl>>>2  LLLLLLLLLLLLLLLLLLLLLLLLLLLLLL0000000000000000000000000000000000
 13510:       //                                                    xl  0000000000000000000000000000000000LLLLLLLLLLLLLLLLLLLLLLLLLLLLLL
 13511:       long yl = (yh << -2 | y.cvl >>> 2) >>> -30;
 13512:       long xm = xh << 32 >>> -30;  //                   xh<<32  MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMLL00000000000000000000000000000000
 13513:       //                                                    xm  0000000000000000000000000000000000MMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
 13514:       long ym = yh << 32 >>> -30;
 13515:       xh >>>= 32;  //                                       xh  00000000000000000000000000000000HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 13516:       yh >>>= 32;
 13517:       //           xh xm xl
 13518:       //  *        yh ym yl
 13519:       //  -----------------
 13520:       //              xl*yl
 13521:       //           xl*ym
 13522:       //           yl*xm
 13523:       //        xl*yh
 13524:       //        yl*xh
 13525:       //        xm*ym
 13526:       //     xm*yh
 13527:       //     ym*xh
 13528:       //  xh*yh
 13529:       //  -----------------
 13530:       //  zd    zc    zb
 13531:       long zb = xl * yl;  //60bit
 13532:       long zc = xl * yh + yl * xh + xm * ym;  //62bit*2+60bit
 13533:       long zd = xh * yh;  //64bit
 13534:       xl *= ym;  //xl*ym。60bit
 13535:       yl *= xm;  //yl*xm。60bit
 13536:       xm *= yh;  //xm*yh。62bit
 13537:       ym *= xh;  //ym*xh。62bit
 13538:       zb += (xl << -30 >>> 4) + (yl << -30 >>> 4);  //xl*ymの下位30bit<<30,yl*xmの下位30bit<<30。60bit*3
 13539:       zc += (xm << -30 >>> 4) + (ym << -30 >>> 4);  //xm*yhの下位30bit<<30,ym*xhの下位30bit<<30。62bit*2+60bit*3
 13540:       zc += (xl >>> 30) + (yl >>> 30) + (zb >>> -4);  //xl*ymの上位30bit,yl*xmの上位30bit,zbからのキャリー4bit。62bit*2+60bit*3+30bit*2+4bitで64bitに収まる
 13541:       zd += (xm >>> 30) + (ym >>> 30) + (zc >>> -4);  //xm*yhの上位32bit,ym*xhの上位32bit,zcからのキャリー4bit。積は92*2=184bitで64bit,60bit,60bitに収まる
 13542:       zb <<= 4;  //sticky bitにゴミが残っていると困るので使用済みのキャリーを押し出す
 13543:       zc <<= 4;  //使用済みのキャリーを押し出してzdとzcの隙間を詰める。zcの下位4bitに隙間ができるがsticky bitなのでzbを詰める必要はない
 13544:       //正規化する
 13545:       //  zdのMSBに隙間がないときは整数部が1+1=2bitになっているので指数部を1増やす
 13546:       if (zd < 0L) {
 13547:         ze++;
 13548:       } else {
 13549:         zd = zd << 1 | zc >>> -1;
 13550:         zc <<= 1;
 13551:       }
 13552:       return this.ifinish (zf, ze, zd, zc, zb);
 13553:     }  //efp.imul(EFP)
 13554:     public final EFP mul (EFP x, EFP y) {  //11.7
 13555:       int xf = x.flg;
 13556:       int yf = y.flg;
 13557:       {
 13558:         int o;
 13559:         if ((o = xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
 13560:           if (o << 3 < 0) {  //どちらかがNaNのときNaN
 13561:             this.flg = N;
 13562:           } else if ((o &= (Z | I)) == (Z | I)) {  //±0*±InfのときNaN
 13563:             epbFpsr |= EPB_FPSR_OE;
 13564:             if (yf << 1 < 0) {  //±Inf*±0
 13565:               epbExceptionOperandExponent = yf & M;
 13566:               epbExceptionOperandMantissa = 0x0000000000000000L;
 13567:             } else {  //±0*±Inf
 13568:               epbExceptionOperandExponent = yf & M | 0x7fff << 16;
 13569:               epbExceptionOperandMantissa = 0x0000000000000000L;
 13570:             }
 13571:             this.flg = N;
 13572:           } else {  //両方±0,NaN以外でどちらかが±Infのとき±Inf、両方±Inf,NaN以外でどちらかが±0のとき±0
 13573:             this.flg = (xf ^ yf) & M | o;
 13574:           }
 13575:           return this;
 13576:         }
 13577:       }
 13578:       //符号
 13579:       int zf = xf ^ yf;  //符号が同じならばP、異なればM。ここでセットされるのはMだけ
 13580:       //指数部
 13581:       int ze = x.epp + y.epp;
 13582:       //以下はLEN<=92bitでなければならない
 13583:       //掛ける
 13584:       //  92bitの仮数部を32bit,30bit,30bitに3分割する
 13585:       //                                                                  111111111122222222223333333333444444444455555555556666
 13586:       //                                                        0123456789012345678901234567890123456789012345678901234567890123
 13587:       //                                                 x.dvl  HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMLL
 13588:       //                                                 x.cvl  LLLLLLLLLLLLLLLLLLLLLLLLLLLL000000000000000000000000000000000000
 13589:       long xh = x.dvl;  //                                  xh  HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMLL
 13590:       long yh = y.dvl;
 13591:       long xl = (xh << -2 | x.cvl >>> 2) >>> -30;  //   xh<<-2  LL00000000000000000000000000000000000000000000000000000000000000
 13592:       //                                             x.cvl>>>2  00LLLLLLLLLLLLLLLLLLLLLLLLLLLL0000000000000000000000000000000000
 13593:       //                                      xh<<-2|x.cvl>>>2  LLLLLLLLLLLLLLLLLLLLLLLLLLLLLL0000000000000000000000000000000000
 13594:       //                                                    xl  0000000000000000000000000000000000LLLLLLLLLLLLLLLLLLLLLLLLLLLLLL
 13595:       long yl = (yh << -2 | y.cvl >>> 2) >>> -30;
 13596:       long xm = xh << 32 >>> -30;  //                   xh<<32  MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMLL00000000000000000000000000000000
 13597:       //                                                    xm  0000000000000000000000000000000000MMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
 13598:       long ym = yh << 32 >>> -30;
 13599:       xh >>>= 32;  //                                       xh  00000000000000000000000000000000HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 13600:       yh >>>= 32;
 13601:       //           xh xm xl
 13602:       //  *        yh ym yl
 13603:       //  -----------------
 13604:       //              xl*yl
 13605:       //           xl*ym
 13606:       //           yl*xm
 13607:       //        xl*yh
 13608:       //        yl*xh
 13609:       //        xm*ym
 13610:       //     xm*yh
 13611:       //     ym*xh
 13612:       //  xh*yh
 13613:       //  -----------------
 13614:       //  zd    zc    zb
 13615:       long zb = xl * yl;  //60bit
 13616:       long zc = xl * yh + yl * xh + xm * ym;  //62bit*2+60bit
 13617:       long zd = xh * yh;  //64bit
 13618:       xl *= ym;  //xl*ym。60bit
 13619:       yl *= xm;  //yl*xm。60bit
 13620:       xm *= yh;  //xm*yh。62bit
 13621:       ym *= xh;  //ym*xh。62bit
 13622:       zb += (xl << -30 >>> 4) + (yl << -30 >>> 4);  //xl*ymの下位30bit<<30,yl*xmの下位30bit<<30。60bit*3
 13623:       zc += (xm << -30 >>> 4) + (ym << -30 >>> 4);  //xm*yhの下位30bit<<30,ym*xhの下位30bit<<30。62bit*2+60bit*3
 13624:       zc += (xl >>> 30) + (yl >>> 30) + (zb >>> -4);  //xl*ymの上位30bit,yl*xmの上位30bit,zbからのキャリー4bit。62bit*2+60bit*3+30bit*2+4bitで64bitに収まる
 13625:       zd += (xm >>> 30) + (ym >>> 30) + (zc >>> -4);  //xm*yhの上位32bit,ym*xhの上位32bit,zcからのキャリー4bit。積は92*2=184bitで64bit,60bit,60bitに収まる
 13626:       zb <<= 4;  //sticky bitにゴミが残っていると困るので使用済みのキャリーを押し出す
 13627:       zc <<= 4;  //使用済みのキャリーを押し出してzdとzcの隙間を詰める。zcの下位4bitに隙間ができるがsticky bitなのでzbを詰める必要はない
 13628:       //正規化する
 13629:       //  zdのMSBに隙間がないときは整数部が1+1=2bitになっているので指数部を1増やす
 13630:       if (zd < 0L) {
 13631:         ze++;
 13632:       } else {
 13633:         zd = zd << 1 | zc >>> -1;
 13634:         zc <<= 1;
 13635:       }
 13636:       return this.finish2 (zf, ze, zd, zc, zb);
 13637:     }  //efp.mul(EFP,EFP)
 13638:     public final EFP imul (EFP x, EFP y) {  //11.7
 13639:       int xf = x.flg;
 13640:       int yf = y.flg;
 13641:       {
 13642:         int o;
 13643:         if ((o = xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
 13644:           if (o << 3 < 0) {  //どちらかがNaNのときNaN
 13645:             this.flg = N;
 13646:           } else if ((o &= (Z | I)) == (Z | I)) {  //±0*±InfのときNaN
 13647:             epbFpsr |= EPB_FPSR_OE;
 13648:             if (yf << 1 < 0) {  //±Inf*±0
 13649:               epbExceptionOperandExponent = yf & M;
 13650:               epbExceptionOperandMantissa = 0x0000000000000000L;
 13651:             } else {  //±0*±Inf
 13652:               epbExceptionOperandExponent = yf & M | 0x7fff << 16;
 13653:               epbExceptionOperandMantissa = 0x0000000000000000L;
 13654:             }
 13655:             this.flg = N;
 13656:           } else {  //両方±0,NaN以外でどちらかが±Infのとき±Inf、両方±Inf,NaN以外でどちらかが±0のとき±0
 13657:             this.flg = (xf ^ yf) & M | o;
 13658:           }
 13659:           return this;
 13660:         }
 13661:       }
 13662:       //符号
 13663:       int zf = xf ^ yf;  //符号が同じならばP、異なればM。ここでセットされるのはMだけ
 13664:       //指数部
 13665:       int ze = x.epp + y.epp;
 13666:       //以下はLEN<=92bitでなければならない
 13667:       //掛ける
 13668:       //  92bitの仮数部を32bit,30bit,30bitに3分割する
 13669:       //                                                                  111111111122222222223333333333444444444455555555556666
 13670:       //                                                        0123456789012345678901234567890123456789012345678901234567890123
 13671:       //                                                 x.dvl  HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMLL
 13672:       //                                                 x.cvl  LLLLLLLLLLLLLLLLLLLLLLLLLLLL000000000000000000000000000000000000
 13673:       long xh = x.dvl;  //                                  xh  HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMLL
 13674:       long yh = y.dvl;
 13675:       long xl = (xh << -2 | x.cvl >>> 2) >>> -30;  //   xh<<-2  LL00000000000000000000000000000000000000000000000000000000000000
 13676:       //                                             x.cvl>>>2  00LLLLLLLLLLLLLLLLLLLLLLLLLLLL0000000000000000000000000000000000
 13677:       //                                      xh<<-2|x.cvl>>>2  LLLLLLLLLLLLLLLLLLLLLLLLLLLLLL0000000000000000000000000000000000
 13678:       //                                                    xl  0000000000000000000000000000000000LLLLLLLLLLLLLLLLLLLLLLLLLLLLLL
 13679:       long yl = (yh << -2 | y.cvl >>> 2) >>> -30;
 13680:       long xm = xh << 32 >>> -30;  //                   xh<<32  MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMLL00000000000000000000000000000000
 13681:       //                                                    xm  0000000000000000000000000000000000MMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
 13682:       long ym = yh << 32 >>> -30;
 13683:       xh >>>= 32;  //                                       xh  00000000000000000000000000000000HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 13684:       yh >>>= 32;
 13685:       //           xh xm xl
 13686:       //  *        yh ym yl
 13687:       //  -----------------
 13688:       //              xl*yl
 13689:       //           xl*ym
 13690:       //           yl*xm
 13691:       //        xl*yh
 13692:       //        yl*xh
 13693:       //        xm*ym
 13694:       //     xm*yh
 13695:       //     ym*xh
 13696:       //  xh*yh
 13697:       //  -----------------
 13698:       //  zd    zc    zb
 13699:       long zb = xl * yl;  //60bit
 13700:       long zc = xl * yh + yl * xh + xm * ym;  //62bit*2+60bit
 13701:       long zd = xh * yh;  //64bit
 13702:       xl *= ym;  //xl*ym。60bit
 13703:       yl *= xm;  //yl*xm。60bit
 13704:       xm *= yh;  //xm*yh。62bit
 13705:       ym *= xh;  //ym*xh。62bit
 13706:       zb += (xl << -30 >>> 4) + (yl << -30 >>> 4);  //xl*ymの下位30bit<<30,yl*xmの下位30bit<<30。60bit*3
 13707:       zc += (xm << -30 >>> 4) + (ym << -30 >>> 4);  //xm*yhの下位30bit<<30,ym*xhの下位30bit<<30。62bit*2+60bit*3
 13708:       zc += (xl >>> 30) + (yl >>> 30) + (zb >>> -4);  //xl*ymの上位30bit,yl*xmの上位30bit,zbからのキャリー4bit。62bit*2+60bit*3+30bit*2+4bitで64bitに収まる
 13709:       zd += (xm >>> 30) + (ym >>> 30) + (zc >>> -4);  //xm*yhの上位32bit,ym*xhの上位32bit,zcからのキャリー4bit。積は92*2=184bitで64bit,60bit,60bitに収まる
 13710:       zb <<= 4;  //sticky bitにゴミが残っていると困るので使用済みのキャリーを押し出す
 13711:       zc <<= 4;  //使用済みのキャリーを押し出してzdとzcの隙間を詰める。zcの下位4bitに隙間ができるがsticky bitなのでzbを詰める必要はない
 13712:       //正規化する
 13713:       //  zdのMSBに隙間がないときは整数部が1+1=2bitになっているので指数部を1増やす
 13714:       if (zd < 0L) {
 13715:         ze++;
 13716:       } else {
 13717:         zd = zd << 1 | zc >>> -1;
 13718:         zc <<= 1;
 13719:       }
 13720:       return this.ifinish (zf, ze, zd, zc, zb);
 13721:     }  //efp.imul(EFP,EFP)
 13722: 
 13723:     //------------------------------------------------------------------------
 13724:     //x = x.mul2 ()
 13725:     //  x*=2
 13726:     //y = y.mul2 (x)
 13727:     //  y=x*2
 13728:     //  2倍
 13729:     //
 13730:     //  グラフ
 13731:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{2*$_[0]});print$g"
 13732:     //    +---------+---------+---------+---------+---------+---------**--------+---------+
 13733:     //    |                                       |                  **                   |
 13734:     //    |                                       |                 **                    |
 13735:     //    |                                       |                **                     |
 13736:     //    |                                       |               **                      |
 13737:     //    +                                       +              **                       +
 13738:     //    |                                       |             **                        |
 13739:     //    |                                       |            **                         |
 13740:     //    |                                       |           **                          |
 13741:     //    |                                       |          **                           |
 13742:     //    +                                       +         **                            +
 13743:     //    |                                       |        **                             |
 13744:     //    |                                       |       **                              |
 13745:     //    |                                       |      **                               |
 13746:     //    |                                       |     **                                |
 13747:     //    +                                       +    **                                 +
 13748:     //    |                                       |   **                                  |
 13749:     //    |                                       |  **                                   |
 13750:     //    |                                       | **                                    |
 13751:     //    |                                       |**                                     |
 13752:     //    +---------+---------+---------+---------**--------+---------+---------+---------+
 13753:     //    |                                      **                                       |
 13754:     //    |                                     **|                                       |
 13755:     //    |                                    ** |                                       |
 13756:     //    |                                   **  |                                       |
 13757:     //    +                                  **   +                                       +
 13758:     //    |                                 **    |                                       |
 13759:     //    |                                **     |                                       |
 13760:     //    |                               **      |                                       |
 13761:     //    |                              **       |                                       |
 13762:     //    +                             **        +                                       +
 13763:     //    |                            **         |                                       |
 13764:     //    |                           **          |                                       |
 13765:     //    |                          **           |                                       |
 13766:     //    |                         **            |                                       |
 13767:     //    +                        **             +                                       +
 13768:     //    |                       **              |                                       |
 13769:     //    |                      **               |                                       |
 13770:     //    |                     **                |                                       |
 13771:     //    |                    **                 |                                       |
 13772:     //    +---------+---------**--------+---------+---------+---------+---------+---------+
 13773:     //    echo read("../misc/efp.gp");eval("mul2(x)=x*2");graph(mul2) | gp -q
 13774:     //    +---------+---------+---------+---------+---------+---------*---------+---------+
 13775:     //    |                                       |                  *                    |
 13776:     //    |                                       |                 *                     |
 13777:     //    |                                       |                *                      |
 13778:     //    |                                       |               *                       |
 13779:     //    +                                       +              *                        +
 13780:     //    |                                       |             *                         |
 13781:     //    |                                       |            *                          |
 13782:     //    |                                       |           *                           |
 13783:     //    |                                       |          *                            |
 13784:     //    +                                       +         *                             +
 13785:     //    |                                       |        *                              |
 13786:     //    |                                       |       *                               |
 13787:     //    |                                       |      *                                |
 13788:     //    |                                       |     *                                 |
 13789:     //    +                                       +    *                                  +
 13790:     //    |                                       |   *                                   |
 13791:     //    |                                       |  *                                    |
 13792:     //    |                                       | *                                     |
 13793:     //    |                                       |*                                      |
 13794:     //    +---------+---------+---------+---------*---------+---------+---------+---------+
 13795:     //    |                                      *|                                       |
 13796:     //    |                                     * |                                       |
 13797:     //    |                                    *  |                                       |
 13798:     //    |                                   *   |                                       |
 13799:     //    +                                  *    +                                       +
 13800:     //    |                                 *     |                                       |
 13801:     //    |                                *      |                                       |
 13802:     //    |                               *       |                                       |
 13803:     //    |                              *        |                                       |
 13804:     //    +                             *         +                                       +
 13805:     //    |                            *          |                                       |
 13806:     //    |                           *           |                                       |
 13807:     //    |                          *            |                                       |
 13808:     //    |                         *             |                                       |
 13809:     //    +                        *              +                                       +
 13810:     //    |                       *               |                                       |
 13811:     //    |                      *                |                                       |
 13812:     //    |                     *                 |                                       |
 13813:     //    |                    *                  |                                       |
 13814:     //    +---------+---------*---------+---------+---------+---------+---------+---------+
 13815:     //
 13816:     public final EFP mul2 () {
 13817:       return this.finish (this.flg, this.epp + 1, this.dvl, this.cvl, 0L);
 13818:     }  //efp.mul2()
 13819:     public final EFP imul2 () {
 13820:       this.epp++;
 13821:       return this;
 13822:     }  //efp.imul2()
 13823:     public final EFP mul2 (EFP x) {
 13824:       return this.finish (x.flg, x.epp + 1, x.dvl, x.cvl, 0L);
 13825:     }  //efp.mul2(EFP)
 13826:     public final EFP imul2 (EFP x) {
 13827:       this.flg = x.flg;
 13828:       this.epp = x.epp + 1;
 13829:       this.dvl = x.dvl;
 13830:       this.cvl = x.cvl;
 13831:       return this;
 13832:     }  //efp.imul2(EFP)
 13833: 
 13834:     //------------------------------------------------------------------------
 13835:     //x = x.mul3 ()
 13836:     //  x*=3
 13837:     //y = y.mul3 (x)
 13838:     //  y=x*3
 13839:     //  3倍
 13840:     //
 13841:     //  グラフ
 13842:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{3*$_[0]});print$g"
 13843:     //    echo read("../misc/efp.gp");eval("mul3(x)=x*3");graph(mul3) | gp -q
 13844:     //    +---------+---------+---------+---------+---------+--**-----+---------+---------+
 13845:     //    |                                       |           **                          |
 13846:     //    |                                       |           *                           |
 13847:     //    |                                       |          **                           |
 13848:     //    |                                       |         **                            |
 13849:     //    +                                       +         *                             +
 13850:     //    |                                       |        **                             |
 13851:     //    |                                       |       **                              |
 13852:     //    |                                       |       *                               |
 13853:     //    |                                       |      **                               |
 13854:     //    +                                       +     **                                +
 13855:     //    |                                       |     *                                 |
 13856:     //    |                                       |    **                                 |
 13857:     //    |                                       |   **                                  |
 13858:     //    |                                       |   *                                   |
 13859:     //    +                                       +  **                                   +
 13860:     //    |                                       | **                                    |
 13861:     //    |                                       | *                                     |
 13862:     //    |                                       |**                                     |
 13863:     //    |                                       **                                      |
 13864:     //    +---------+---------+---------+---------*---------+---------+---------+---------+
 13865:     //    |                                      **                                       |
 13866:     //    |                                     **|                                       |
 13867:     //    |                                     * |                                       |
 13868:     //    |                                    ** |                                       |
 13869:     //    +                                   **  +                                       +
 13870:     //    |                                   *   |                                       |
 13871:     //    |                                  **   |                                       |
 13872:     //    |                                 **    |                                       |
 13873:     //    |                                 *     |                                       |
 13874:     //    +                                **     +                                       +
 13875:     //    |                               **      |                                       |
 13876:     //    |                               *       |                                       |
 13877:     //    |                              **       |                                       |
 13878:     //    |                             **        |                                       |
 13879:     //    +                             *         +                                       +
 13880:     //    |                            **         |                                       |
 13881:     //    |                           **          |                                       |
 13882:     //    |                           *           |                                       |
 13883:     //    |                          **           |                                       |
 13884:     //    +---------+---------+-----**--+---------+---------+---------+---------+---------+
 13885:     //
 13886:     public final EFP mul3 () {
 13887:       return this.muli (this, 3);
 13888:     }  //efp.mul3()
 13889:     public final EFP mul3 (EFP x) {
 13890:       //return this.muli (x, 3);  //x*3
 13891:       int xf = x.flg;
 13892:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 13893:         this.flg = xf;
 13894:         return this;
 13895:       }
 13896:       //±0,±Inf,NaN以外
 13897:       int ze = x.epp + 1;
 13898:       long zd = x.dvl;
 13899:       long zc = x.cvl;
 13900:       long t = zc;
 13901:       zc += (zc >>> 1);  //bit63が1→0のときcから溢れている
 13902:       zd += (zd >>> 1) + ((zc & ~t) >>> -1);  //bit63が1→0のときdから溢れている
 13903:       if (zd >= 0L) {  //2bit増えた
 13904:         zc = zd << -1 | zc >>> 1;
 13905:         zd = MSB | zd >>> 1;
 13906:         ze++;
 13907:       }
 13908:       return this.finish (xf, ze, zd, zc, 0L);
 13909:     }  //efp.mul3(EFP)
 13910: 
 13911:     //------------------------------------------------------------------------
 13912:     //x = x.muli (n)
 13913:     //  x*=n
 13914:     //z = z.muli (x, n)
 13915:     //  z=x*n
 13916:     //  int乗算
 13917:     //
 13918:     public final EFP muli (int n) {
 13919:       return this.muli (this, n);
 13920:     }  //efp.muli(int)
 13921:     public final EFP muli (EFP x, int n) {
 13922:       //return this.mul (x, new EFP (n));  //x*n
 13923:       int xf = x.flg;
 13924:       if (n == 0) {  //0倍
 13925:         this.flg = (xf & (I | N)) != 0 ? N : xf | Z;  //±Inf*0=NaN, NaN*0=NaN, ±0*0=±0, ±x*0=±0
 13926:         return this;
 13927:       }
 13928:       if (xf << 1 != 0) {  //xが±0,±Inf,NaN
 13929:         this.flg = xf << 3 < 0 ? N : xf ^ (n & M);  //NaN*±n=NaN, ±Inf*±n=±Inf, ±0*±n=±0
 13930:         return this;
 13931:       }
 13932:       //両方±0,±Inf,NaN以外
 13933:       int ze = x.epp;
 13934:       long zd = x.dvl;
 13935:       long zc = x.cvl;
 13936:       if (n < 0) {  //乗数が負
 13937:         xf ^= M;
 13938:         if (n == 0x80000000) {
 13939:           ze += 31;
 13940:           if ((short) ze != ze) {  //オーバーフロー
 13941:             epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 13942:             epbExceptionOperandExponent = xf;
 13943:             epbExceptionOperandMantissa = zd;
 13944:             return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | xf >>> 31]).finish ();  //±Inf
 13945:           }
 13946:           this.flg = xf;
 13947:           this.epp = ze;
 13948:           this.dvl = zd;
 13949:           this.cvl = zc;
 13950:           return this;
 13951:         }
 13952:         n = -n;
 13953:       }
 13954:       if (n > 1) {
 13955:         long y = (long) n;  //0x80000000は処理済みなので0xffffffffLでマスクする必要はない
 13956:         //掛ける
 13957:         //     x0 x1 x2
 13958:         //  *        y0
 13959:         //  -----------
 13960:         //        x2*y0
 13961:         //     x1*y0
 13962:         //  x0*y0
 13963:         //  -----------
 13964:         //     zd    zc
 13965:         zc = (zc >>> 32) * y;
 13966:         long t = (zd & 0xffffffffL) * y + (zc >>> 32);
 13967:         zc = t << 32 | (zc & 0xffffffffL);
 13968:         zd = (zd >>> 32) * y + (t >>> 32);
 13969:         //正規化する
 13970:         int o = Long.numberOfLeadingZeros (zd);
 13971:         ze += 32 - o;
 13972:         if (o > 0) {
 13973:           zd = zd << o | zc >>> -o;
 13974:           zc <<= o;
 13975:         }
 13976:       }
 13977:       return this.finish (xf, ze, zd, zc, 0L);
 13978:     }  //efp.muli(EFP,int)
 13979: 
 13980:     //------------------------------------------------------------------------
 13981:     //x = x.mulpi ()
 13982:     //  x*=pi
 13983:     //y = y.mulpi (x)
 13984:     //  y=x*pi
 13985:     //  円周率倍
 13986:     //
 13987:     //  グラフ
 13988:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{4*atan2(1,1)*$_[0]});print$g"
 13989:     //    echo read("../misc/efp.gp");eval("mulpi(x)=x*Pi");graph(mulpi) | gp -q
 13990:     //    +---------+---------+---------+---------+---------+-**------+---------+---------+
 13991:     //    |                                       |           *                           |
 13992:     //    |                                       |          **                           |
 13993:     //    |                                       |          *                            |
 13994:     //    |                                       |         **                            |
 13995:     //    +                                       +        **                             +
 13996:     //    |                                       |        *                              |
 13997:     //    |                                       |       **                              |
 13998:     //    |                                       |      **                               |
 13999:     //    |                                       |      *                                |
 14000:     //    +                                       +     **                                +
 14001:     //    |                                       |    **                                 |
 14002:     //    |                                       |    *                                  |
 14003:     //    |                                       |   **                                  |
 14004:     //    |                                       |   *                                   |
 14005:     //    +                                       +  **                                   +
 14006:     //    |                                       | **                                    |
 14007:     //    |                                       | *                                     |
 14008:     //    |                                       |**                                     |
 14009:     //    |                                       **                                      |
 14010:     //    +---------+---------+---------+---------*---------+---------+---------+---------+
 14011:     //    |                                      **                                       |
 14012:     //    |                                     **|                                       |
 14013:     //    |                                     * |                                       |
 14014:     //    |                                    ** |                                       |
 14015:     //    +                                   **  +                                       +
 14016:     //    |                                   *   |                                       |
 14017:     //    |                                  **   |                                       |
 14018:     //    |                                  *    |                                       |
 14019:     //    |                                 **    |                                       |
 14020:     //    +                                **     +                                       +
 14021:     //    |                                *      |                                       |
 14022:     //    |                               **      |                                       |
 14023:     //    |                              **       |                                       |
 14024:     //    |                              *        |                                       |
 14025:     //    +                             **        +                                       +
 14026:     //    |                            **         |                                       |
 14027:     //    |                            *          |                                       |
 14028:     //    |                           **          |                                       |
 14029:     //    |                           *           |                                       |
 14030:     //    +---------+---------+------**-+---------+---------+---------+---------+---------+
 14031:     //
 14032:     public final EFP mulpi () {
 14033:       return this.mul (this, PI);
 14034:     }  //efp.mulpi()
 14035:     public final EFP mulpi (EFP x) {
 14036:       return this.mul (x, PI);  //x*pi
 14037:     }  //efp.mulpi(EFP)
 14038: 
 14039:     //------------------------------------------------------------------------
 14040:     //z = z.imulw (w, x, y)
 14041:     //  z+w=x*y
 14042:     //  倍精度乗算
 14043:     //  zはz.imul(x,y)の結果と等しい
 14044:     //  zはnearest-evenで丸められる
 14045:     //  wの符号はzの符号と同じとは限らない
 14046:     //  wの絶対値はulp(z)/2以下
 14047:     //  結果は常に正確
 14048:     //
 14049:     public final EFP imulw (EFP w, EFP x, EFP y) {
 14050:       int xf = x.flg;
 14051:       int yf = y.flg;
 14052:       {
 14053:         int o;
 14054:         if ((o = xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
 14055:           if (o << 3 < 0) {  //どちらかがNaNのときNaN
 14056:             this.flg = N;
 14057:           } else if ((o &= (Z | I)) == (Z | I)) {  //±0*±InfのときNaN
 14058:             epbFpsr |= EPB_FPSR_OE;
 14059:             if (yf << 1 < 0) {  //±Inf*±0
 14060:               epbExceptionOperandExponent = yf & M;
 14061:               epbExceptionOperandMantissa = 0x0000000000000000L;
 14062:             } else {  //±0*±Inf
 14063:               epbExceptionOperandExponent = yf & M | 0x7fff << 16;
 14064:               epbExceptionOperandMantissa = 0x0000000000000000L;
 14065:             }
 14066:             this.flg = N;
 14067:           } else {  //両方±0,NaN以外でどちらかが±Infのとき±Inf、両方±Inf,NaN以外でどちらかが±0のとき±0
 14068:             this.flg = (xf ^ yf) & M | o;
 14069:           }
 14070:           w.flg = this.flg;  //zが±0,±Inf,NaNのときwも±0,±Inf,NaN
 14071:           return this;
 14072:         }
 14073:       }
 14074:       //符号
 14075:       int zf = xf ^ yf;  //符号が同じならばP、異なればM。ここでセットされるのはMだけ
 14076:       //指数部
 14077:       int ze = x.epp + y.epp;
 14078:       //以下はLEN<=92bitでなければならない
 14079:       //掛ける
 14080:       //  92bitの仮数部を32bit,30bit,30bitに3分割する
 14081:       //                                                                  111111111122222222223333333333444444444455555555556666
 14082:       //                                                        0123456789012345678901234567890123456789012345678901234567890123
 14083:       //                                                 x.dvl  HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMLL
 14084:       //                                                 x.cvl  LLLLLLLLLLLLLLLLLLLLLLLLLLLL000000000000000000000000000000000000
 14085:       long xh = x.dvl;  //                                  xh  HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMLL
 14086:       long yh = y.dvl;
 14087:       long xl = (xh << -2 | x.cvl >>> 2) >>> -30;  //   xh<<-2  LL00000000000000000000000000000000000000000000000000000000000000
 14088:       //                                             x.cvl>>>2  00LLLLLLLLLLLLLLLLLLLLLLLLLLLL0000000000000000000000000000000000
 14089:       //                                      xh<<-2|x.cvl>>>2  LLLLLLLLLLLLLLLLLLLLLLLLLLLLLL0000000000000000000000000000000000
 14090:       //                                                    xl  0000000000000000000000000000000000LLLLLLLLLLLLLLLLLLLLLLLLLLLLLL
 14091:       long yl = (yh << -2 | y.cvl >>> 2) >>> -30;
 14092:       long xm = xh << 32 >>> -30;  //                   xh<<32  MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMLL00000000000000000000000000000000
 14093:       //                                                    xm  0000000000000000000000000000000000MMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
 14094:       long ym = yh << 32 >>> -30;
 14095:       xh >>>= 32;  //                                       xh  00000000000000000000000000000000HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 14096:       yh >>>= 32;
 14097:       //           xh xm xl
 14098:       //  *        yh ym yl
 14099:       //  -----------------
 14100:       //              xl*yl
 14101:       //           xl*ym
 14102:       //           yl*xm
 14103:       //        xl*yh
 14104:       //        yl*xh
 14105:       //        xm*ym
 14106:       //     xm*yh
 14107:       //     ym*xh
 14108:       //  xh*yh
 14109:       //  -----------------
 14110:       //  zd    zc    zb
 14111:       long zb = xl * yl;  //60bit
 14112:       long zc = xl * yh + yl * xh + xm * ym;  //62bit*2+60bit
 14113:       long zd = xh * yh;  //64bit
 14114:       xl *= ym;  //xl*ym。60bit
 14115:       yl *= xm;  //yl*xm。60bit
 14116:       xm *= yh;  //xm*yh。62bit
 14117:       ym *= xh;  //ym*xh。62bit
 14118:       zb += (xl << -30 >>> 4) + (yl << -30 >>> 4);  //xl*ymの下位30bit<<30,yl*xmの下位30bit<<30。60bit*3
 14119:       zc += (xm << -30 >>> 4) + (ym << -30 >>> 4);  //xm*yhの下位30bit<<30,ym*xhの下位30bit<<30。62bit*2+60bit*3
 14120:       zc += (xl >>> 30) + (yl >>> 30) + (zb >>> -4);  //xl*ymの上位30bit,yl*xmの上位30bit,zbからのキャリー4bit。62bit*2+60bit*3+30bit*2+4bitで64bitに収まる
 14121:       zd += (xm >>> 30) + (ym >>> 30) + (zc >>> -4);  //xm*yhの上位32bit,ym*xhの上位32bit,zcからのキャリー4bit。積は92*2=184bitで64bit,60bit,60bitに収まる
 14122:       zb <<= 4;  //使用済みのキャリーを押し出す
 14123:       zc = zc << 4 | zb >>> -4;  //使用済みのキャリーを押し出してzbから4bit持ってくる
 14124:       zb <<= 4;
 14125:       //上位を正規化する
 14126:       //  zdのMSBに隙間がないときは整数部が1+1=2bitになっているので指数部を1増やす
 14127:       if (zd < 0L) {
 14128:         ze++;
 14129:       } else {
 14130:         zd = zd << 1 | zc >>> -1;
 14131:         zc = zc << 1 | zb >>> -1;
 14132:         zb <<= 1;
 14133:       }
 14134:       //積を上位と下位に分ける
 14135:       //                111111111122222222223333333333444444444455555555556666
 14136:       //      0123456789012345678901234567890123456789012345678901234567890123
 14137:       //  zd  HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 14138:       //  zc  hhhhhhhhhhhhhhhhhhhhhhhhhhhhLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL
 14139:       //  zb  llllllllllllllllllllllllllllllllllllllllllllllllllllllll00000000
 14140:       //  zd  HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 14141:       //  zc  hhhhhhhhhhhhhhhhhhhhhhhhhhhh000000000000000000000000000000000000
 14142:       //  wd  LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLllllllllllllllllllllllllllll
 14143:       //  wc  llllllllllllllllllllllllllll000000000000000000000000000000000000
 14144:       int wf = zf;
 14145:       int we = ze - LEN;
 14146:       long wd = zc << LEN - 64 | zb >>> -(LEN - 64);
 14147:       long wc = zb << LEN - 64;
 14148:       zc &= -LSB;
 14149:       //zb = 0L;
 14150:       //下位の絶対値を上位の1/2ulp以下にする
 14151:       if (wd < 0L && (zc & LSB | wd << 1 | wc) != 0L) {  //guard bitが1かつLSBとround bitとsticky bitのいずれかが0でない
 14152:         //下位からLSBを引く(LSBから下位を引いて符号を反転する)
 14153:         wf ^= M;
 14154:         wc = -(wc >>> 1);
 14155:         wd = -wd - (wc >>> -1);
 14156:         wc <<= 1;
 14157:         //上位にLSBを加える
 14158:         if ((zc += LSB) == 0L && ++zd == 0L) {  //LSBを加えて、溢れたとき
 14159:           zd = MSB;  //MSBだけセットして
 14160:           ze++;  //指数部を1増やす
 14161:         }
 14162:       }
 14163:       //下位を正規化する
 14164:       if (wd >= 0L) {  //正規化が必要
 14165:         if (wd != 0L) {
 14166:           int o = Long.numberOfLeadingZeros (wd);  //1以上
 14167:           we -= o;
 14168:           wd = wd << o | wc >>> -o;  //o==0は不可
 14169:           wc <<= o;
 14170:         } else if (wc != 0L) {
 14171:           int o = Long.numberOfLeadingZeros (wc);  //0以上
 14172:           we -= 64 + o;
 14173:           wd = wc << o;
 14174:           wc = 0L;
 14175:         } else {
 14176:           wf |= Z;
 14177:         }
 14178:       }
 14179:       //結果
 14180:       if (ze > 32767) {  //オーバーフロー
 14181:         epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 14182:         epbExceptionOperandExponent = zf;
 14183:         epbExceptionOperandMantissa = zd;
 14184:         return this.sete (w.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | zf >>> 31]));  //±Inf
 14185:       } else if (ze < -32768 || wf << 1 >= 0 && we < -32768) {  //アンダーフロー
 14186:         epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 14187:         epbExceptionOperandExponent = zf;
 14188:         epbExceptionOperandMantissa = zd;
 14189:         return this.sete (w.sete (UNFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | zf >>> 31]));  //±0
 14190:       } else {
 14191:         this.flg = zf;
 14192:         this.epp = ze;
 14193:         this.dvl = zd;
 14194:         this.cvl = zc;
 14195:         w.flg = wf;
 14196:         w.epp = we;
 14197:         w.dvl = wd;
 14198:         w.cvl = wc;
 14199:         return this;
 14200:       }
 14201:     }  //efp.imulw(EFP,EFP,EFP)
 14202: 
 14203:     //------------------------------------------------------------------------
 14204:     //b = x.ne (y)
 14205:     //  b=x!=y
 14206:     //  等しくないか
 14207:     //
 14208:     //  -Inf==-Inf<-x<-0==+0<+x<+Inf==+Inf
 14209:     //
 14210:     //  NaNの扱い
 14211:     //    どちらかがNaNのときはtrueを返す
 14212:     //
 14213:     public boolean ne (EFP y) {
 14214:       int xf = this.flg;
 14215:       int yf = y.flg;
 14216:       return ((xf | yf) << 1 != 0 ?  //どちらかが±0,±Inf,NaN
 14217:               EFP_NE_TABLE[xf >>> 28] << (yf >>> 28 - 1) < 0
 14218:               : //両方±0,±Inf,NaN以外
 14219:               xf != yf || this.epp != y.epp || this.dvl != y.dvl || this.cvl != y.cvl);
 14220:     }  //efp.ne(EFP)
 14221: 
 14222:     //------------------------------------------------------------------------
 14223:     //x = x.neg ()
 14224:     //  x=-x
 14225:     //y = y.neg (x)
 14226:     //  y=-x
 14227:     //  符号反転
 14228:     //x = x.neg (b)
 14229:     //  x=b?-x:x
 14230:     //y = y.neg (x, b)
 14231:     //  y=b?-x:x
 14232:     //  条件付き符号反転
 14233:     //
 14234:     //  グラフ
 14235:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{-$_[0]});print$g"
 14236:     //    echo read("../misc/efp.gp");eval("neg(x)=-x");graph(neg) | gp -q
 14237:     //    **--------+---------+---------+---------+---------+---------+---------+---------+
 14238:     //    |***                                    |                                       |
 14239:     //    |  ***                                  |                                       |
 14240:     //    |    ***                                |                                       |
 14241:     //    |      ***                              |                                       |
 14242:     //    +        ***                            +                                       +
 14243:     //    |          ***                          |                                       |
 14244:     //    |            ***                        |                                       |
 14245:     //    |              ***                      |                                       |
 14246:     //    |                ***                    |                                       |
 14247:     //    +                  ***                  +                                       +
 14248:     //    |                    ***                |                                       |
 14249:     //    |                      ***              |                                       |
 14250:     //    |                        ***            |                                       |
 14251:     //    |                          ***          |                                       |
 14252:     //    +                            ***        +                                       +
 14253:     //    |                              ***      |                                       |
 14254:     //    |                                ***    |                                       |
 14255:     //    |                                  ***  |                                       |
 14256:     //    |                                    ***|                                       |
 14257:     //    +---------+---------+---------+--------***--------+---------+---------+---------+
 14258:     //    |                                       |***                                    |
 14259:     //    |                                       |  ***                                  |
 14260:     //    |                                       |    ***                                |
 14261:     //    |                                       |      ***                              |
 14262:     //    +                                       +        ***                            +
 14263:     //    |                                       |          ***                          |
 14264:     //    |                                       |            ***                        |
 14265:     //    |                                       |              ***                      |
 14266:     //    |                                       |                ***                    |
 14267:     //    +                                       +                  ***                  +
 14268:     //    |                                       |                    ***                |
 14269:     //    |                                       |                      ***              |
 14270:     //    |                                       |                        ***            |
 14271:     //    |                                       |                          ***          |
 14272:     //    +                                       +                            ***        +
 14273:     //    |                                       |                              ***      |
 14274:     //    |                                       |                                ***    |
 14275:     //    |                                       |                                  ***  |
 14276:     //    |                                       |                                    ***|
 14277:     //    +---------+---------+---------+---------+---------+---------+---------+--------**
 14278:     //
 14279:     public final EFP neg () {
 14280:       return this.finish (0 <= this.flg << 3 ? this.flg ^ M : this.flg, this.epp, this.dvl, this.cvl, 0L);  //NaN以外のとき符号反転
 14281:     }  //efp.neg()
 14282:     public final EFP ineg () {
 14283:       if (0 <= this.flg << 3) {  //NaN以外のとき
 14284:         this.flg ^= M;  //符号反転
 14285:       }
 14286:       return this;
 14287:     }  //efp.ineg()
 14288:     public final EFP neg (boolean b) {
 14289:       return this.finish (b && 0 <= this.flg << 3 ? this.flg ^ M : this.flg, this.epp, this.dvl, this.cvl, 0L);  //bかつNaN以外のとき符号反転
 14290:     }  //efp.neg(boolean)
 14291:     public final EFP ineg (boolean b) {
 14292:       if (b && 0 <= this.flg << 3) {  //bかつNaN以外のとき
 14293:         this.flg ^= M;  //符号反転
 14294:       }
 14295:       return this;
 14296:     }  //efp.ineg(boolean)
 14297:     public final EFP neg (EFP x) {
 14298:       return this.finish (0 <= x.flg << 3 ? x.flg ^ M : x.flg, x.epp, x.dvl, x.cvl, 0L);  //NaN以外のとき符号反転
 14299:     }  //efp.neg(EFP)
 14300:     public final EFP ineg (EFP x) {
 14301:       this.flg = 0 <= x.flg << 3 ? x.flg ^ M : x.flg;  //NaN以外のとき符号反転
 14302:       this.epp = x.epp;
 14303:       this.dvl = x.dvl;
 14304:       this.cvl = x.cvl;
 14305:       return this;
 14306:     }  //efp.ineg(EFP)
 14307:     public final EFP neg (EFP x, boolean b) {
 14308:       return this.finish (b && 0 <= x.flg << 3 ? x.flg ^ M : x.flg, x.epp, x.dvl, x.cvl, 0L);  //bかつNaN以外のとき符号反転
 14309:     }  //efp.neg(EFP,boolean)
 14310:     public final EFP ineg (EFP x, boolean b) {
 14311:       this.flg = b && 0 <= x.flg << 3 ? x.flg ^ M : x.flg;  //bかつNaN以外のとき符号反転
 14312:       this.epp = x.epp;
 14313:       this.dvl = x.dvl;
 14314:       this.cvl = x.cvl;
 14315:       return this;
 14316:     }  //efp.ineg(EFP,boolean)
 14317: 
 14318:     //------------------------------------------------------------------------
 14319:     //x = x.negdec ()
 14320:     //  x=1-x
 14321:     //y = y.negdec (x)
 14322:     //  y=1-x
 14323:     //  1から引く(逆デクリメント)
 14324:     //
 14325:     //  x.dec(y).neg()と同じ
 14326:     //
 14327:     public final EFP negdec () {
 14328:       return this.inner ().dec ().outer ().neg (0 <= this.flg << 1);  //x-1==+0のとき1-x==+0にするため符号反転しない
 14329:     }  //efp.negdec()
 14330:     public final EFP negdec (EFP x) {
 14331:       return this.inner ().dec (x).outer ().neg (0 <= this.flg << 1);  //x-1==+0のとき1-x==+0にするため符号反転しない
 14332:     }  //efp.negdec(EFP)
 14333: 
 14334:     //------------------------------------------------------------------------
 14335:     //y = y.negset0 ()
 14336:     //  -0代入
 14337:     //
 14338:     public final EFP negset0 () {
 14339:       this.flg = M | Z;
 14340:       //this.epp = 0;
 14341:       //this.dvl = 0L;
 14342:       //this.cvl = 0L;
 14343:       return this;
 14344:     }  //efp.negset0()
 14345: 
 14346:     //------------------------------------------------------------------------
 14347:     //y = y.negset1 ()
 14348:     //  -1代入
 14349:     //
 14350:     public final EFP negset1 () {
 14351:       this.flg = M;
 14352:       this.epp = 0;
 14353:       this.dvl = MSB;
 14354:       this.cvl = 0L;
 14355:       return this;
 14356:     }  //efp.negset1()
 14357: 
 14358:     //------------------------------------------------------------------------
 14359:     //y = y.negsetinf ()
 14360:     //  -Inf代入
 14361:     //
 14362:     public final EFP negsetinf () {
 14363:       this.flg = M | I;
 14364:       //this.epp = 0;
 14365:       //this.dvl = 0L;
 14366:       //this.cvl = 0L;
 14367:       return this;
 14368:     }  //efp.negsetinf()
 14369: 
 14370:     //------------------------------------------------------------------------
 14371:     //x = x.negsub (y)
 14372:     //  x=y-x
 14373:     //  逆減算
 14374:     //
 14375:     //  x.sub(y).neg()と同じ
 14376:     //  z.negsub(x,y)はz.sub(y,x)と同じ
 14377:     //
 14378:     public final EFP negsub (EFP y) {
 14379:       int xf = y.flg;
 14380:       int xe = y.epp;
 14381:       long xd = y.dvl;
 14382:       long xc = y.cvl;
 14383:       long xb = 0L;
 14384:       int yf = this.flg;
 14385:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
 14386:         if ((xf | yf) << 3 < 0) {  //どちらかがNaNのときNaN
 14387:           this.flg = N;
 14388:           return this;
 14389:         }
 14390:         if ((xf & yf) << 2 < 0 && xf == yf) {  //両方±Infで符号が同じときNaN
 14391:           epbFpsr |= EPB_FPSR_OE;
 14392:           epbExceptionOperandExponent = yf & M | 0x7fff << 16;
 14393:           epbExceptionOperandMantissa = 0x0000000000000000L;
 14394:           this.flg = N;
 14395:           return this;
 14396:         }
 14397:         if ((xf & yf) << 1 < 0 && xf == yf) {  //両方±0で符号が同じとき
 14398:           this.flg = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //RMのとき-0,それ以外は+0
 14399:           return this;
 14400:         }
 14401:         if (xf << 1 < 0 || yf << 2 < 0) {  //xが±0またはyが±Infのとき-y
 14402:           xf = yf ^ M;
 14403:           xe = this.epp;
 14404:           xd = this.dvl;
 14405:           xc = this.cvl;
 14406:         }
 14407:         //xが±Infまたはyが±0のときx
 14408:       } else {  //両方±0,±Inf,NaN以外
 14409:         //減算なのでyの符号を反転して加算する
 14410:         yf ^= M;
 14411:         long yd = this.dvl;
 14412:         long yc = this.cvl;
 14413:         int o = xe - this.epp;
 14414:         if (o < 0 || o == 0 && (xd < yd || xd == yd && xc >>> 1 < yc >>> 1)) {  //yの方が絶対値が大きい
 14415:           //xとyを入れ換える
 14416:           xf = yf;
 14417:           xe += o = -o;  //xe=this.epp
 14418:           xd = yd;
 14419:           xc = yc;
 14420:           yf = y.flg;  //後で符号を比較するときに使う
 14421:           yd = y.dvl;
 14422:           yc = y.cvl;
 14423:         }
 14424:         //xの方が絶対値が大きいか等しい
 14425:         //yを右にずらして小数点の位置を合わせる
 14426:         if (0 < o) {
 14427:           if (o <= 63) {
 14428:             xb = yc << -o;
 14429:             yc = yd << -o | yc >>> o;
 14430:             yd >>>= o;
 14431:           } else if (o == 64) {
 14432:             xb = yc;
 14433:             yc = yd;
 14434:             yd = 0L;
 14435:           } else if (o <= 127) {
 14436:             xb = yd << -o | yc;
 14437:             yc = yd >>> o;
 14438:             yd = 0L;
 14439:           } else {
 14440:             xb = yd | yc;  //絶対値減算を行うとき下位からのボローとして必要
 14441:             yc = 0L;
 14442:             yd = 0L;
 14443:           }
 14444:         }
 14445:         //絶対値加算または絶対値減算を行う
 14446:         if (xf == yf) {  //符号が同じなので絶対値加算を行う
 14447:           //yc[1]とyc[0]をsticky bitに押し出す
 14448:           xb |= yc << 62;
 14449:           //右にずらしてxd[63]を空ける
 14450:           xc = xd << 63 | xc >>> 1;
 14451:           xd >>>= 1;
 14452:           yc = yd << 63 | yc >>> 1;
 14453:           yd >>>= 1;
 14454:           //下位を右にずらしてxc[63]を空ける
 14455:           yc >>>= 1;
 14456:           xc >>>= 1;
 14457:           //足す
 14458:           xc += yc;
 14459:           xd += yd + (xc >>> 63);
 14460:           //下位を左にずらしてxc[63]を詰める
 14461:           xc <<= 1;
 14462:           //溢れの処理
 14463:           if (xd < 0L) {  //溢れたとき
 14464:             xe++;
 14465:           } else {  //溢れなかったとき
 14466:             xd = xd << 1 | xc >>> 63;  //左にずらしてxd[63]を詰める
 14467:             xc <<= 1;
 14468:           }
 14469:         } else {  //符号が異なるので絶対値減算を行う
 14470:           //yc[0]をsticky bitに押し出す
 14471:           xb |= yc << 63;
 14472:           //下位を右にずらしてxc[63]を空ける
 14473:           yc >>>= 1;
 14474:           xc >>>= 1;
 14475:           //引く
 14476:           //  xの方が絶対値が大きいか等しいので負になることはないが0になることがある
 14477:           if (xb != 0L) {
 14478:             xc--;
 14479:           }
 14480:           xc -= yc;
 14481:           xd -= yd + (xc >>> 63);
 14482:           //下位を左にずらしてxc[63]を詰める
 14483:           xc <<= 1;
 14484:           //正規化する
 14485:           if (0L <= xd) {
 14486:             if (xd != 0L) {
 14487:               xe -= o = Long.numberOfLeadingZeros (xd);
 14488:               xd = xd << o | xc >>> -o;
 14489:               xc <<= o;
 14490:             } else if (xc != 0L) {
 14491:               xe -= o = 64 + Long.numberOfLeadingZeros (xc);
 14492:               xd = xc << o;
 14493:               xc = 0L;
 14494:             } else {  //0になった
 14495:               xf = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //RMのとき-0,それ以外は+0
 14496:             }
 14497:           }
 14498:         }  //if 符号が同じなので絶対値加算を行う/符号が異なるので絶対値減算を行う
 14499:       }  //if どちらかが±0,±Inf,NaN/両方±0,±Inf,NaN以外
 14500:       return this.finish (xf, xe, xd, xc, xb);
 14501:     }  //efp.negsub(EFP)
 14502:     public final EFP negsub (EFP x, EFP y) {
 14503:       int xf = y.flg;
 14504:       int xe = y.epp;
 14505:       long xd = y.dvl;
 14506:       long xc = y.cvl;
 14507:       long xb = 0L;
 14508:       int yf = x.flg;
 14509:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
 14510:         if ((xf | yf) << 3 < 0) {  //どちらかがNaNのときNaN
 14511:           this.flg = N;
 14512:           return this;
 14513:         }
 14514:         if ((xf & yf) << 2 < 0 && xf == yf) {  //両方±Infで符号が同じときNaN
 14515:           epbFpsr |= EPB_FPSR_OE;
 14516:           epbExceptionOperandExponent = yf & M | 0x7fff << 16;
 14517:           epbExceptionOperandMantissa = 0x0000000000000000L;
 14518:           this.flg = N;
 14519:           return this;
 14520:         }
 14521:         if ((xf & yf) << 1 < 0 && xf == yf) {  //両方±0で符号が同じとき
 14522:           this.flg = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //RMのとき-0,それ以外は+0
 14523:           return this;
 14524:         }
 14525:         if (xf << 1 < 0 || yf << 2 < 0) {  //xが±0またはyが±Infのとき-y
 14526:           xf = yf ^ M;
 14527:           xe = x.epp;
 14528:           xd = x.dvl;
 14529:           xc = x.cvl;
 14530:         }
 14531:         //xが±Infまたはyが±0のときx
 14532:       } else {  //両方±0,±Inf,NaN以外
 14533:         //減算なのでyの符号を反転して加算する
 14534:         yf ^= M;
 14535:         long yd = x.dvl;
 14536:         long yc = x.cvl;
 14537:         int o = xe - x.epp;
 14538:         if (o < 0 || o == 0 && (xd < yd || xd == yd && xc >>> 1 < yc >>> 1)) {  //yの方が絶対値が大きい
 14539:           //xとyを入れ換える
 14540:           xf = yf;
 14541:           xe += o = -o;  //xe=x.epp
 14542:           xd = yd;
 14543:           xc = yc;
 14544:           yf = y.flg;  //後で符号を比較するときに使う
 14545:           yd = y.dvl;
 14546:           yc = y.cvl;
 14547:         }
 14548:         //xの方が絶対値が大きいか等しい
 14549:         //yを右にずらして小数点の位置を合わせる
 14550:         if (0 < o) {
 14551:           if (o <= 63) {
 14552:             xb = yc << -o;
 14553:             yc = yd << -o | yc >>> o;
 14554:             yd >>>= o;
 14555:           } else if (o == 64) {
 14556:             xb = yc;
 14557:             yc = yd;
 14558:             yd = 0L;
 14559:           } else if (o <= 127) {
 14560:             xb = yd << -o | yc;
 14561:             yc = yd >>> o;
 14562:             yd = 0L;
 14563:           } else {
 14564:             xb = yd | yc;  //絶対値減算を行うとき下位からのボローとして必要
 14565:             yc = 0L;
 14566:             yd = 0L;
 14567:           }
 14568:         }
 14569:         //絶対値加算または絶対値減算を行う
 14570:         if (xf == yf) {  //符号が同じなので絶対値加算を行う
 14571:           //yc[1]とyc[0]をsticky bitに押し出す
 14572:           xb |= yc << 62;
 14573:           //右にずらしてxd[63]を空ける
 14574:           xc = xd << 63 | xc >>> 1;
 14575:           xd >>>= 1;
 14576:           yc = yd << 63 | yc >>> 1;
 14577:           yd >>>= 1;
 14578:           //下位を右にずらしてxc[63]を空ける
 14579:           yc >>>= 1;
 14580:           xc >>>= 1;
 14581:           //足す
 14582:           xc += yc;
 14583:           xd += yd + (xc >>> 63);
 14584:           //下位を左にずらしてxc[63]を詰める
 14585:           xc <<= 1;
 14586:           //溢れの処理
 14587:           if (xd < 0L) {  //溢れたとき
 14588:             xe++;
 14589:           } else {  //溢れなかったとき
 14590:             xd = xd << 1 | xc >>> 63;  //左にずらしてxd[63]を詰める
 14591:             xc <<= 1;
 14592:           }
 14593:         } else {  //符号が異なるので絶対値減算を行う
 14594:           //yc[0]をsticky bitに押し出す
 14595:           xb |= yc << 63;
 14596:           //下位を右にずらしてxc[63]を空ける
 14597:           yc >>>= 1;
 14598:           xc >>>= 1;
 14599:           //引く
 14600:           //  xの方が絶対値が大きいか等しいので負になることはないが0になることがある
 14601:           if (xb != 0L) {
 14602:             xc--;
 14603:           }
 14604:           xc -= yc;
 14605:           xd -= yd + (xc >>> 63);
 14606:           //下位を左にずらしてxc[63]を詰める
 14607:           xc <<= 1;
 14608:           //正規化する
 14609:           if (0L <= xd) {
 14610:             if (xd != 0L) {
 14611:               xe -= o = Long.numberOfLeadingZeros (xd);
 14612:               xd = xd << o | xc >>> -o;
 14613:               xc <<= o;
 14614:             } else if (xc != 0L) {
 14615:               xe -= o = 64 + Long.numberOfLeadingZeros (xc);
 14616:               xd = xc << o;
 14617:               xc = 0L;
 14618:             } else {  //0になった
 14619:               xf = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //RMのとき-0,それ以外は+0
 14620:             }
 14621:           }
 14622:         }  //if 符号が同じなので絶対値加算を行う/符号が異なるので絶対値減算を行う
 14623:       }  //if どちらかが±0,±Inf,NaN/両方±0,±Inf,NaN以外
 14624:       return this.finish (xf, xe, xd, xc, xb);
 14625:     }  //efp.negsub(EFP,EFP)
 14626: 
 14627:     //------------------------------------------------------------------------
 14628:     //x = x.nextdowne ()
 14629:     //y = y.nextdowne (x)
 14630:     //  EFPで表現できるxの-Inf側の隣接値
 14631:     //x = x.nextdownd ()
 14632:     //y = y.nextdownd (x)
 14633:     //  doubleで表現できるxよりも小さい最大の値
 14634:     //x = x.nextdownf ()
 14635:     //y = y.nextdownf (x)
 14636:     //  floatで表現できるxよりも小さい最大の値
 14637:     //x = x.nextdownx ()
 14638:     //y = y.nextdownx (x)
 14639:     //  extendedで表現できるxよりも小さい最大の値
 14640:     //x = x.nextdowny ()
 14641:     //y = y.nextdowny (x)
 14642:     //  tripleで表現できるxよりも小さい最大の値
 14643:     //x = x.nextdown (prec)
 14644:     //y = y.nextdown (x, prec)
 14645:     //  precの精度で表現できるxよりも小さい最大の値
 14646:     //
 14647:     //  nextdown(±0)=負の最小値
 14648:     //  nextdown(+Inf)=最大値
 14649:     //  nextdown(-Inf)=-Inf
 14650:     //  nextdown(NaN)=NaN
 14651:     //  nextdown(最小値)=-Inf
 14652:     //
 14653:     public final EFP nextdowne () {
 14654:       return this.nextdowne (this);
 14655:     }  //efp.nextdowne()
 14656:     public final EFP nextdowne (EFP x) {
 14657:       int xf = x.flg;
 14658:       int xe = x.epp;
 14659:       long xd = x.dvl;
 14660:       long xc = x.cvl;
 14661:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 14662:         if (xf << 1 < 0) {  //±0
 14663:           xf = M;  //負の最大値
 14664:           xe = -32768;
 14665:           xd = MSB;
 14666:           xc = 0L;
 14667:         } else if (xf == (P | I)) {  //+Inf
 14668:           xf = P;  //最大値
 14669:           xe = 32767;
 14670:           xd = -1L;
 14671:           xc = -1L << 128 - LEN;
 14672:         }
 14673:         //-Inf,NaNはそのまま
 14674:       } else if (xf >= 0) {  //+x
 14675:         if (xc != 0L) {
 14676:           xc -= 1L << 128 - LEN;  //最下位bitから1を引く
 14677:         } else if (xd != MSB) {
 14678:           xc = -1L << 128 - LEN;
 14679:           xd--;
 14680:         } else if (xe > -32768) {
 14681:           xc = -1L << 128 - LEN;
 14682:           xd = -1L;
 14683:           xe--;
 14684:         } else {  //アンダーフロー
 14685:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 14686:           epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 14687:           epbExceptionOperandMantissa = xd;
 14688:           return this.set0 ();  //+0
 14689:         }
 14690:       } else {  //-x
 14691:         if (xc != -1L << 128 - LEN) {
 14692:           xc += (1L << 128 - LEN);  //最下位bitに1を加える
 14693:         } else if (xd != -1L) {
 14694:           xc = 0L;
 14695:           xd++;
 14696:         } else if (xe < 32767) {
 14697:           xc = 0L;
 14698:           xd = MSB;
 14699:           xe++;
 14700:         } else {  //オーバーフロー
 14701:           epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 14702:           epbExceptionOperandExponent = xf;
 14703:           epbExceptionOperandMantissa = xd;
 14704:           return this.negsetinf ();  //-Inf
 14705:         }
 14706:       }
 14707:       this.flg = xf;
 14708:       this.epp = xe;
 14709:       this.dvl = xd;
 14710:       this.cvl = xc;
 14711:       return this;
 14712:     }  //efp.nextdowne(EFP)
 14713:     public final EFP nextdownd () {
 14714:       return this.nextdowne (this).roundd (EPB_MODE_RM);
 14715:     }  //efp.nextdownd()
 14716:     public final EFP nextdownd (EFP x) {
 14717:       return this.nextdowne (x).roundd (EPB_MODE_RM);
 14718:     }  //efp.nextdownd(EFP)
 14719:     public final EFP nextdownf () {
 14720:       return this.nextdowne (this).roundf (EPB_MODE_RM);
 14721:     }  //efp.nextdownf()
 14722:     public final EFP nextdownf (EFP x) {
 14723:       return this.nextdowne (x).roundf (EPB_MODE_RM);
 14724:     }  //efp.nextdownf(EFP)
 14725:     public final EFP nextdowng () {
 14726:       return this.nextdowne (this).roundg (EPB_MODE_RM);
 14727:     }  //efp.nextdowng()
 14728:     public final EFP nextdowng (EFP x) {
 14729:       return this.nextdowne (x).roundg (EPB_MODE_RM);
 14730:     }  //efp.nextdowng(EFP)
 14731:     public final EFP nextdownx () {
 14732:       return this.nextdowne (this).roundx (EPB_MODE_RM);
 14733:     }  //efp.nextdownx()
 14734:     public final EFP nextdownx (EFP x) {
 14735:       return this.nextdowne (x).roundx (EPB_MODE_RM);
 14736:     }  //efp.nextdownx(EFP)
 14737:     public final EFP nextdowny () {
 14738:       return this.nextdowne (this).roundy (EPB_MODE_RM);
 14739:     }  //efp.nextdowny()
 14740:     public final EFP nextdowny (EFP x) {
 14741:       return this.nextdowne (x).roundy (EPB_MODE_RM);
 14742:     }  //efp.nextdowny(EFP)
 14743:     public final EFP nextdown (int prec) {
 14744:       switch (prec) {
 14745:       case EPB_PREC_EXD:
 14746:         return this.nextdowne (this).roundx (EPB_MODE_RM);
 14747:       case EPB_PREC_SGL:
 14748:         return this.nextdowne (this).roundf (EPB_MODE_RM);
 14749:       case EPB_PREC_DBL:
 14750:       case EPB_PREC_DBL3:
 14751:         return this.nextdowne (this).roundd (EPB_MODE_RM);
 14752:       case EPB_PREC_TPL:
 14753:         return this.nextdowne (this).roundy (EPB_MODE_RM);
 14754:       case EPB_PREC_XSG:
 14755:         return this.nextdowne (this).roundg (EPB_MODE_RM);
 14756:       }
 14757:       return this.nextdowne (this);
 14758:     }  //efp.nextdown(int)
 14759:     public final EFP nextdown (EFP x, int prec) {
 14760:       switch (prec) {
 14761:       case EPB_PREC_EXD:
 14762:         return this.nextdowne (x).roundx (EPB_MODE_RM);
 14763:       case EPB_PREC_SGL:
 14764:         return this.nextdowne (x).roundf (EPB_MODE_RM);
 14765:       case EPB_PREC_DBL:
 14766:       case EPB_PREC_DBL3:
 14767:         return this.nextdowne (x).roundd (EPB_MODE_RM);
 14768:       case EPB_PREC_TPL:
 14769:         return this.nextdowne (x).roundy (EPB_MODE_RM);
 14770:       case EPB_PREC_XSG:
 14771:         return this.nextdowne (x).roundg (EPB_MODE_RM);
 14772:       }
 14773:       return this.nextdowne (x);
 14774:     }  //efp.nextdown(EFP,int)
 14775: 
 14776:     //------------------------------------------------------------------------
 14777:     //x = x.nextupe ()
 14778:     //y = y.nextupe (x)
 14779:     //  EFPで表現できる+Inf側の隣接値
 14780:     //x = x.nextupd ()
 14781:     //y = y.nextupd (x)
 14782:     //  doubleで表現できるxよりも大きい最小の値
 14783:     //x = x.nextupf ()
 14784:     //y = y.nextupf (x)
 14785:     //  floatで表現できるxよりも大きい最小の値
 14786:     //x = x.nextupx ()
 14787:     //y = y.nextupx (x)
 14788:     //  extendedで表現できるxよりも大きい最小の値
 14789:     //x = x.nextupy ()
 14790:     //y = y.nextupy (x)
 14791:     //  tripleで表現できるxよりも大きい最小の値
 14792:     //x = x.nextup (prec)
 14793:     //y = y.nextup (x, prec)
 14794:     //  precの精度で表現できるxよりも大きい最小の値
 14795:     //
 14796:     //  nextup(±0)=正の最小値
 14797:     //  nextup(-Inf)=最小値
 14798:     //  nextup(+Inf)=+Inf
 14799:     //  nextup(NaN)=NaN
 14800:     //  nextup(最大値)=+Inf
 14801:     //
 14802:     public final EFP nextupe () {
 14803:       return this.nextupe (this);
 14804:     }  //efp.nextupe()
 14805:     public final EFP nextupe (EFP x) {
 14806:       int xf = x.flg;
 14807:       int xe = x.epp;
 14808:       long xd = x.dvl;
 14809:       long xc = x.cvl;
 14810:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 14811:         if (xf << 1 < 0) {  //±0
 14812:           xf = P;  //正の最小値
 14813:           xe = -32768;
 14814:           xd = MSB;
 14815:           xc = 0L;
 14816:         } else if (xf == (M | I)) {  //-Inf
 14817:           xf = M;  //最小値
 14818:           xe = 32767;
 14819:           xd = -1L;
 14820:           xc = -1L << 128 - LEN;
 14821:         }
 14822:         //+Inf,NaNはそのまま
 14823:       } else if (xf >= 0) {  //+x
 14824:         if (xc != -1L << 128 - LEN) {
 14825:           xc += (1L << 128 - LEN);  //最下位bitに1を加える
 14826:         } else if (xd != -1L) {
 14827:           xc = 0L;
 14828:           xd++;
 14829:         } else if (xe < 32767) {
 14830:           xc = 0L;
 14831:           xd = MSB;
 14832:           xe++;
 14833:         } else {  //オーバーフロー
 14834:           epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 14835:           epbExceptionOperandExponent = xf;
 14836:           epbExceptionOperandMantissa = xd;
 14837:           return this.setinf ();  //+Inf
 14838:         }
 14839:       } else {  //-x
 14840:         if (xc != 0L) {
 14841:           xc -= 1L << 128 - LEN;  //最下位bitから1を引く
 14842:         } else if (xd != MSB) {
 14843:           xc = -1L << 128 - LEN;
 14844:           xd--;
 14845:         } else if (xe > -32768) {
 14846:           xc = -1L << 128 - LEN;
 14847:           xd = -1L;
 14848:           xe--;
 14849:         } else {  //アンダーフロー
 14850:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 14851:           epbExceptionOperandExponent = xf;
 14852:           epbExceptionOperandMantissa = xd;
 14853:           return this.negset0 ();  //-0
 14854:         }
 14855:       }
 14856:       this.flg = xf;
 14857:       this.epp = xe;
 14858:       this.dvl = xd;
 14859:       this.cvl = xc;
 14860:       return this;
 14861:     }  //efp.nextupe(EFP)
 14862:     public final EFP nextupd () {
 14863:       return this.nextupe (this).roundd (EPB_MODE_RP);
 14864:     }  //efp.nextupd()
 14865:     public final EFP nextupd (EFP x) {
 14866:       return this.nextupe (x).roundd (EPB_MODE_RP);
 14867:     }  //efp.nextupd(EFP)
 14868:     public final EFP nextupf () {
 14869:       return this.nextupe (this).roundf (EPB_MODE_RP);
 14870:     }  //efp.nextupf()
 14871:     public final EFP nextupf (EFP x) {
 14872:       return this.nextupe (x).roundf (EPB_MODE_RP);
 14873:     }  //efp.nextupf(EFP)
 14874:     public final EFP nextupg () {
 14875:       return this.nextupe (this).roundg (EPB_MODE_RP);
 14876:     }  //efp.nextupg()
 14877:     public final EFP nextupg (EFP x) {
 14878:       return this.nextupe (x).roundg (EPB_MODE_RP);
 14879:     }  //efp.nextupg(EFP)
 14880:     public final EFP nextupx () {
 14881:       return this.nextupe (this).roundx (EPB_MODE_RP);
 14882:     }  //efp.nextupx()
 14883:     public final EFP nextupx (EFP x) {
 14884:       return this.nextupe (x).roundx (EPB_MODE_RP);
 14885:     }  //efp.nextupx(EFP)
 14886:     public final EFP nextupy () {
 14887:       return this.nextupe (this).roundy (EPB_MODE_RP);
 14888:     }  //efp.nextupy()
 14889:     public final EFP nextupy (EFP x) {
 14890:       return this.nextupe (x).roundy (EPB_MODE_RP);
 14891:     }  //efp.nextupy(EFP)
 14892:     public final EFP nextup (int prec) {
 14893:       switch (prec) {
 14894:       case EPB_PREC_EXD:
 14895:         return this.nextupe (this).roundx (EPB_MODE_RP);
 14896:       case EPB_PREC_SGL:
 14897:         return this.nextupe (this).roundf (EPB_MODE_RP);
 14898:       case EPB_PREC_DBL:
 14899:       case EPB_PREC_DBL3:
 14900:         return this.nextupe (this).roundd (EPB_MODE_RP);
 14901:       case EPB_PREC_TPL:
 14902:         return this.nextupe (this).roundy (EPB_MODE_RP);
 14903:       case EPB_PREC_XSG:
 14904:         return this.nextupe (this).roundg (EPB_MODE_RP);
 14905:       }
 14906:       return this.nextupe (this);
 14907:     }  //efp.nextup(int)
 14908:     public final EFP nextup (EFP x, int prec) {
 14909:       switch (prec) {
 14910:       case EPB_PREC_EXD:
 14911:         return this.nextupe (x).roundx (EPB_MODE_RP);
 14912:       case EPB_PREC_SGL:
 14913:         return this.nextupe (x).roundf (EPB_MODE_RP);
 14914:       case EPB_PREC_DBL:
 14915:       case EPB_PREC_DBL3:
 14916:         return this.nextupe (x).roundd (EPB_MODE_RP);
 14917:       case EPB_PREC_TPL:
 14918:         return this.nextupe (x).roundy (EPB_MODE_RP);
 14919:       case EPB_PREC_XSG:
 14920:         return this.nextupe (x).roundg (EPB_MODE_RP);
 14921:       }
 14922:       return this.nextupe (x);
 14923:     }  //efp.nextup(EFP,int)
 14924: 
 14925:     //------------------------------------------------------------------------
 14926:     //y = y.parse (s)
 14927:     //  文字列解析
 14928:     //
 14929:     //    仮数部がInfで始まっているときはInf、Inf以外で仮数部に数字がないときはNaNとみなす
 14930:     //    仮数部が0bで始まっているときは2進数、0oで始まっているときは8進数、0xで始まっているときは16進数、それ以外は10進数とみなす
 14931:     //    0で始まっているだけでは8進数とみなさない
 14932:     //    2進数と8進数と16進数は2の累乗の指数部をp～で、10進数は10の累乗の指数部をe～で指定できる
 14933:     //    Inf、16進数のa～f、指数部のp～とe～は大文字と小文字を区別しない
 14934:     //    後ろのゴミは無視する
 14935:     //    先頭に空白があるときはエラーとなってNaNが返ることに注意
 14936:     //
 14937:     public final EFP parse (String s) {
 14938:       int i = 0;
 14939:       int l = s.length ();
 14940:       char c = i < l ? s.charAt (i++) : '\0';
 14941:       //符号
 14942:       int f;
 14943:       if (c == '-') {
 14944:         f = M;
 14945:         c = i < l ? s.charAt (i++) : '\0';
 14946:       } else {
 14947:         f = P;
 14948:         if (c == '+') {
 14949:           c = i < l ? s.charAt (i++) : '\0';
 14950:         }
 14951:       }
 14952:       //Inf
 14953:       if (i + 1 < l && (c | 0x20) == 'i' && (s.charAt (i) | 0x20) == 'n' && (s.charAt (i + 1) | 0x20) == 'f') {
 14954:         this.flg = f | I;
 14955:         return this;
 14956:       }
 14957:       //仮数部
 14958:       this.inner ();
 14959:       this.flg = P | Z;  //符号は最後に付ける
 14960:       boolean nan = true;  //true=仮数部に数字がない
 14961:       //基数
 14962:       int r = 10;
 14963:       if (c == '$') {  //16進数
 14964:         c = i < l ? s.charAt (i++) : '\0';
 14965:         r = 16;
 14966:       } else if (c == '@') {  //8進数
 14967:         c = i < l ? s.charAt (i++) : '\0';
 14968:         r = 8;
 14969:       } else if (c == '%') {  //2進数
 14970:         c = i < l ? s.charAt (i++) : '\0';
 14971:         r = 2;
 14972:       } else if (c == '0') {
 14973:         nan = false;  //0xの後に数字がなくても0があるのでNaNではなくて0にする
 14974:         c = i < l ? s.charAt (i++) : '\0';
 14975:         if ((c | 0x20) == 'x') {  //16進数
 14976:           c = i < l ? s.charAt (i++) : '\0';
 14977:           r = 16;
 14978:         } else if ((c | 0x20) == 'o') {  //8進数
 14979:           c = i < l ? s.charAt (i++) : '\0';
 14980:           r = 8;
 14981:         } else if ((c | 0x20) == 'b') {  //2進数
 14982:           c = i < l ? s.charAt (i++) : '\0';
 14983:           r = 2;
 14984:         }
 14985:       }
 14986:       //整数部
 14987:       {
 14988:         int t = Character.digit (c, r);
 14989:         if (t >= 0) {
 14990:           nan = false;
 14991:           do {
 14992:             this.imul (EFP_DIGIT[r]).iadd (EFP_DIGIT[t]);
 14993:             c = i < l ? s.charAt (i++) : '\0';
 14994:             t = Character.digit (c, r);
 14995:           } while (t >= 0);
 14996:         }
 14997:       }
 14998:       //小数部
 14999:       int o = 0;  //-小数点以下の桁数またはbit数
 15000:       if (c == '.') {
 15001:         c = i < l ? s.charAt (i++) : '\0';
 15002:         int t = Character.digit (c, r);
 15003:         if (t >= 0) {
 15004:           nan = false;
 15005:           do {
 15006:             o--;
 15007:             this.imul (EFP_DIGIT[r]).iadd (EFP_DIGIT[t]);
 15008:             c = i < l ? s.charAt (i++) : '\0';
 15009:             t = Character.digit (c, r);
 15010:           } while (t >= 0);
 15011:           if (r == 8) {  //8進数のときは1桁が3bit
 15012:             o *= 3;
 15013:           } else if (r == 16) {  //16進数のときは1桁が4bit
 15014:             o <<= 2;
 15015:           }
 15016:         }
 15017:       }
 15018:       //NaN
 15019:       if (nan) {  //仮数部に数字がない
 15020:         this.flg = N;
 15021:         return this.outer ();
 15022:       }
 15023:       //0
 15024:       if (this.flg << 1 < 0) {  //Z
 15025:         this.flg = f | Z;
 15026:         return this.outer ();
 15027:       }
 15028:       //指数部
 15029:       if ((c | 0x20) == (r == 10 ? 'e' : 'p')) {
 15030:         c = i < l ? s.charAt (i++) : '\0';
 15031:         int m;  //指数部の符号
 15032:         if (c == '-') {
 15033:           m = -1;
 15034:           c = i < l ? s.charAt (i++) : '\0';
 15035:         } else {
 15036:           m = 1;
 15037:           if (c == '+') {
 15038:             c = i < l ? s.charAt (i++) : '\0';
 15039:           }
 15040:         }
 15041:         if ('0' <= c && c <= '9') {  //指数部は常に10進数
 15042:           int t = 0;
 15043:           do {
 15044:             t = t * 10 + (c - '0');
 15045:             if (t >= 100000000) {  //オーバーフローまたはアンダーフロー
 15046:               this.outer ();
 15047:               if (m >= 0) {  //オーバーフロー
 15048:                 //0e+999999999は0だが0は除外済み
 15049:                 epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 15050:                 epbExceptionOperandExponent = 0;
 15051:                 epbExceptionOperandMantissa = 0L;
 15052:                 return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | f >>> 31]).finish ();  //±Inf
 15053:               } else {  //アンダーフロー
 15054:                 //1e-999999999は0
 15055:                 epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 15056:                 epbExceptionOperandExponent = 0;
 15057:                 epbExceptionOperandMantissa = 0L;
 15058:                 return this.sete (UNFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | f >>> 31]).finish ();  //±0
 15059:               }
 15060:             }
 15061:             c = i < l ? s.charAt (i++) : '\0';
 15062:           } while ('0' <= c && c <= '9');
 15063:           o += m * t;  //指数部-小数点以下の桁数
 15064:         }
 15065:       }
 15066:       if (r != 10) {  //2^oを掛ける
 15067:         this.shl (o);  //8進数または16進数のときも指数部はbit単位
 15068:       } else if (o > 0) {  //10^oを掛ける
 15069:         //this.imul (new EFP (TEN).pow (o));
 15070:         EFP t = new EFP (ONE);
 15071:         for (int j = 0, m = o; m != 0; j++, m >>>= 1) {
 15072:           if ((m & 1) != 0) {
 15073:             t.imul (EFP_TEN_POWER_P[j]);
 15074:           }
 15075:         }
 15076:         this.imul (t);
 15077:       } else if (o < 0) {  //10^-oで割る
 15078:         //this.div (new EFP (TEN).pow (-o));
 15079:         EFP t = new EFP (ONE);
 15080:         for (int j = 0, m = -o; m != 0; j++, m >>>= 1) {
 15081:           if ((m & 1) != 0) {
 15082:             t.imul (EFP_TEN_POWER_P[j]);
 15083:           }
 15084:         }
 15085:         this.div (t);
 15086:       }
 15087:       //符号
 15088:       return this.outer ().neg (f < 0);
 15089:     }  //efp.parse(String)
 15090: 
 15091:     //------------------------------------------------------------------------
 15092:     //x = x.pow (y)
 15093:     //  x=x^y
 15094:     //z = z.pow (x, y)
 15095:     //  z=x^y
 15096:     //  累乗
 15097:     //
 15098:     //  指数関数との関係
 15099:     //    x^y=(e^(log(x)))^y
 15100:     //       =e^(log(x)*y)
 15101:     //       =(2^(log2(x)))^y
 15102:     //       =2^(log2(x)*y)
 15103:     //
 15104:     //  メモ
 15105:     //    log2(x)はxが0に近すぎると-Infになってしまう
 15106:     //    x=2^k*v
 15107:     //    log2(2^k*v)=k+log2(v)
 15108:     //    x^y=2^(log2(x)*y)
 15109:     //       =2^(log2(2^k*v)*y)
 15110:     //       =2^((k+log2(v))*y)
 15111:     //       =2^(k*y+log2(v)*y)
 15112:     //       =2^(k*y)*2^(log2(v)*y)
 15113:     //
 15114:     public final EFP pow (EFP y) {
 15115:       return this.pow (this, y);
 15116:     }  //efp.pow(EFP)
 15117:     public final EFP pow (EFP x, EFP y) {
 15118:       int xf = x.flg;
 15119:       int yf = y.flg;
 15120:       if (yf << 1 != 0) {  //yが±0,±Inf,NaN
 15121:         if (yf << 1 < 0) {
 15122:           this.flg = P;  //x^±0=1。NaN^±0=1を含む
 15123:           this.epp = 0;
 15124:           this.dvl = MSB;
 15125:           this.cvl = 0L;
 15126:           return this;
 15127:         } else {
 15128:           int s;
 15129:           this.flg = (yf << 3 < 0 ||  //x^NaN=NaN
 15130:                       xf << 3 < 0 ||  //NaN^(y!=±0)=NaN
 15131:                       (s = x.cmp1abs ()) == 0 ? N :  //(|x|==1)^±Inf=NaN
 15132:                       (s ^ yf) >= 0 ? P | I :  //(|x|>1)^+Inf=(|x|<1)^-Inf=+Inf。±Inf^±Inf=+Infを含む
 15133:                       P | Z);  //(|x|>1)^-Inf=(|x|<1)^+Inf=+0。±Inf^∓Inf=+0を含む
 15134:           return this;
 15135:         }
 15136:       } else if (xf << 1 != 0) {  //xが±0,±Inf,NaNでyが±0,±Inf,NaN以外
 15137:         this.flg = (xf << 3 < 0 ? N :  //NaN^(y!=±0)=NaN
 15138:                     xf >= 0 ?  //xが+0,+Inf
 15139:                     (xf << 2 ^ yf) >= 0 ? P | Z :  //+0^(y>0)=+0,+Inf^(y<0)=+0
 15140:                     P | I :  //+0^(y<0)=+Inf,+Inf^(y>0)=+Inf
 15141:                     //xが-0,-Inf
 15142:                     y.isodd () ?  //yが奇数
 15143:                     (xf << 2 ^ yf) >= 0 ? M | Z :  //-0^(y>0 and is odd)=-0,-Inf^(y<0 and is odd)=-0
 15144:                     M | I :  //-0^(y<0 and is odd)=-Inf,-0^(y<0 and is odd)=-Inf
 15145:                     //yが奇数でない(偶数であるまたは整数でない)
 15146:                     //!!! (-Inf)^-1.5は+0なのか?
 15147:                     //  System.out.println(Math.pow(Double.NEGATIVE_INFINITY,-1.5));
 15148:                     //  0.0
 15149:                     (xf << 2 ^ yf) >= 0 ? P | Z :  //-0^(y>0 and is not odd)=+0,-Inf^(y<0 and is even)=+0
 15150:                     P | I);  //-0^(y<0 and is even)=+Inf,-Inf^(y>0 and is even)=+Inf
 15151:         return this;
 15152:       } else if (xf < 0) {  //両方±0,±Inf,NaN以外でxが負
 15153:         this.inner ();
 15154:         if (y.iseven ()) {  //yが偶数
 15155:           EFP w = new EFP ();
 15156:           this.imulw (w, new EFP ().ineg (x).log2 (), y);
 15157:           if (this.epp >= 16) {  //指数が大きすぎる
 15158:             this.flg = this.flg >= 0 ? P | I : P | Z;  //2^+big=+Inf,2^-big=+0
 15159:             return this.outer ();
 15160:           } else {
 15161:             int k = this.geti ();
 15162:             return this.frac ().iadd (w).exp2 ().outer ().shl (k);
 15163:           }
 15164:         } else if (y.isodd ()) {  //yが奇数
 15165:           EFP w = new EFP ();
 15166:           this.imulw (w, new EFP ().ineg (x).log2 (), y);
 15167:           if (this.epp >= 16) {  //指数が大きすぎる
 15168:             this.flg = this.flg >= 0 ? M | I : M | Z;  //-(2^+big)=-Inf,-(2^-big)=-0
 15169:             return this.outer ();
 15170:           } else {
 15171:             int k = this.geti ();
 15172:             return this.frac ().iadd (w).exp2 ().shl (k).outer ().neg ();
 15173:           }
 15174:         } else {  //yが整数でない
 15175:           this.flg = N;  //(x<0)^(y is not integer)=NaN
 15176:           return this.outer ();
 15177:         }
 15178:       } else {  //両方±0,±Inf,NaN以外でxが正
 15179:         this.inner ();
 15180:         EFP w = new EFP ();
 15181:         this.imulw (w, new EFP ().log2 (x), y);
 15182:         if (this.epp >= 16) {  //指数が大きすぎる
 15183:           this.flg = this.flg >= 0 ? P | I : P | Z;  //2^+big=+Inf,2^-big=+0
 15184:           return this.outer ();
 15185:         } else {
 15186:           int k = this.geti ();
 15187:           return this.frac ().iadd (w).exp2 ().outer ().shl (k);
 15188:         }
 15189:       }
 15190:     }  //efp.pow(EFP,EFP)
 15191: 
 15192:     //------------------------------------------------------------------------
 15193:     //x = x.powi (n)
 15194:     //  x=x^n
 15195:     //z = z.powi (x, n)
 15196:     //  z=x^n
 15197:     //  int累乗
 15198:     //
 15199:     public final EFP powi (int n) {
 15200:       return this.powi (this, n);
 15201:     }  //efp.powi(int)
 15202:     public final EFP powi (EFP x, int n) {
 15203:       int xf = x.flg;
 15204:       if (n == 0) {  //yが±0,±Inf,NaN
 15205:         //this.set1 ();
 15206:         this.flg = P;  //x^±0=1。NaN^±0=1を含む
 15207:         this.epp = 0;
 15208:         this.dvl = MSB;
 15209:         this.cvl = 0L;
 15210:         return this;
 15211:       } else if (xf << 1 != 0) {  //xが±0,±Inf,NaNでyが±0,±Inf,NaN以外
 15212:         this.flg = (xf << 3 < 0 ? N :  //NaN^(y!=±0)=NaN
 15213:                     xf >= 0 ?  //xが+0,+Inf
 15214:                     (xf << 2 ^ n) >= 0 ? P | Z :  //+0^(y>0)=+0,+Inf^(y<0)=+0
 15215:                     P | I :  //+0^(y<0)=+Inf,+Inf^(y>0)=+Inf
 15216:                     //xが-0,-Inf
 15217:                     (n & 1) != 0 ?  //yが奇数
 15218:                     (xf << 2 ^ n) >= 0 ? M | Z :  //-0^(y>0 and is odd)=-0,-Inf^(y<0 and is odd)=-0
 15219:                     M | I :  //-0^(y<0 and is odd)=-Inf,-0^(y<0 and is odd)=-Inf
 15220:                     //yが奇数でない(偶数であるまたは整数でない)
 15221:                     //!!! (-Inf)^-1.5は+0なのか?
 15222:                     //  System.out.println(Math.pow(Double.NEGATIVE_INFINITY,-1.5));
 15223:                     //  0.0
 15224:                     (xf << 2 ^ n) >= 0 ? P | Z :  //-0^(y>0 and is not odd)=+0,-Inf^(y<0 and is even)=+0
 15225:                     P | I);  //-0^(y<0 and is even)=+Inf,-Inf^(y>0 and is even)=+Inf
 15226:         return this;
 15227:       } else {  //両方±0,±Inf,NaN以外
 15228:         //  y==0は処理済み
 15229:         int t = n >= 0 ? n : -n;  //|y|
 15230:         if (t >>> 16 != 0) {  //t==0x80000000の場合があるのでt>65535は不可
 15231:           //|x|が1に近くて|n|が大きいとき乗算を繰り返す方法では誤差が大きくなるのでpowに計算させる
 15232:           int xe = x.epp;
 15233:           long xd = x.dvl;
 15234:           if (xe == 0 && xd >>> -16 == 0x8000L ||
 15235:               xe == -1 && xd >>> -16 == 0xffffL) {  //±1±ε
 15236:             return this.pow (x, new EFP (n));
 15237:           }
 15238:         }
 15239:         this.inner ();
 15240:         EFP w = new EFP (x);  //x^(2^0)
 15241:         if ((t & 1) == 0) {
 15242:           //this.set1 ();
 15243:           this.flg = P;  //x^0=1
 15244:           this.epp = 0;
 15245:           this.dvl = MSB;
 15246:           this.cvl = 0L;
 15247:         } else {
 15248:           //this.sete (x);
 15249:           this.flg = xf;  //x^1=x
 15250:           this.epp = x.epp;
 15251:           this.dvl = x.dvl;
 15252:           this.cvl = x.cvl;
 15253:         }
 15254:         while ((t >>>= 1) != 0) {
 15255:           w.squ ();  //x^(2^k)。指数部分が32bitでも足りなくなることがあるのでisquは不可
 15256:           if ((t & 1) != 0) {
 15257:             this.mul (w);
 15258:           }
 15259:         }
 15260:         if (n < 0) {  //x^(y<0)=1/x^-y
 15261:           this.rcp ();
 15262:         }
 15263:         return this.outer ().finish ();
 15264:       }
 15265:     }  //efp.powi(EFP,int)
 15266: 
 15267:     //------------------------------------------------------------------------
 15268:     //x = x.quo (y)
 15269:     //  x=trunc(x/y)
 15270:     //z = z.quo (x, y)
 15271:     //  z=trunc(x/y)
 15272:     //  商
 15273:     //
 15274:     public final EFP quo (EFP y) {
 15275:       return this.quo (this, y);
 15276:     }  //efp.quo(EFP)
 15277:     public final EFP quo (EFP x, EFP y) {
 15278:       int xf = x.flg;
 15279:       int yf = y.flg;
 15280:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
 15281:         this.flg = ((xf | yf) << 3 != 0 || (xf & yf & (Z | I)) != 0 ? N :  //どちらかがNaNまたは±0/±0または±Inf/±InfのときNaN
 15282:                     (xf ^ yf) & M | ((xf & Z | yf & I) != 0 ? Z : I));  //±0/(±0,NaN以外)または(±Inf,NaN以外)/±Infのとき±0、(±0,NaN以外)/±0または±Inf/(±Inf,NaN以外)のとき±Inf
 15283:         return this;
 15284:       }
 15285:       //±0,±Inf,NaN以外
 15286:       int zf = xf ^ yf;  //符号が同じならばP、異なればM。ここでセットされるのはMだけ
 15287:       int ze = x.epp - y.epp;  //商の小数点はq0の左端から右にzeの位置
 15288:       if (ze < 0) {  //|x|<|y|。商は0
 15289:         this.flg = zf | Z;
 15290:         return this;
 15291:       }
 15292:       //仮数部を31bitずつ3分割する
 15293:       long r01 = x.dvl;
 15294:       long y01 = y.dvl;
 15295:       long r2 = (r01 << -2 | x.cvl >>> 2) >>> 33;
 15296:       long y2 = (y01 << -2 | y.cvl >>> 2) >>> 33;
 15297:       r01 >>>= 2;
 15298:       y01 >>>= 2;
 15299:       long y0 = y01 >>> 31;
 15300:       long y1 = y01 & 0x7fffffffL;
 15301:       //先頭1bit
 15302:       boolean qq;
 15303:       if (r01 < y01 || (r01 == y01 && r2 < y2)) {  //xの仮数部<yの仮数部
 15304:         if (ze == 0) {  //|x|<|y|。商は0
 15305:           this.flg = zf | Z;
 15306:           return this;
 15307:         }
 15308:         qq = false;
 15309:       } else {
 15310:         qq = true;
 15311:         r2 -= y2;
 15312:         r01 -= y01;
 15313:         if (r2 < 0L) {
 15314:           r2 += 0x80000000L;
 15315:           r01--;
 15316:         }
 15317:       }
 15318:       long q0, q1, q2;
 15319:       //1桁目
 15320:       q0 = r01 >> 31 == y0 ? 0x7fffffffL : r01 / y0;
 15321:       r01 = (r01 - q0 * y0 << 31) + r2 - q0 * y1;
 15322:       if (r01 < 0L) {
 15323:         q0--;
 15324:         r01 += y01;
 15325:       }
 15326:       r2 = q0 * y2 + 0x7fffffffL;
 15327:       r01 -= r2 >> 31;
 15328:       r2 = ~r2 & 0x7fffffffL;  //~(r2 | ~0x7fffffffL)
 15329:       if (r01 < 0L) {
 15330:         q0--;
 15331:         r2 += y2;
 15332:         r01 += y01 + (r2 >> 31);
 15333:         r2 &= 0x7fffffffL;
 15334:       }
 15335:       if (ze <= 31) {
 15336:         q0 &= ~0x7fffffffL >> ze;
 15337:         q1 = q2 = 0L;
 15338:       } else {
 15339:         //2桁目
 15340:         q1 = r01 >> 31 == y0 ? 0x7fffffffL : r01 / y0;
 15341:         r01 = (r01 - q1 * y0 << 31) + r2 - q1 * y1;
 15342:         if (r01 < 0L) {
 15343:           q1--;
 15344:           r01 += y01;
 15345:         }
 15346:         r2 = q1 * y2 + 0x7fffffffL;
 15347:         r01 -= r2 >> 31;
 15348:         r2 = ~r2 & 0x7fffffffL;  //~(r2 | ~0x7fffffffL)
 15349:         if (r01 < 0L) {
 15350:           q1--;
 15351:           r2 += y2;
 15352:           r01 += y01 + (r2 >> 31);
 15353:           r2 &= 0x7fffffffL;
 15354:         }
 15355:         if (ze <= 62) {
 15356:           q1 &= ~0x7fffffffL >> ze - 31;
 15357:           q2 = 0L;
 15358:         } else {
 15359:           //3桁目
 15360:           q2 = r01 >> 31 == y0 ? 0x7fffffffL : r01 / y0;
 15361:           r01 = (r01 - q2 * y0 << 31) + r2 - q2 * y1;
 15362:           if (r01 < 0L) {
 15363:             q2--;
 15364:             r01 += y01;
 15365:           }
 15366:           r2 = q2 * y2 + 0x7fffffffL;
 15367:           r01 -= r2 >> 31;
 15368:           r2 = ~r2 & 0x7fffffffL;  //~(r2 | ~0x7fffffffL)
 15369:           if (r01 < 0L) {
 15370:             q2--;
 15371:             //r2 += y2;
 15372:             //r01 += y01 + (r2 >> 31);
 15373:             //r2 &= 0x7fffffffL;
 15374:           }
 15375:           if (ze <= 93) {
 15376:             q2 &= ~0x7fffffffL >> ze - 62;
 15377:           }
 15378:         }
 15379:       }
 15380:       //商  (((qq ? 1 : 0) << 31 | q0) << 31 | q1) << 31 | q2
 15381:       //正規化する
 15382:       if (qq) {  //商は94bit
 15383:         q0 = MSB | q0 << 32 | q1 << 1 | q2 >>> 30;
 15384:         q2 <<= -30;
 15385:       } else {  //商は93bit
 15386:         ze--;
 15387:         q0 = q0 << -31 | q1 << 2 | q2 >>> 29;
 15388:         q2 <<= -29;
 15389:       }
 15390:       return this.finish (zf, ze, q0, q2, 0L);
 15391:     }  //efp.quo(EFP,EFP)
 15392: 
 15393:     //------------------------------------------------------------------------
 15394:     //x = x.rad ()
 15395:     //  x*=pi/180
 15396:     //y = y.rad (x)
 15397:     //  y=x*pi/180
 15398:     //  pi/180倍(ラジアン)
 15399:     //
 15400:     //  グラフ
 15401:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{atan2(1,1)/45*$_[0]});print$g"
 15402:     //    echo read("../misc/efp.gp");eval("rad(x)=x*(Pi/180)");graph(rad) | gp -q
 15403:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 15404:     //    |                                       |                                       |
 15405:     //    |                                       |                                       |
 15406:     //    |                                       |                                       |
 15407:     //    |                                       |                                       |
 15408:     //    +                                       +                                       +
 15409:     //    |                                       |                                       |
 15410:     //    |                                       |                                       |
 15411:     //    |                                       |                                       |
 15412:     //    |                                       |                                       |
 15413:     //    +                                       +                                       +
 15414:     //    |                                       |                                       |
 15415:     //    |                                       |                                       |
 15416:     //    |                                       |                                       |
 15417:     //    |                                       |                                       |
 15418:     //    +                                       +                                       +
 15419:     //    |                                       |                                       |
 15420:     //    |                                       |                                       |
 15421:     //    |                                       |                                       |
 15422:     //    |                                       |                                       |
 15423:     //    *********************************************************************************
 15424:     //    |                                       |                                       |
 15425:     //    |                                       |                                       |
 15426:     //    |                                       |                                       |
 15427:     //    |                                       |                                       |
 15428:     //    +                                       +                                       +
 15429:     //    |                                       |                                       |
 15430:     //    |                                       |                                       |
 15431:     //    |                                       |                                       |
 15432:     //    |                                       |                                       |
 15433:     //    +                                       +                                       +
 15434:     //    |                                       |                                       |
 15435:     //    |                                       |                                       |
 15436:     //    |                                       |                                       |
 15437:     //    |                                       |                                       |
 15438:     //    +                                       +                                       +
 15439:     //    |                                       |                                       |
 15440:     //    |                                       |                                       |
 15441:     //    |                                       |                                       |
 15442:     //    |                                       |                                       |
 15443:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 15444:     //
 15445:     public final EFP rad () {
 15446:       return this.mul (this, TO_RAD);  //x*pi/180
 15447:     }  //efp.rad()
 15448:     public final EFP rad (EFP x) {
 15449:       return this.mul (x, TO_RAD);  //x*pi/180
 15450:     }  //efp.rad(EFP)
 15451: 
 15452:     //------------------------------------------------------------------------
 15453:     //y = y.random ()
 15454:     //  y=random()
 15455:     //  乱数
 15456:     //
 15457:     //  0以上1未満の乱数
 15458:     //  0以上1未満の1/2^LENの倍数がほぼ一様に出現するはず
 15459:     //  指数部が小さい数は有効桁数が少ない
 15460:     //
 15461:     public final EFP random () {
 15462:       int xf = P;
 15463:       int xe = -1;
 15464:       long xd = epbRand48 ();
 15465:       long xc = epbRand48 ();
 15466:       xd = xd << 16 | xc >>> 32;
 15467:       xc = xc << 32 & -LSB;
 15468:       if (xd != 0L) {
 15469:         int o = Long.numberOfLeadingZeros (xd);
 15470:         if (o > 0) {
 15471:           xe -= o;
 15472:           xd = xd << o | xc >>> -o;
 15473:           xc <<= o;
 15474:         }
 15475:       } else if (xc != 0L) {
 15476:         int o = Long.numberOfLeadingZeros (xc);
 15477:         xe -= 64 + o;
 15478:         xd = xc << o;
 15479:         xc = 0L;
 15480:       } else {
 15481:         xf = P | Z;
 15482:       }
 15483:       return this.finish (xf, xe, xd, xc, 0L);
 15484:     }  //efp.random()
 15485: 
 15486:     //------------------------------------------------------------------------
 15487:     //x = x.rcp ()
 15488:     //  x=1/x
 15489:     //y = y.rcp (x)
 15490:     //  y=1/x
 15491:     //  逆数 reciprocal
 15492:     //
 15493:     //  グラフ
 15494:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{1/$_[0]});print$g"
 15495:     //    echo read("../misc/efp.gp");eval("rcp(x)=1/x");graph(rcp) | gp -q
 15496:     //    +---------+---------+---------+---------+-**------+---------+---------+---------+
 15497:     //    |                                       |  *                                    |
 15498:     //    |                                       |  *                                    |
 15499:     //    |                                       |  *                                    |
 15500:     //    |                                       |  *                                    |
 15501:     //    +                                       +  *                                    +
 15502:     //    |                                       |  **                                   |
 15503:     //    |                                       |   *                                   |
 15504:     //    |                                       |   *                                   |
 15505:     //    |                                       |   **                                  |
 15506:     //    +                                       +    *                                  +
 15507:     //    |                                       |    **                                 |
 15508:     //    |                                       |     **                                |
 15509:     //    |                                       |      **                               |
 15510:     //    |                                       |       **                              |
 15511:     //    +                                       +        ***                            +
 15512:     //    |                                       |          ****                         |
 15513:     //    |                                       |             *******                   |
 15514:     //    |                                       |                   **************      |
 15515:     //    |                                       |                                ********
 15516:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 15517:     //    ********                                |                                       |
 15518:     //    |      **************                   |                                       |
 15519:     //    |                   *******             |                                       |
 15520:     //    |                         ****          |                                       |
 15521:     //    +                            ***        +                                       +
 15522:     //    |                              **       |                                       |
 15523:     //    |                               **      |                                       |
 15524:     //    |                                **     |                                       |
 15525:     //    |                                 **    |                                       |
 15526:     //    +                                  *    +                                       +
 15527:     //    |                                  **   |                                       |
 15528:     //    |                                   *   |                                       |
 15529:     //    |                                   *   |                                       |
 15530:     //    |                                   **  |                                       |
 15531:     //    +                                    *  +                                       +
 15532:     //    |                                    *  |                                       |
 15533:     //    |                                    *  |                                       |
 15534:     //    |                                    *  |                                       |
 15535:     //    |                                    *  |                                       |
 15536:     //    +---------+---------+---------+------**-+---------+---------+---------+---------+
 15537:     //
 15538:     //  ニュートン法
 15539:     //    f(x)=a-1/x
 15540:     //    f'(x)=1/x^2
 15541:     //    x'=x-f(x)/f'(x)
 15542:     //      =x-(a-1/x)/(1/x^2)
 15543:     //      =x-(a*x^2-x)
 15544:     //      =2*x-a*x^2
 15545:     //
 15546:     public final EFP rcp () {
 15547:       return this.div (ONE, this);
 15548:     }  //efp.rcp()
 15549:     public final EFP rcp (EFP x) {
 15550:       if (false) {  //1を割る。[93] 55.7ns。正確だが遅い
 15551:         return this.div (ONE, x);
 15552:       } else {  //ニュートン法。[91] 37.0ns。速いが誤差が大きい
 15553:         int xf = x.flg;
 15554:         if (xf << 1 != 0) {  //±0,±Inf,NaN
 15555:           if (xf << 1 < 0) {  //±0
 15556:             epbFpsr |= EPB_FPSR_DZ;
 15557:             epbExceptionOperandExponent = xf & M;
 15558:             epbExceptionOperandMantissa = 0x0000000000000000L;
 15559:             this.flg = xf ^ (Z | I);  //1/±0=±Inf
 15560:           } else if (xf << 2 < 0) {  //±Inf
 15561:             this.flg = xf ^ (Z | I);  //1/±Inf=±0
 15562:           } else {  //NaN
 15563:             this.flg = N;
 15564:           }
 15565:           return this;
 15566:         }
 15567:         //±0,±Inf,NaN以外
 15568:         this.inner ();
 15569:         long s = Double.doubleToLongBits (1.0 / Double.longBitsToDouble ((long) 1023 << 52 | x.dvl << 1 >>> 12));
 15570:         EFP t = new EFP (xf, (int) (s >>> 52) - 1023 - x.epp, MSB | s << 12 >>> 1, 0L);
 15571:         //return this.imul (x, t).negsub (TWO).outer ().mul (t);  //(2-x*t)*t。[91] 38.4ns
 15572:         this.imul2 (t);  //2*t
 15573:         t.isqu ().imul (x);  //x*t^2
 15574:         return this.outer ().sub (t);  //2*t-x*t^2。[91] 37.0ns。mulがsquになっている分速い
 15575:       }
 15576:     }  //efp.rcp(EFP)
 15577: 
 15578:     //------------------------------------------------------------------------
 15579:     //x = x.rcpdiv (y)
 15580:     //  x=y/x
 15581:     //  逆除算
 15582:     //
 15583:     //  x.div(y).rcp()と同じ
 15584:     //  z.rcpdiv(x,y)はz.div(y,x)と同じ
 15585:     //
 15586:     public final EFP rcpdiv (EFP y) {
 15587:       return this.div (y, this);
 15588:     }  //efp.rcpdiv(EFP)
 15589:     public final EFP rcpdiv (EFP x, EFP y) {
 15590:       return this.div (y, x);
 15591:     }  //efp.rcpdiv(EFP,EFP)
 15592: 
 15593:     //------------------------------------------------------------------------
 15594:     //x = x.rem (y)
 15595:     //  x%=y
 15596:     //z = z.rem (x, y)
 15597:     //  z=x%y
 15598:     //  剰余(round-to-zero)
 15599:     //
 15600:     //  x%y=x-trunc(x/y)*y
 15601:     //  (xn/xd)-trunc(x/y)*(yn/yd)
 15602:     //    =(xn/xd)-((trunc(x/y)*yn)/yd)
 15603:     //    =(xn*yd-xd*((trunc(x/y)*yn))/(xd*yd)
 15604:     //
 15605:     //  Javaのx%yと同じ
 15606:     //    x%y=x-(x/y)*y
 15607:     //       =isNaN(x)||isNaN(y)||isInfinite(x)?NaN:isInfinite(y)?x:(t=x-trunc(x/y)*y)==0?copySign(0,x):t
 15608:     //    Javaの%演算子はdoubleをdoubleのまま計算する
 15609:     //  被除数から0の方向にある最も近い除数の倍数を引いた結果を返す
 15610:     //  倍数の符号は任意なので除数の符号は結果に影響しない
 15611:     //     5.0 %  3.0 ==  5.0 - (long) ( 5.0 /  3.0) *  3.0 ==  2.0
 15612:     //     5.0 % -3.0 ==  5.0 - (long) ( 5.0 / -3.0) * -3.0 ==  2.0
 15613:     //    -5.0 %  3.0 == -5.0 - (long) (-5.0 /  3.0) *  3.0 == -2.0
 15614:     //    -5.0 % -3.0 == -5.0 - (long) (-5.0 / -3.0) * -3.0 == -2.0
 15615:     //  z  余り remainder
 15616:     //  x  被除数 dividend
 15617:     //  y  除数 divisor
 15618:     //
 15619:     public final EFP rem (EFP y) {
 15620:       return this.rem (this, y);
 15621:     }  //efp.rem(EFP)
 15622:     public final EFP rem (EFP x, EFP y) {
 15623:       int xf = x.flg;
 15624:       int yf = y.flg;
 15625:       epbFpsr &= 0xff00ffff;  //quotient byteをクリアする
 15626:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
 15627:         if ((xf | yf) << 3 < 0) {  //rem(NaN,y)=NaN, rem(x,NaN)=NaN
 15628:           this.flg = N;
 15629:         } else if (xf << 2 < 0 ||  //rem(±Inf,y)=NaN
 15630:                    yf << 1 < 0) {  //rem(x,±0)=NaN
 15631:           //除数が±0でもゼロ除算にはならない
 15632:           epbFpsr |= EPB_FPSR_OE;
 15633:           if (yf << 1 < 0) {  //±0
 15634:             epbExceptionOperandExponent = yf & M;
 15635:             epbExceptionOperandMantissa = 0x0000000000000000L;
 15636:           } else if (yf << 2 < 0) {  //±Inf
 15637:             epbExceptionOperandExponent = yf & M | 0x7fff << 16;
 15638:             epbExceptionOperandMantissa = 0x0000000000000000L;
 15639:           } else {  //±y
 15640:             epbExceptionOperandExponent = yf & M | 0x3fff + y.epp << 16;
 15641:             epbExceptionOperandMantissa = y.dvl;
 15642:           }
 15643:           this.flg = N;
 15644:         } else if (xf << 1 < 0) {  //rem(±0,y)=±0
 15645:           epbFpsr |= ((xf ^ yf) & M) >>> 8;  //quotient byteに商の符号を入れる
 15646:           this.flg = xf;
 15647:         } else {  //rem(x,±Inf)=x
 15648:           epbFpsr |= ((xf ^ yf) & M) >>> 8;  //quotient byteに商の符号を入れる
 15649:           this.finish (xf, x.epp, x.dvl, x.cvl, 0L);  //xが非正規化数のときUFをセットする
 15650:         }
 15651:         return this;
 15652:       }
 15653:       //両方±0,±Inf,NaN以外
 15654:       epbFpsr |= ((xf ^ yf) & M) >>> 8;  //quotient byteに商の符号を入れる
 15655:       if (false) {
 15656:         this.inner ();
 15657:         //this.sub (x, new EFP ().div (x, y).trunc ().imul (y));  //x-trunc(x/y)*y。this==x||this==yの場合に注意
 15658:         int s;
 15659:         long t;
 15660:         if ((s = x.epp - y.epp) < 0 ||
 15661:             s == 0 && ((t = x.dvl - y.dvl) < 0L ||
 15662:                        t == 0L && (x.cvl >>> 1) - (y.cvl >>> 1) < 0L)) {  //|x|<|y|。商が0
 15663:           //this.sete (x);  //被除数がそのまま余りになる
 15664:           this.flg = xf;
 15665:           this.epp = x.epp;
 15666:           this.dvl = x.dvl;
 15667:           this.cvl = x.cvl;
 15668:         } else {  //|x|>=|y|。商が0ではない
 15669:           EFP xx = x != this ? x : new EFP (x);  //xのコピー
 15670:           EFP yy = y != this ? y : new EFP (y);  //yのコピー
 15671:           this.divrz (xx, yy).trunc ();  //trunc(x/y)。商。divを使うと丸め(RN)で商の絶対値が1大きくなってしまうことがあるのでdivrzを使う
 15672:           epbQuotient = this.geti32abs ();
 15673:           epbFpsr |= (epbQuotient & 127) << 16;  //商の絶対値の下位7bit
 15674:           EFP ww = new EFP ();
 15675:           this.imulw (ww, this, yy).negsub (xx).sub (ww);  //x-trunc(x/y)*y。余り。xがyの倍数に近いとき桁落ちが発生するので乗算を倍精度で行う
 15676:           if (this.flg << 1 < 0) {  //余りが0
 15677:             this.flg = xf | Z;  //0にxの符号を付ける
 15678:           }
 15679:         }
 15680:         return this.outer ().finish ();
 15681:       } else {
 15682:         this.inner ();
 15683:         int ye = y.epp;  //this==yの場合があるので順序に注意する
 15684:         long yd = y.dvl;
 15685:         long yc = y.cvl;
 15686:         long yc1 = yc >>> 1;
 15687:         this.epp = x.epp;
 15688:         this.dvl = x.dvl;
 15689:         this.cvl = x.cvl;
 15690:         int i;
 15691:         long l;
 15692:         int q = 0;
 15693:         if ((i = this.epp - ye) > 0 ||
 15694:             i == 0 && ((l = this.dvl - yd) > 0L ||
 15695:                        l == 0L && this.cvl >>> 1 >= yc1)) {  //|x|>=|y|。商は0ではない
 15696:           this.flg = P;  //|x|。余りの初期値
 15697:           EFP t = new EFP (P, 0, yd, yc);
 15698:           do {
 15699:             t.epp = i = (l = this.dvl - yd) > 0L || l == 0L && this.cvl >>> 1 >= yc1 ? this.epp : this.epp - 1;  //指数部を揃えて
 15700:             if ((i -= ye) <= 31) {
 15701:               q |= 1 << i;
 15702:             }
 15703:             this.sub (t);  //引く。アンダーフローのチェックは後で行う
 15704:           } while (this.flg == 0 &&  //0ではない
 15705:                    ((i = this.epp - ye) > 0 ||
 15706:                     i == 0 && ((l = this.dvl - yd) > 0L ||
 15707:                                l == 0L && this.cvl >>> 1 >= yc1)));  //this>=|y|。まだ引ける。指数部が極端に違うと繰り返す回数が大きくなる
 15708:           this.flg |= xf;  //余りが0の場合も含めてyの符号に関係なくxの符号を付ける
 15709:         } else {  //|x|<|y|。商は0
 15710:           this.flg = xf;  //被除数がそのまま余りになる
 15711:         }
 15712:         epbQuotient = q;
 15713:         epbFpsr |= (q & 127) << 16;  //商の絶対値の下位7bit
 15714:         return this.outer ().finish ();
 15715:       }
 15716:     }  //efp.rem(EFP,EFP)
 15717: 
 15718:     //------------------------------------------------------------------------
 15719:     //x = x.rint ()
 15720:     //  x=rint(x)
 15721:     //y = y.rint (x)
 15722:     //  y=rint(x)
 15723:     //  丸め(nearest-even)
 15724:     //
 15725:     //  グラフ
 15726:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{my$x=$_[0];my$t=int$x;my$f=abs($x-$t);$t+($f==0.5&&($t&1)!=0||$f>0.5?$x<=>0:0)});print$g"
 15727:     //    echo read("../misc/efp.gp");eval("rint(x)={my(f=floor(x),s=sign(x-floor(x)-0.5));if(s==0&&(f%2==0)||s<0,f,f+1)}");graph(rint) | gp -q
 15728:     //    +---------+---------+---------+---------+---------+---------+---------+----******
 15729:     //    |                                       |                                       |
 15730:     //    |                                       |                                       |
 15731:     //    |                                       |                                       |
 15732:     //    |                                       |                                       |
 15733:     //    +                                       +                        ***********    +
 15734:     //    |                                       |                                       |
 15735:     //    |                                       |                                       |
 15736:     //    |                                       |                                       |
 15737:     //    |                                       |                                       |
 15738:     //    +                                       +              ***********              +
 15739:     //    |                                       |                                       |
 15740:     //    |                                       |                                       |
 15741:     //    |                                       |                                       |
 15742:     //    |                                       |                                       |
 15743:     //    +                                       +    ***********                        +
 15744:     //    |                                       |                                       |
 15745:     //    |                                       |                                       |
 15746:     //    |                                       |                                       |
 15747:     //    |                                       |                                       |
 15748:     //    +---------+---------+---------+----***********----+---------+---------+---------+
 15749:     //    |                                       |                                       |
 15750:     //    |                                       |                                       |
 15751:     //    |                                       |                                       |
 15752:     //    |                                       |                                       |
 15753:     //    +                        ***********    +                                       +
 15754:     //    |                                       |                                       |
 15755:     //    |                                       |                                       |
 15756:     //    |                                       |                                       |
 15757:     //    |                                       |                                       |
 15758:     //    +              ***********              +                                       +
 15759:     //    |                                       |                                       |
 15760:     //    |                                       |                                       |
 15761:     //    |                                       |                                       |
 15762:     //    |                                       |                                       |
 15763:     //    +    ***********                        +                                       +
 15764:     //    |                                       |                                       |
 15765:     //    |                                       |                                       |
 15766:     //    |                                       |                                       |
 15767:     //    |                                       |                                       |
 15768:     //    ******----+---------+---------+---------+---------+---------+---------+---------+
 15769:     //
 15770:     //  最も近い整数に丸める
 15771:     //  小数点以下が0.5のときは偶数の方向に丸める
 15772:     //
 15773:     public final EFP rint () {
 15774:       return this.rint (this);
 15775:     }  //efp.rint()
 15776:     public final EFP rint (EFP x) {  //4.6ns
 15777:       int xf = x.flg;
 15778:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 15779:         this.flg = xf;
 15780:         return this;
 15781:       }
 15782:       //±0,±Inf,NaN以外
 15783:       int xe = x.epp;
 15784:       long xd = x.dvl;
 15785:       long xc = x.cvl;
 15786:       if (xe < 0) {  //0<|x|<1
 15787:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 15788:         if (xe < -1 || xd == MSB && xc == 0L) {  //0<|x|<=1/2
 15789:           this.flg = xf | Z;  //rint(-1/2<=x<0)=-0, rint(0<x<=1/2)=+0
 15790:         } else {  //1/2<|x|<1
 15791:           this.flg = xf;  //rint(-1<x<-1/2)=-1, rint(1/2<x<1)=1
 15792:           this.epp = 0;
 15793:           this.dvl = MSB;
 15794:           this.cvl = 0L;
 15795:         }
 15796:         return this;
 15797:       }
 15798:       //整数部がある
 15799:       long m = MSB >> xe;  //整数部のマスク。符号に注意
 15800:       if (xe <= 62) {  //0..62。dの途中まで整数部
 15801:         if ((xd & ~m | xc) != 0L) {  //小数部が0ではない
 15802:           epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 15803:           long t = xd;  //保存して
 15804:           xd &= m;  //小数部を切り捨てる
 15805:           if ((t & -(m >> 1)) != 0L && (t & (-m | ~(m >> 1)) | xc) != 0L) {  //guard bitが1かつLSBまたはguard bit以外の端数が0ではない
 15806:             xd -= m;  //絶対値に1を加える。符号に注意
 15807:             if (xd >= 0L) {  //dから溢れた
 15808:               xd = MSB;
 15809:               xe++;
 15810:               if ((short) xe != xe) {  //オーバーフローした
 15811:                 epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 15812:                 epbExceptionOperandExponent = xf;
 15813:                 epbExceptionOperandMantissa = xd;
 15814:                 return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | xf >>> 31]).finish ();  //±Inf
 15815:               }
 15816:             }
 15817:           }
 15818:           xc = 0L;
 15819:         }
 15820:       } else if (xe == 63) {  //63。dの末尾まで整数部
 15821:         if (xc != 0L) {  //小数部が0ではない
 15822:           epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 15823:           if (xc < 0L && (xd << -1 | xc << 1) != 0L) {  //guard bitが1かつLSBまたはguard bit以外の端数が0ではない
 15824:             xd++;  //絶対値に1を加える
 15825:             if (xd >= 0L) {  //dから溢れた
 15826:               xd = MSB;
 15827:               xe++;
 15828:               if ((short) xe != xe) {  //オーバーフローした
 15829:                 epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 15830:                 epbExceptionOperandExponent = xf;
 15831:                 epbExceptionOperandMantissa = xd;
 15832:                 return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | xf >>> 31]).finish ();  //±Inf
 15833:               }
 15834:             }
 15835:           }
 15836:           xc = 0L;
 15837:         }
 15838:       } else if (xe <= LEN - 2) {  //64..90。cの途中まで整数部
 15839:         if ((xc & ~m) != 0L) {  //小数部が0ではない
 15840:           epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 15841:           long t = xc;  //保存して
 15842:           xc &= m;  //小数部を切り捨てる
 15843:           if ((t & -(m >> 1)) != 0L && (t & (-m | ~(m >> 1))) != 0L) {  //guard bitが1かつLSBまたはguard bit以外の端数が0ではない
 15844:             xc -= m;  //絶対値に1を加える。符号に注意
 15845:             if ((t ^ xc) < 0L) {  //cから溢れた
 15846:               xd++;
 15847:               if (xd >= 0L) {  //dから溢れた
 15848:                 xd = MSB;
 15849:                 xe++;
 15850:                 if ((short) xe != xe) {  //オーバーフローした
 15851:                   epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 15852:                   epbExceptionOperandExponent = xf;
 15853:                   epbExceptionOperandMantissa = xd;
 15854:                   return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | xf >>> 31]).finish ();  //±Inf
 15855:                 }
 15856:               }
 15857:             }
 15858:           }
 15859:         }
 15860:       }
 15861:       //すべて整数部のときはそのまま
 15862:       return finish (xf, xe, xd, xc, 0L);
 15863:     }  //efp.rint(EFP)
 15864: 
 15865:     //------------------------------------------------------------------------
 15866:     //x = x.round ()
 15867:     //x = x.round (roundingMode)
 15868:     //x = x.round (x)
 15869:     //x = x.round (x, roundingMode)
 15870:     //  丸め
 15871:     //
 15872:     //  サイズの制限を与えずに整数に丸める
 15873:     //
 15874:     public final EFP round () {
 15875:       return this.round (this, EPB_MODE_RN);
 15876:     }  //efp.round()
 15877:     public final EFP round (int roundingMode) {
 15878:       return this.round (this, roundingMode);
 15879:     }  //efp.round(int)
 15880:     public final EFP round (EFP x) {
 15881:       return this.round (x, EPB_MODE_RN);
 15882:     }  //efp.round(EFP)
 15883:     public final EFP round (EFP x, int roundingMode) {
 15884:       return (roundingMode == EPB_MODE_RN ? this.rint (x) :
 15885:               roundingMode == EPB_MODE_RM ? this.floor (x) :
 15886:               roundingMode == EPB_MODE_RP ? this.ceil (x) :
 15887:               this.trunc (x));
 15888:     }  //efp.round(EFP,int)
 15889: 
 15890:     //------------------------------------------------------------------------
 15891:     //x = x.roundd ()
 15892:     //x = x.roundd (roundingMode)
 15893:     //x = x.roundd (x)
 15894:     //x = x.roundd (x, roundingMode)
 15895:     //  double丸め
 15896:     //
 15897:     //  この関数はepbRoundingModeとepbRoundingPrecを無視する
 15898:     //  double(指数部11bit,仮数部52+1bit,非正規化数を含む)で表現できる値に丸める
 15899:     //  doubleで表現できないときは±Infに変換する
 15900:     //
 15901:     public final EFP roundd () {
 15902:       return this.roundd (this, EPB_MODE_RN);
 15903:     }  //efp.roundd()
 15904:     public final EFP roundd (int roundingMode) {
 15905:       return this.roundd (this, roundingMode);
 15906:     }  //efp.roundd(int)
 15907:     public final EFP roundd (EFP x) {
 15908:       return this.roundd (x, EPB_MODE_RN);
 15909:     }  //efp.roundd(EFP)
 15910:     public final EFP roundd (EFP x, int roundingMode) {
 15911:       int xf = x.flg;
 15912:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 15913:         this.flg = xf;
 15914:         return this;
 15915:       }
 15916:       //±0,±Inf,NaN以外
 15917:       int xe = x.epp;  //正規化数は-1022<=xe<=1023、非正規化数は-1075<=xe<=-1023
 15918:       long xd = x.dvl;
 15919:       long xc = x.cvl;
 15920:       if (xe < -1075) {  //指数部が小さすぎる。非正規化数の最小値は2^-1074だが丸めで繰り上がる場合があるので一旦2^-1075まで受け入れる
 15921:         epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 15922:         epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 15923:         epbExceptionOperandMantissa = xd;
 15924:         return this.sete (UNFL_RESULTS[EPB_PREC_DBL << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 15925:       }
 15926:       if (1023 < xe) {  //指数部が大きすぎる
 15927:         if (true) {
 15928:           epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 15929:           if ((xd << 53 | xc) != 0L) {  //端数が0ではない
 15930:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 15931:           }
 15932:         } else {
 15933:           epbFpsr |= EPB_FPSR_OF | EPB_FPSR_X2;  //オーバーフロー、不正確な結果
 15934:         }
 15935:         epbExceptionOperandExponent = xf | 0x3fff - 0x6000 + xe << 16;
 15936:         epbExceptionOperandMantissa = xd;
 15937:         return this.sete (OVFL_RESULTS[EPB_PREC_DBL << 3 | roundingMode << 1 | xf >>> 31]);  //±Inf
 15938:       }
 15939:       long xb = 0L;
 15940:       int o = xe <= -1023 ? 11 + -1022 - xe : 11;  //右にずらすbit数。正規化数は11、非正規化数は11+1<=o<=11+53
 15941:       if (o < 64) {
 15942:         xb = xc << -o;
 15943:         xc = xd << -o | xc >>> o;
 15944:         xd >>>= o;
 15945:       } else {
 15946:         xb = xc;
 15947:         xc = xd;
 15948:         xd = 0L;
 15949:       }
 15950:       if ((xc | xb) != 0L) {  //端数が0ではない
 15951:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 15952:         epbExceptionOperandExponent = x.flg & M | 0x3fff + 0x6000 + x.epp << 16;
 15953:         epbExceptionOperandMantissa = x.dvl;
 15954:         if (roundingMode == EPB_MODE_RN && xc < 0L && (xd << 63 | xc << 1 | xb) != 0L ||  //RNでguard bitが1かつLSBまたはguard bit以外の端数が0ではないまたは
 15955:             roundingMode == EPB_MODE_RM && xf < 0 ||  //端数が0ではなくてRMで-または
 15956:             roundingMode == EPB_MODE_RP && 0 <= xf) {  //端数が0ではなくてRPで+のとき
 15957:           xd++;  //繰り上げる
 15958:           if (xd >>> 53 != 0L) {  //繰り上がって溢れたとき
 15959:             xd = 1L << 52;
 15960:             xe++;  //指数部をインクリメントする。ここでxe=1024になる場合がある
 15961:             if (1023 < xe) {  //指数部が大きすぎる
 15962:               epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 15963:               return this.sete (OVFL_RESULTS[EPB_PREC_DBL << 3 | roundingMode << 1 | xf >>> 31]);  //±Inf
 15964:             }
 15965:           } else if (11 < o) {  //非正規化数のとき
 15966:             if (xd << o - 1 < 0L) {  //1bit増えたとき
 15967:               xe++;  //指数部をインクリメントする
 15968: /* roundd */
 15969:               if (xe == -1022) {  //非正規化数が繰り上がって正規化数になったとき
 15970:                 //xd = 1L << 52;
 15971:                 epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 15972:                 epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 15973:                 epbExceptionOperandMantissa = xd;
 15974:               }
 15975: /**/
 15976:             }
 15977:           }
 15978:         }
 15979:         //RZ toward zeroのときは端数を切り捨てるだけなので何もしなくてよい
 15980:         if (xe <= -1023) {  //非正規化数
 15981:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 15982:           if (xd == 0L) {  //非正規化数でxe==-1075だったとき、先頭の1がxcにあって丸めで繰り上がらなかった
 15983:             return this.sete (UNFL_RESULTS[EPB_PREC_DBL << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 15984:           }
 15985:         }  //if 非正規化数
 15986:       } else {  //端数が0
 15987:         if (xe <= -1023) {  //非正規化数
 15988:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 15989:           epbExceptionOperandExponent = x.flg & M | 0x3fff + 0x6000 + x.epp << 16;
 15990:           epbExceptionOperandMantissa = x.dvl;
 15991:           if (xd == 0L) {  //非正規化数でxe==-1075だったとき、先頭の1がxcにあって丸めで繰り上がらなかった
 15992:             return this.sete (UNFL_RESULTS[EPB_PREC_DBL << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 15993:           }
 15994:         }  //if 非正規化数
 15995:       }  //if 端数が0ではない/端数が0
 15996:       xd <<= Long.numberOfLeadingZeros (xd);  //xcとxbはゴミが残っているので加えないこと
 15997:       //結果
 15998:       this.flg = xf;
 15999:       this.epp = xe;
 16000:       this.dvl = xd;
 16001:       this.cvl = 0L;
 16002:       return this;
 16003:     }  //efp.roundd(EFP,int)
 16004: 
 16005:     //------------------------------------------------------------------------
 16006:     //x = x.roundf ()
 16007:     //x = x.roundf (roundingMode)
 16008:     //y = y.roundf (x)
 16009:     //y = y.roundf (x, roundingMode)
 16010:     //  float丸め
 16011:     //
 16012:     //  この関数はepbRoundingModeとepbRoundingPrecを無視する
 16013:     //  float(指数部8bit,仮数部23+1bit,非正規化数を含む)で表現できる値に丸める
 16014:     //  floatで表現できないときは±Infに変換する
 16015:     //
 16016:     public final EFP roundf () {
 16017:       return this.roundf (this, EPB_MODE_RN);
 16018:     }  //efp.roundf()
 16019:     public final EFP roundf (int roundingMode) {
 16020:       return this.roundf (this, roundingMode);
 16021:     }  //efp.roundf(int)
 16022:     public final EFP roundf (EFP x) {
 16023:       return this.roundf (x, EPB_MODE_RN);
 16024:     }  //efp.roundf(EFP)
 16025:     public final EFP roundf (EFP x, int roundingMode) {
 16026:       int xf = x.flg;
 16027:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 16028:         this.flg = xf;
 16029:         return this;
 16030:       }
 16031:       //±0,±Inf,NaN以外
 16032:       int xe = x.epp;  //正規化数は-126<=xe<=127、非正規化数は-149<=xe<=-127
 16033:       long xd = x.dvl;
 16034:       long xc = x.cvl;
 16035:       if (xe < -150) {  //指数部が小さすぎる。非正規化数の最小値は2^-149だが丸めで繰り上がる場合があるので一旦2^-150まで受け入れる
 16036:         epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 16037:         epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 16038:         epbExceptionOperandMantissa = xd;
 16039:         return this.sete (UNFL_RESULTS[EPB_PREC_SGL << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 16040:       }
 16041:       if (127 < xe) {  //指数部が大きすぎる
 16042:         if (true) {
 16043:           epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 16044:           if ((xd << 24 | xc) != 0L) {  //端数が0ではない
 16045:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 16046:           }
 16047:         } else {
 16048:           epbFpsr |= EPB_FPSR_OF | EPB_FPSR_X2;  //オーバーフロー、不正確な結果
 16049:         }
 16050:         epbExceptionOperandExponent = xf | 0x3fff - 0x6000 + xe << 16;
 16051:         epbExceptionOperandMantissa = xd;
 16052:         return this.sete (OVFL_RESULTS[EPB_PREC_SGL << 3 | roundingMode << 1 | xf >>> 31]);  //±Inf
 16053:       }
 16054:       long xb = 0L;
 16055:       int o = xe <= -127 ? 40 + -126 - xe : 40;  //右にずらすbit数。正規化数は40、非正規化数は40+1<=o<=40+24
 16056:       if (o < 64) {
 16057:         xb = xc << -o;
 16058:         xc = xd << -o | xc >>> o;
 16059:         xd >>>= o;
 16060:       } else {
 16061:         xb = xc;
 16062:         xc = xd;
 16063:         xd = 0L;
 16064:       }
 16065:       if ((xc | xb) != 0L) {  //端数が0ではない
 16066:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 16067:         epbExceptionOperandExponent = x.flg & M | 0x3fff + 0x6000 + x.epp << 16;
 16068:         epbExceptionOperandMantissa = x.dvl;
 16069:         if (roundingMode == EPB_MODE_RN && xc < 0L && (xd << -1 | xc << 1 | xb) != 0L ||  //RNでguard bitが1かつLSBまたはguard bit以外の端数が0ではないまたは
 16070:             roundingMode == EPB_MODE_RM && xf < 0 ||  //端数が0ではなくてRMで-または
 16071:             roundingMode == EPB_MODE_RP && 0 <= xf) {  //端数が0ではなくてRPで+のとき
 16072:           xd++;  //繰り上げる
 16073:           if (xd >>> 24 != 0L) {  //繰り上がって溢れたとき
 16074:             xd = 1L << 23;
 16075:             xe++;  //指数部をインクリメントする。ここでxe=128になる場合がある
 16076:             if (127 < xe) {  //指数部が大きすぎる
 16077:               epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 16078:               return this.sete (OVFL_RESULTS[EPB_PREC_SGL << 3 | roundingMode << 1 | xf >>> 31]);  //±Inf
 16079:             }
 16080:           } else if (40 < o) {  //非正規化数のとき
 16081:             if (xd << o - 1 < 0L) {  //1bit増えたとき
 16082:               xe++;  //指数部をインクリメントする
 16083: /* roundf */
 16084:               if (xe == -126) {  //非正規化数が繰り上がって正規化数になったとき
 16085:                 //xd = 1L << 23;
 16086:                 epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 16087:                 epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 16088:                 epbExceptionOperandMantissa = xd;
 16089:               }
 16090: /**/
 16091:             }
 16092:           }
 16093:         }
 16094:         //RZ toward zeroのときは端数を切り捨てるだけなので何もしなくてよい
 16095:         if (xe <= -127) {  //非正規化数
 16096:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 16097:           if (xd == 0L) {  //非正規化数でxe==-150だったとき、先頭の1がxcにあって丸めで繰り上がらなかった
 16098:             return this.sete (UNFL_RESULTS[EPB_PREC_SGL << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 16099:           }
 16100:         }  //if 非正規化数
 16101:       } else {  //端数が0
 16102:         if (xe <= -127) {  //非正規化数
 16103:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 16104:           epbExceptionOperandExponent = x.flg & M | 0x3fff + 0x6000 + x.epp << 16;
 16105:           epbExceptionOperandMantissa = x.dvl;
 16106:           if (xd == 0L) {  //非正規化数でxe==-150だったとき、先頭の1がxcにあって丸めで繰り上がらなかった
 16107:             return this.sete (UNFL_RESULTS[EPB_PREC_SGL << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 16108:           }
 16109:         }
 16110:       }
 16111:       xd <<= Long.numberOfLeadingZeros (xd);  //xcとxbはゴミが残っているので加えないこと
 16112:       //結果
 16113:       this.flg = xf;
 16114:       this.epp = xe;
 16115:       this.dvl = xd;
 16116:       this.cvl = 0L;
 16117:       return this;
 16118:     }  //efp.roundf(EFP,int)
 16119: 
 16120:     //------------------------------------------------------------------------
 16121:     //x = x.roundg ()
 16122:     //x = x.roundg (roundingMode)
 16123:     //y = y.roundg (x)
 16124:     //y = y.roundg (x, roundingMode)
 16125:     //  xsg丸め
 16126:     //
 16127:     //  この関数はepbRoundingModeとepbRoundingPrecを無視する
 16128:     //  xsg(指数部15bit,仮数部23+1bit,非正規化数を含む)で表現できる値に丸める
 16129:     //  xsgで表現できないときは±Infに変換する
 16130:     //
 16131:     public final EFP roundg () {
 16132:       return this.roundg (this, EPB_MODE_RN);
 16133:     }  //efp.roundg()
 16134:     public final EFP roundg (int roundingMode) {
 16135:       return this.roundg (this, roundingMode);
 16136:     }  //efp.roundg(int)
 16137:     public final EFP roundg (EFP x) {
 16138:       return this.roundg (x, EPB_MODE_RN);
 16139:     }  //efp.roundg(EFP)
 16140:     public final EFP roundg (EFP x, int roundingMode) {
 16141:       int xf = x.flg;
 16142:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 16143:         this.flg = xf;
 16144:         return this;
 16145:       }
 16146:       //±0,±Inf,NaN以外
 16147:       int xe = x.epp;  //正規化数は-16383<=xe<=16383、非正規化数は-16406<=xe<=-16384
 16148:       long xd = x.dvl;
 16149:       long xc = x.cvl;
 16150:       if (xe < -16407) {  //指数部が小さすぎる。非正規化数の最小値は2^-16406だが丸めで繰り上がる場合があるので一旦2^-16407まで受け入れる
 16151:         epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 16152:         epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 16153:         epbExceptionOperandMantissa = xd;
 16154:         return this.sete (UNFL_RESULTS[EPB_PREC_XSG << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 16155:       }
 16156:       if (16383 < xe) {  //指数部が大きすぎる
 16157:         if (true) {
 16158:           epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 16159:           if ((xd << 24 | xc) != 0L) {  //端数が0ではない
 16160:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 16161:           }
 16162:         } else {
 16163:           epbFpsr |= EPB_FPSR_OF | EPB_FPSR_X2;  //オーバーフロー、不正確な結果
 16164:         }
 16165:         epbExceptionOperandExponent = xf | 0x3fff - 0x6000 + xe << 16;
 16166:         epbExceptionOperandMantissa = xd;
 16167:         return this.sete (OVFL_RESULTS[EPB_PREC_XSG << 3 | roundingMode << 1 | xf >>> 31]);  //±Inf
 16168:       }
 16169:       long xb = 0L;
 16170:       int o = xe <= -16384 ? 40 + -16383 - xe : 40;  //右にずらすbit数。正規化数は40、非正規化数は40+1<=o<=40+24
 16171:       if (o < 64) {
 16172:         xb = xc << -o;
 16173:         xc = xd << -o | xc >>> o;
 16174:         xd >>>= o;
 16175:       } else {
 16176:         xb = xc;
 16177:         xc = xd;
 16178:         xd = 0L;
 16179:       }
 16180:       if ((xc | xb) != 0L) {  //端数が0ではない
 16181:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 16182:         epbExceptionOperandExponent = x.flg & M | 0x3fff + 0x6000 + x.epp << 16;
 16183:         epbExceptionOperandMantissa = x.dvl;
 16184:         if (roundingMode == EPB_MODE_RN && xc < 0L && (xd << -1 | xc << 1 | xb) != 0L ||  //RNでguard bitが1かつLSBまたはguard bit以外の端数が0ではないまたは
 16185:             roundingMode == EPB_MODE_RM && xf < 0 ||  //端数が0ではなくてRMで-または
 16186:             roundingMode == EPB_MODE_RP && 0 <= xf) {  //端数が0ではなくてRPで+のとき
 16187:           xd++;  //繰り上げる
 16188:           if (xd >>> 24 != 0L) {  //繰り上がって溢れたとき
 16189:             xd = 1L << 23;
 16190:             xe++;  //指数部をインクリメントする。ここでxe=16384になる場合がある
 16191:             if (16383 < xe) {  //指数部が大きすぎる
 16192:               epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 16193:               return this.sete (OVFL_RESULTS[EPB_PREC_XSG << 3 | roundingMode << 1 | xf >>> 31]);  //±Inf
 16194:             }
 16195:           } else if (40 < o) {  //非正規化数のとき
 16196:             if (xd << o - 1 < 0L) {  //1bit増えたとき
 16197:               xe++;  //指数部をインクリメントする
 16198: /* roundg
 16199:               if (xe == -16383) {  //非正規化数が繰り上がって正規化数になったとき
 16200:                 //xd = 1L << 23;
 16201:                 epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 16202:                 epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 16203:                 epbExceptionOperandMantissa = xd;
 16204:               }
 16205: */
 16206:             }
 16207:           }
 16208:         }
 16209:         //RZ toward zeroのときは端数を切り捨てるだけなので何もしなくてよい
 16210:         if (xe <= -16384) {  //非正規化数
 16211:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 16212:           if (xd == 0L) {  //非正規化数でxe==-16407だったとき、先頭の1がxcにあって丸めで繰り上がらなかった
 16213:             return this.sete (UNFL_RESULTS[EPB_PREC_XSG << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 16214:           }
 16215:         }  //if 非正規化数
 16216:       } else {  //端数が0
 16217:         if (xe <= -16384) {  //非正規化数
 16218:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 16219:           epbExceptionOperandExponent = x.flg & M | 0x3fff + 0x6000 + x.epp << 16;
 16220:           epbExceptionOperandMantissa = x.dvl;
 16221:           if (xd == 0L) {  //非正規化数でxe==-16407だったとき、先頭の1がxcにあって丸めで繰り上がらなかった
 16222:             return this.sete (UNFL_RESULTS[EPB_PREC_XSG << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 16223:           }
 16224:         }
 16225:       }
 16226:       xd <<= Long.numberOfLeadingZeros (xd);  //xcとxbはゴミが残っているので加えないこと
 16227:       //結果
 16228:       this.flg = xf;
 16229:       this.epp = xe;
 16230:       this.dvl = xd;
 16231:       this.cvl = 0L;
 16232:       return this;
 16233:     }  //efp.roundg(EFP,int)
 16234: 
 16235:     //------------------------------------------------------------------------
 16236:     //x = x.roundi ()
 16237:     //x = x.roundi (roundingMode)
 16238:     //x = x.roundi (x)
 16239:     //x = x.roundi (x, roundingMode)
 16240:     //  int丸め
 16241:     //
 16242:     //  int(32bit整数)に丸める
 16243:     //  2^31-1よりも大きい数は2^31-1に、-2^31よりも小さい数は-2^31に変換する(飽和変換)
 16244:     //  NaNは0に変換する
 16245:     //
 16246:     public final EFP roundi () {
 16247:       return this.roundi (this, EPB_MODE_RN);
 16248:     }  //efp.roundi()
 16249:     public final EFP roundi (int roundingMode) {
 16250:       return this.roundi (this, roundingMode);
 16251:     }  //efp.roundi(int)
 16252:     public final EFP roundi (EFP x) {
 16253:       return this.roundi (x, EPB_MODE_RN);
 16254:     }  //efp.roundi(EFP)
 16255:     public final EFP roundi (EFP x, int roundingMode) {
 16256:       return this.seti (x.geti (roundingMode));
 16257:     }  //efp.roundi(EFP,int)
 16258: 
 16259:     //------------------------------------------------------------------------
 16260:     //x = x.roundl ()
 16261:     //x = x.roundl (roundingMode)
 16262:     //x = x.roundl (x)
 16263:     //x = x.roundl (x, roundingMode)
 16264:     //  long丸め
 16265:     //
 16266:     //  long(64bit整数)に丸める
 16267:     //  2^63-1よりも大きい数は2^63-1に、-2^63よりも小さい数は-2^63に変換する(飽和変換)
 16268:     //  NaNは0に変換する
 16269:     //
 16270:     public final EFP roundl () {
 16271:       return this.roundl (this, EPB_MODE_RN);
 16272:     }  //efp.roundl()
 16273:     public final EFP roundl (int roundingMode) {
 16274:       return this.roundl (this, roundingMode);
 16275:     }  //efp.roundl(int)
 16276:     public final EFP roundl (EFP x) {
 16277:       return this.roundl (x, EPB_MODE_RN);
 16278:     }  //efp.roundl(EFP)
 16279:     public final EFP roundl (EFP x, int roundingMode) {
 16280:       return this.setl (x.getl (roundingMode));
 16281:     }  //efp.roundl(EFP,int)
 16282: 
 16283:     //------------------------------------------------------------------------
 16284:     //x = x.roundmand ()
 16285:     //x = x.roundmand (roundingMode)
 16286:     //x = x.roundmand (x)
 16287:     //x = x.roundmand (x, roundingMode)
 16288:     //  仮数部double丸め
 16289:     //  仮数部を(1+52)bitに丸める
 16290:     //
 16291:     public final EFP roundmand () {
 16292:       return this.roundmand (this, EPB_MODE_RN);
 16293:     }  //efp.roundmand()
 16294:     public final EFP roundmand (int roundingMode) {
 16295:       return this.roundmand (this, roundingMode);
 16296:     }  //efp.roundmand(int)
 16297:     public final EFP roundmand (EFP x) {
 16298:       return this.roundmand (x, EPB_MODE_RN);
 16299:     }  //efp.roundmand(EFP)
 16300:     public final EFP roundmand (EFP x, int roundingMode) {
 16301:       int xf = x.flg;
 16302:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 16303:         this.flg = xf;
 16304:         return this;
 16305:       }
 16306:       //±0,±Inf,NaN以外
 16307:       int xe = x.epp;
 16308:       long xd = x.dvl;
 16309:       long xc = x.cvl;
 16310:       long xb = 0L;
 16311:       xb = xc << -11;
 16312:       xc = xd << -11 | xc >>> 11;
 16313:       xd >>>= 11;
 16314:       if ((xc | xb) != 0L) {  //端数が0ではない
 16315:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 16316:         epbExceptionOperandExponent = x.flg & M | 0x3fff + 0x6000 + x.epp << 16;
 16317:         epbExceptionOperandMantissa = x.dvl;
 16318:         if (roundingMode == EPB_MODE_RN && xc < 0L && (xd << 63 | xc << 1 | xb) != 0L ||  //RNでguard bitが1かつLSBまたはguard bit以外の端数が0ではないまたは
 16319:             roundingMode == EPB_MODE_RM && xf < 0 ||  //端数が0ではなくてRMで-または
 16320:             roundingMode == EPB_MODE_RP && 0 <= xf) {  //端数が0ではなくてRPで+のとき
 16321:           xd++;  //繰り上げる
 16322:           if (xd >>> 53 != 0L) {  //繰り上がって溢れたとき
 16323:             xd = 1L << 52;
 16324:             xe++;  //指数部をインクリメントする
 16325:           }
 16326:         }
 16327:         //RZ toward zeroのときは端数を切り捨てるだけなので何もしなくてよい
 16328:       }  //if 端数が0ではない
 16329:       xd <<= 11;  //xcとxbはゴミが残っているので加えないこと
 16330:       //結果
 16331:       this.flg = xf;
 16332:       this.epp = xe;
 16333:       this.dvl = xd;
 16334:       this.cvl = 0L;
 16335:       return this;
 16336:     }  //efp.roundmand(EFP,int)
 16337: 
 16338:     //------------------------------------------------------------------------
 16339:     //x = x.roundmanf ()
 16340:     //x = x.roundmanf (roundingMode)
 16341:     //y = y.roundmanf (x)
 16342:     //y = y.roundmanf (x, roundingMode)
 16343:     //  仮数部float丸め
 16344:     //  仮数部を(1+23)bitに丸める
 16345:     //
 16346:     public final EFP roundmanf () {
 16347:       return this.roundmanf (this, EPB_MODE_RN);
 16348:     }  //efp.roundmanf()
 16349:     public final EFP roundmanf (int roundingMode) {
 16350:       return this.roundmanf (this, roundingMode);
 16351:     }  //efp.roundmanf(int)
 16352:     public final EFP roundmanf (EFP x) {
 16353:       return this.roundmanf (x, EPB_MODE_RN);
 16354:     }  //efp.roundmanf(EFP)
 16355:     public final EFP roundmanf (EFP x, int roundingMode) {
 16356:       int xf = x.flg;
 16357:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 16358:         this.flg = xf;
 16359:         return this;
 16360:       }
 16361:       //±0,±Inf,NaN以外
 16362:       int xe = x.epp;
 16363:       long xd = x.dvl;
 16364:       long xc = x.cvl;
 16365:       long xb = 0L;
 16366:       xb = xc << -40;
 16367:       xc = xd << -40 | xc >>> 40;
 16368:       xd >>>= 40;
 16369:       if ((xc | xb) != 0L) {  //端数が0ではない
 16370:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 16371:         epbExceptionOperandExponent = x.flg & M | 0x3fff + 0x6000 + x.epp << 16;
 16372:         epbExceptionOperandMantissa = x.dvl;
 16373:         if (roundingMode == EPB_MODE_RN && xc < 0L && (xd << 63 | xc << 1 | xb) != 0L ||  //RNでguard bitが1かつLSBまたはguard bit以外の端数が0ではないまたは
 16374:             roundingMode == EPB_MODE_RM && xf < 0 ||  //端数が0ではなくてRMで-または
 16375:             roundingMode == EPB_MODE_RP && 0 <= xf) {  //端数が0ではなくてRPで+のとき
 16376:           xd++;  //繰り上げる
 16377:           if (xd >>> 24 != 0L) {  //繰り上がって溢れたとき
 16378:             xd = 1L << 23;
 16379:             xe++;  //指数部をインクリメントする
 16380:           }
 16381:         }
 16382:         //RZ toward zeroのときは端数を切り捨てるだけなので何もしなくてよい
 16383:       }  //if 端数が0ではない
 16384:       xd <<= 40;  //xcとxbはゴミが残っているので加えないこと
 16385:       //結果
 16386:       this.flg = xf;
 16387:       this.epp = xe;
 16388:       this.dvl = xd;
 16389:       this.cvl = 0L;
 16390:       return this;
 16391:     }  //efp.roundmanf(EFP,int)
 16392: 
 16393:     //------------------------------------------------------------------------
 16394:     //x = x.roundmanx ()
 16395:     //x = x.roundmanx (roundingMode)
 16396:     //x = x.roundmanx (x)
 16397:     //x = x.roundmanx (x, roundingMode)
 16398:     //  仮数部extended丸め
 16399:     //  仮数部を(1+63)bitに丸める
 16400:     //
 16401:     public final EFP roundmanx () {
 16402:       return this.roundmanx (this, EPB_MODE_RN);
 16403:     }  //efp.roundmanx()
 16404:     public final EFP roundmanx (int roundingMode) {
 16405:       return this.roundmanx (this, roundingMode);
 16406:     }  //efp.roundmanx(int)
 16407:     public final EFP roundmanx (EFP x) {
 16408:       return this.roundmanx (x, EPB_MODE_RN);
 16409:     }  //efp.roundmanx(EFP)
 16410:     public final EFP roundmanx (EFP x, int roundingMode) {
 16411:       int xf = x.flg;
 16412:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 16413:         this.flg = xf;
 16414:         return this;
 16415:       }
 16416:       //±0,±Inf,NaN以外
 16417:       int xe = x.epp;
 16418:       long xd = x.dvl;
 16419:       long xc = x.cvl;
 16420:       long xb = 0L;
 16421:       if ((xc | xb) != 0L) {  //端数が0ではない
 16422:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 16423:         epbExceptionOperandExponent = x.flg & M | 0x3fff + 0x6000 + x.epp << 16;
 16424:         epbExceptionOperandMantissa = x.dvl;
 16425:         if (roundingMode == EPB_MODE_RN && xc < 0L && (xd << 63 | xc << 1 | xb) != 0L ||  //RNでguard bitが1かつLSBまたはguard bit以外の端数が0ではないまたは
 16426:             roundingMode == EPB_MODE_RM && xf < 0 ||  //端数が0ではなくてRMで-または
 16427:             roundingMode == EPB_MODE_RP && 0 <= xf) {  //端数が0ではなくてRPで+のとき
 16428:           xd++;  //繰り上げる
 16429:           if (xd == 0L) {  //繰り上がって溢れたとき
 16430:             xd = MSB;
 16431:             xe++;  //指数部をインクリメントする
 16432:           }
 16433:         }
 16434:         //RZ toward zeroのときは端数を切り捨てるだけなので何もしなくてよい
 16435:       }  //if 端数が0ではない
 16436:       xd <<= Long.numberOfLeadingZeros (xd);  //xcとxbはゴミが残っているので加えないこと
 16437:       //結果
 16438:       this.flg = xf;
 16439:       this.epp = xe;
 16440:       this.dvl = xd;
 16441:       this.cvl = 0L;
 16442:       return this;
 16443:     }  //efp.roundmanx(EFP,int)
 16444: 
 16445:     //------------------------------------------------------------------------
 16446:     //x = x.roundmany ()
 16447:     //x = x.roundmany (roundingMode)
 16448:     //x = x.roundmany (x)
 16449:     //x = x.roundmany (x, roundingMode)
 16450:     //  仮数部triple丸め
 16451:     //  仮数部を(1+79)bitに丸める
 16452:     //
 16453:     public final EFP roundmany () {
 16454:       return this.roundmany (this, EPB_MODE_RN);
 16455:     }  //efp.roundmany()
 16456:     public final EFP roundmany (int roundingMode) {
 16457:       return this.roundmany (this, roundingMode);
 16458:     }  //efp.roundmany(int)
 16459:     public final EFP roundmany (EFP x) {
 16460:       return this.roundmany (x, EPB_MODE_RN);
 16461:     }  //efp.roundmany(EFP)
 16462:     public final EFP roundmany (EFP x, int roundingMode) {
 16463:       int xf = x.flg;
 16464:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 16465:         this.flg = xf;
 16466:         return this;
 16467:       }
 16468:       //±0,±Inf,NaN以外
 16469:       int xe = x.epp;
 16470:       long xd = x.dvl;
 16471:       long xc = x.cvl;
 16472:       long xb = 0L;
 16473:       xb = xc << -48;
 16474:       xc = xd << -48 | xc >>> 48;
 16475:       xd >>>= 48;
 16476:       if (xb != 0L) {  //端数が0ではない
 16477:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 16478:         epbExceptionOperandExponent = x.flg & M | 0x3fff + 0x6000 + x.epp << 16;
 16479:         epbExceptionOperandMantissa = x.dvl;
 16480:         if (roundingMode == EPB_MODE_RN && xb < 0L && (xc << 63 | xb << 1) != 0L ||  //RNでguard bitが1かつLSBまたはguard bit以外の端数が0ではないまたは
 16481:             roundingMode == EPB_MODE_RM && xf < 0 ||  //端数が0ではなくてRMで-または
 16482:             roundingMode == EPB_MODE_RP && 0 <= xf) {  //端数が0ではなくてRPで+のとき
 16483:           xc++;  //繰り上げる
 16484:           if (xc == 0L) {  //繰り上がって溢れたとき
 16485:             xd++;  //繰り上げる
 16486:             if (xd >>> 16 != 0L) {  //繰り上がって溢れたとき
 16487:               xd = 1L << 15;
 16488:               xe++;  //指数部をインクリメントする
 16489:             }
 16490:           }
 16491:         }
 16492:         //RZ toward zeroのときは端数を切り捨てるだけなので何もしなくてよい
 16493:       }  //if 端数が0ではない
 16494:       xd = xd << 48 | xc >>> -48;
 16495:       xc <<= 48;  //xbはゴミが残っているので加えないこと
 16496:       //結果
 16497:       this.flg = xf;
 16498:       this.epp = xe;
 16499:       this.dvl = xd;
 16500:       this.cvl = xc;
 16501:       return this;
 16502:     }  //efp.roundmany(EFP,int)
 16503: 
 16504:     //------------------------------------------------------------------------
 16505:     //x = x.roundx ()
 16506:     //x = x.roundx (roundingMode)
 16507:     //x = x.roundx (x)
 16508:     //x = x.roundx (x, roundingMode)
 16509:     //  extended丸め
 16510:     //
 16511:     //  この関数はepbRoundingModeとepbRoundingPrecを無視する
 16512:     //  extended(指数部15bit,仮数部64bit,非正規化数を含む)で表現できる値に丸める
 16513:     //  extendedで表現できないときは±Infに変換する
 16514:     //
 16515:     public final EFP roundx () {
 16516:       return this.roundx (this, EPB_MODE_RN);
 16517:     }  //efp.roundx()
 16518:     public final EFP roundx (int roundingMode) {
 16519:       return this.roundx (this, roundingMode);
 16520:     }  //efp.roundx(int)
 16521:     public final EFP roundx2 (int roundingMode) {
 16522:       return this.roundx2 (this, roundingMode);
 16523:     }  //efp.roundx(int)
 16524:     public final EFP roundx (EFP x) {
 16525:       return this.roundx (x, EPB_MODE_RN);
 16526:     }  //efp.roundx(EFP)
 16527:     public final EFP roundx (EFP x, int roundingMode) {
 16528:       int xf = x.flg;
 16529:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 16530:         this.flg = xf;
 16531:         return this;
 16532:       }
 16533:       //±0,±Inf,NaN以外
 16534:       int xe = x.epp;  //正規化数は-16383<=xe<=16383、非正規化数は-16446<=xe<=-16384
 16535:       long xd = x.dvl;
 16536:       long xc = x.cvl;
 16537:       if (xe < -16447) {  //指数部が小さすぎる。非正規化数の最小値は2^-16446だが丸めで繰り上がる場合があるので一旦2^-16447まで受け入れる
 16538:         epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 16539:         epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 16540:         epbExceptionOperandMantissa = xd;
 16541:         return this.sete (UNFL_RESULTS[EPB_PREC_EXD << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 16542:       }
 16543:       if (16383 < xe) {  //指数部が大きすぎる
 16544:         if (true) {
 16545:           epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 16546:           if (xc != 0L) {  //端数が0ではない
 16547:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 16548:           }
 16549:         } else {
 16550:           epbFpsr |= EPB_FPSR_OF | EPB_FPSR_X2;  //オーバーフロー、不正確な結果
 16551:         }
 16552:         epbExceptionOperandExponent = xf | 0x3fff - 0x6000 + xe << 16;
 16553:         epbExceptionOperandMantissa = xd;
 16554:         return this.sete (OVFL_RESULTS[EPB_PREC_EXD << 3 | roundingMode << 1 | xf >>> 31]);  //±Inf
 16555:       }
 16556:       long xb = 0L;
 16557:       int o = xe <= -16384 ? 0 + -16383 - xe : 0;  //右にずらすbit数。正規化数は0、非正規化数は0+1<=o<=0+64
 16558:       if (o == 0) {
 16559:       } else if (o < 64) {
 16560:         xb = xc << -o;
 16561:         xc = xd << -o | xc >>> o;
 16562:         xd >>>= o;
 16563:       } else {
 16564:         xb = xc;
 16565:         xc = xd;
 16566:         xd = 0L;
 16567:       }
 16568:       if ((xc | xb) != 0L) {  //端数が0ではない
 16569:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 16570:         epbExceptionOperandExponent = x.flg & M | 0x3fff + 0x6000 + x.epp << 16;
 16571:         epbExceptionOperandMantissa = x.dvl;
 16572:         if (roundingMode == EPB_MODE_RN && xc < 0L && (xd << 63 | xc << 1 | xb) != 0L ||  //RNでguard bitが1かつLSBまたはguard bit以外の端数が0ではないまたは
 16573:             roundingMode == EPB_MODE_RM && xf < 0 ||  //端数が0ではなくてRMで-または
 16574:             roundingMode == EPB_MODE_RP && 0 <= xf) {  //端数が0ではなくてRPで+のとき
 16575:           xd++;  //繰り上げる
 16576:           if (xd == 0L) {  //繰り上がって溢れたとき
 16577:             xd = MSB;
 16578:             xe++;  //指数部をインクリメントする。ここでxe=16384になる場合がある
 16579:             if (16383 < xe) {  //指数部が大きすぎる
 16580:               epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 16581:               return this.sete (OVFL_RESULTS[EPB_PREC_EXD << 3 | roundingMode << 1 | xf >>> 31]);  //±Inf
 16582:             }
 16583:           } else if (0 < o) {  //非正規化数のとき
 16584:             if (xd << o - 1 < 0L) {  //1bit増えたとき
 16585:               xe++;  //指数部をインクリメントする
 16586: /* roundx
 16587:               if (xe == -16383) {  //非正規化数が繰り上がって正規化数になったとき
 16588:                 //xd = MSB;
 16589:                 epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 16590:                 epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 16591:                 epbExceptionOperandMantissa = xd;
 16592:               }
 16593: */
 16594:             }
 16595:           }
 16596:         }
 16597:         //RZ toward zeroのときは端数を切り捨てるだけなので何もしなくてよい
 16598:         if (xe <= -16384) {  //非正規化数
 16599:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 16600:           if (xd == 0L) {  //非正規化数でxe==-16447だったとき、先頭の1がxcにあって丸めで繰り上がらなかった
 16601:             return this.sete (UNFL_RESULTS[EPB_PREC_EXD << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 16602:           }
 16603:         }  //if 非正規化数
 16604:       } else {  //端数が0
 16605:         if (xe <= -16384) {  //非正規化数
 16606:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 16607:           epbExceptionOperandExponent = x.flg & M | 0x3fff + 0x6000 + x.epp << 16;
 16608:           epbExceptionOperandMantissa = x.dvl;
 16609:           if (xd == 0L) {  //非正規化数でxe==-16447だったとき、先頭の1がxcにあって丸めで繰り上がらなかった
 16610:             return this.sete (UNFL_RESULTS[EPB_PREC_EXD << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 16611:           }
 16612:         }  //if 非正規化数
 16613:       }  //if 端数が0ではない/端数が0
 16614:       xd <<= Long.numberOfLeadingZeros (xd);  //xcとxbはゴミが残っているので加えないこと
 16615:       //結果
 16616:       this.flg = xf;
 16617:       this.epp = xe;
 16618:       this.dvl = xd;
 16619:       this.cvl = 0L;
 16620:       return this;
 16621:     }  //efp.roundx(EFP,int)
 16622:     public final EFP roundx2 (EFP x, int roundingMode) {
 16623:       int xf = x.flg;
 16624:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 16625:         this.flg = xf;
 16626:         return this;
 16627:       }
 16628:       //±0,±Inf,NaN以外
 16629:       int xe = x.epp;  //正規化数は-16383<=xe<=16383、非正規化数は-16446<=xe<=-16384
 16630:       long xd = x.dvl;
 16631:       long xc = x.cvl;
 16632:       if (xe < -16447) {  //指数部が小さすぎる。非正規化数の最小値は2^-16446だが丸めで繰り上がる場合があるので一旦2^-16447まで受け入れる
 16633:         epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 16634:         epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 16635:         epbExceptionOperandMantissa = xd;
 16636:         return this.sete (UNFL_RESULTS[EPB_PREC_EXD << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 16637:       }
 16638:       if (16383 < xe) {  //指数部が大きすぎる
 16639:         if (true) {
 16640:           epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 16641:           if (xc != 0L) {  //端数が0ではない
 16642:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 16643:           }
 16644:         } else {
 16645:           epbFpsr |= EPB_FPSR_OF | EPB_FPSR_X2;  //オーバーフロー、不正確な結果
 16646:         }
 16647:         epbExceptionOperandExponent = xf | 0x3fff - 0x6000 + xe << 16;
 16648:         epbExceptionOperandMantissa = xd;
 16649:         return this.sete (OVFL_RESULTS[EPB_PREC_EXD << 3 | roundingMode << 1 | xf >>> 31]);  //±Inf
 16650:       }
 16651:       long xb = 0L;
 16652:       int o = xe <= -16384 ? 0 + -16383 - xe : 0;  //右にずらすbit数。正規化数は0、非正規化数は0+1<=o<=0+64
 16653:       if (o == 0) {
 16654:       } else if (o < 64) {
 16655:         xb = xc << -o;
 16656:         xc = xd << -o | xc >>> o;
 16657:         xd >>>= o;
 16658:       } else {
 16659:         xb = xc;
 16660:         xc = xd;
 16661:         xd = 0L;
 16662:       }
 16663:       if ((xc | xb) != 0L) {  //端数が0ではない
 16664:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 16665:         epbExceptionOperandExponent = x.flg & M | 0x3fff + 0x6000 + x.epp << 16;
 16666:         epbExceptionOperandMantissa = x.dvl;
 16667:         if (roundingMode == EPB_MODE_RN && xc < 0L && (xd << 63 | xc << 1 | xb) != 0L ||  //RNでguard bitが1かつLSBまたはguard bit以外の端数が0ではないまたは
 16668:             roundingMode == EPB_MODE_RM && xf < 0 ||  //端数が0ではなくてRMで-または
 16669:             roundingMode == EPB_MODE_RP && 0 <= xf) {  //端数が0ではなくてRPで+のとき
 16670:           xd++;  //繰り上げる
 16671:           if (xd == 0L) {  //繰り上がって溢れたとき
 16672:             xd = MSB;
 16673:             xe++;  //指数部をインクリメントする。ここでxe=16384になる場合がある
 16674:             if (16383 < xe) {  //指数部が大きすぎる
 16675:               epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 16676:               return this.sete (OVFL_RESULTS[EPB_PREC_EXD << 3 | roundingMode << 1 | xf >>> 31]);  //±Inf
 16677:             }
 16678:           } else if (0 < o) {  //非正規化数のとき
 16679:             if (xd << o - 1 < 0L) {  //1bit増えたとき
 16680:               xe++;  //指数部をインクリメントする
 16681: /* roundx2 */
 16682:               if (xe == -16383) {  //非正規化数が繰り上がって正規化数になったとき
 16683:                 //xd = MSB;
 16684:                 epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 16685:                 epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 16686:                 epbExceptionOperandMantissa = xd;
 16687:               }
 16688: /**/
 16689:             }
 16690:           }
 16691:         }
 16692:         //RZ toward zeroのときは端数を切り捨てるだけなので何もしなくてよい
 16693:         if (xe <= -16384) {  //非正規化数
 16694:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 16695:           if (xd == 0L) {  //非正規化数でxe==-16447だったとき、先頭の1がxcにあって丸めで繰り上がらなかった
 16696:             return this.sete (UNFL_RESULTS[EPB_PREC_EXD << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 16697:           }
 16698:         }  //if 非正規化数
 16699:       } else {  //端数が0
 16700:         if (xe <= -16384) {  //非正規化数
 16701:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 16702:           epbExceptionOperandExponent = x.flg & M | 0x3fff + 0x6000 + x.epp << 16;
 16703:           epbExceptionOperandMantissa = x.dvl;
 16704:           if (xd == 0L) {  //非正規化数でxe==-16447だったとき、先頭の1がxcにあって丸めで繰り上がらなかった
 16705:             return this.sete (UNFL_RESULTS[EPB_PREC_EXD << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 16706:           }
 16707:         }  //if 非正規化数
 16708:       }  //if 端数が0ではない/端数が0
 16709:       xd <<= Long.numberOfLeadingZeros (xd);  //xcとxbはゴミが残っているので加えないこと
 16710:       //結果
 16711:       this.flg = xf;
 16712:       this.epp = xe;
 16713:       this.dvl = xd;
 16714:       this.cvl = 0L;
 16715:       return this;
 16716:     }  //efp.roundx(EFP,int)
 16717: 
 16718:     //------------------------------------------------------------------------
 16719:     //x = x.roundy ()
 16720:     //x = x.roundy (roundingMode)
 16721:     //x = x.roundy (x)
 16722:     //x = x.roundy (x, roundingMode)
 16723:     //  triple丸め
 16724:     //
 16725:     //  この関数はepbRoundingModeとepbRoundingPrecを無視する
 16726:     //  triple(指数部15bit,仮数部80bit,非正規化数を含む)で表現できる値に丸める
 16727:     //  tripleで表現できないときは±Infに変換する
 16728:     //
 16729:     public final EFP roundy () {
 16730:       return this.roundy (this, EPB_MODE_RN);
 16731:     }  //efp.roundy()
 16732:     public final EFP roundy (int roundingMode) {
 16733:       return this.roundy (this, roundingMode);
 16734:     }  //efp.roundy(int)
 16735:     public final EFP roundy2 (int roundingMode) {
 16736:       return this.roundy2 (this, roundingMode);
 16737:     }  //efp.roundy(int)
 16738:     public final EFP roundy (EFP x) {
 16739:       return this.roundy (x, EPB_MODE_RN);
 16740:     }  //efp.roundy(EFP)
 16741:     public final EFP roundy (EFP x, int roundingMode) {
 16742:       int xf = x.flg;
 16743:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 16744:         this.flg = xf;
 16745:         return this;
 16746:       }
 16747:       //±0,±Inf,NaN以外
 16748:       int xe = x.epp;  //正規化数は-16383<=xe<=16383、非正規化数は-16462<=xe<=-16384
 16749:       long xd = x.dvl;
 16750:       long xc = x.cvl;
 16751:       if (xe < -16463) {  //指数部が小さすぎる。非正規化数の最小値は2^-16462だが丸めで繰り上がる場合があるので一旦2^-16463まで受け入れる
 16752:         epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 16753:         epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 16754:         epbExceptionOperandMantissa = xd;
 16755:         return this.sete (UNFL_RESULTS[EPB_PREC_TPL << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 16756:       }
 16757:       if (16383 < xe) {  //指数部が大きすぎる
 16758:         if (true) {
 16759:           epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 16760:           if (xc << 16 != 0L) {  //端数が0ではない
 16761:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 16762:           }
 16763:         } else {
 16764:           epbFpsr |= EPB_FPSR_OF | EPB_FPSR_X2;  //オーバーフロー、不正確な結果
 16765:         }
 16766:         epbExceptionOperandExponent = xf | 0x3fff - 0x6000 + xe << 16;
 16767:         epbExceptionOperandMantissa = xd;
 16768:         return this.sete (OVFL_RESULTS[EPB_PREC_TPL << 3 | roundingMode << 1 | xf >>> 31]);  //±Inf
 16769:       }
 16770:       long xb = 0L;
 16771:       long xa = 0L;
 16772:       int o = xe <= -16384 ? 48 + -16383 - xe : 48;  //右にずらすbit数。正規化数は48、非正規化数は48+1<=o<=48+80
 16773:       if (o < 64) {
 16774:         xb = xc << -o;
 16775:         xc = xd << -o | xc >>> o;
 16776:         xd >>>= o;
 16777:       } else if (o == 64) {
 16778:         xb = xc;
 16779:         xc = xd;
 16780:         xd = 0L;
 16781:       } else if (o < 128) {
 16782:         xa = xc << -o;
 16783:         xb = xd << -o | xc >>> o;
 16784:         xc = xd >>> o;
 16785:         xd = 0L;
 16786:       } else {
 16787:         xa = xc;
 16788:         xb = xd;
 16789:         xc = 0L;
 16790:         xd = 0L;
 16791:       }
 16792:       if ((xb | xa) != 0L) {  //端数が0ではない
 16793:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 16794:         epbExceptionOperandExponent = x.flg & M | 0x3fff + 0x6000 + x.epp << 16;
 16795:         epbExceptionOperandMantissa = x.dvl;
 16796:         if (roundingMode == EPB_MODE_RN && xb < 0L && (xc << 63 | xb << 1 | xa) != 0L ||  //RNでguard bitが1かつLSBまたはguard bit以外の端数が0ではないまたは
 16797:             roundingMode == EPB_MODE_RM && xf < 0 ||  //端数が0ではなくてRMで-または
 16798:             roundingMode == EPB_MODE_RP && 0 <= xf) {  //端数が0ではなくてRPで+のとき
 16799:           xc++;  //繰り上げる
 16800:           if (xc == 0L) {  //繰り上がって溢れたとき
 16801:             xd++;  //繰り上げる
 16802:             if (xd >>> 16 != 0L) {  //繰り上がって溢れたとき
 16803:               //xd = 1L << 15;
 16804:               xe++;  //指数部をインクリメントする。ここでxe=16384になる場合がある
 16805:               if (16383 < xe) {  //指数部が大きすぎる
 16806:                 epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 16807:                 return this.sete (OVFL_RESULTS[EPB_PREC_TPL << 3 | roundingMode << 1 | xf >>> 31]);  //±Inf
 16808:               }  //if 指数部が大きすぎる
 16809:             } else if (48 < o) {  //非正規化数のとき
 16810:               if (xd << o - 1 < 0L) {  //1bit増えたとき
 16811:                 xe++;  //指数部をインクリメントする
 16812: /* roundy
 16813:                 if (xe == -16383) {  //非正規化数が繰り上がって正規化数になったとき
 16814:                   //xd = 1L << 15;
 16815:                   epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 16816:                   epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 16817:                   epbExceptionOperandMantissa = xd;
 16818:                 }
 16819: */
 16820:               }
 16821:             }
 16822:           }
 16823:         }
 16824:         //RZ toward zeroのときは端数を切り捨てるだけなので何もしなくてよい
 16825:         if (xe <= -16384) {  //非正規化数
 16826:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 16827:           if ((xd | xc) == 0L) {  //非正規化数でxe==-16463だったとき、先頭の1がxbにあって丸めで繰り上がらなかった
 16828:             return this.sete (UNFL_RESULTS[EPB_PREC_TPL << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 16829:           }
 16830:         }  //if 非正規化数
 16831:       } else {  //端数が0
 16832:         if (xe <= -16384) {  //非正規化数
 16833:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 16834:           epbExceptionOperandExponent = x.flg & M | 0x3fff + 0x6000 + x.epp << 16;
 16835:           epbExceptionOperandMantissa = x.dvl;
 16836:           if ((xd | xc) == 0L) {  //非正規化数でxe==-16463だったとき、先頭の1がxbにあって丸めで繰り上がらなかった
 16837:             return this.sete (UNFL_RESULTS[EPB_PREC_TPL << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 16838:           }
 16839:         }  //if 非正規化数
 16840:       }  //if 端数が0ではない/端数が0
 16841:       if (xd != 0L) {
 16842:         o = Long.numberOfLeadingZeros (xd);
 16843:         xd = xd << o | xc >>> -o;
 16844:         xc <<= o;  //xbとxaはゴミが残っているので加えないこと
 16845:       } else {
 16846:         xd = xc << Long.numberOfLeadingZeros (xc);  //xbとxaはゴミが残っているので加えないこと
 16847:         xc = 0L;
 16848:       }
 16849:       //結果
 16850:       this.flg = xf;
 16851:       this.epp = xe;
 16852:       this.dvl = xd;
 16853:       this.cvl = xc;
 16854:       return this;
 16855:     }  //efp.roundy(EFP,int)
 16856:     public final EFP roundy2 (EFP x, int roundingMode) {
 16857:       int xf = x.flg;
 16858:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 16859:         this.flg = xf;
 16860:         return this;
 16861:       }
 16862:       //±0,±Inf,NaN以外
 16863:       int xe = x.epp;  //正規化数は-16383<=xe<=16383、非正規化数は-16462<=xe<=-16384
 16864:       long xd = x.dvl;
 16865:       long xc = x.cvl;
 16866:       if (xe < -16463) {  //指数部が小さすぎる。非正規化数の最小値は2^-16462だが丸めで繰り上がる場合があるので一旦2^-16463まで受け入れる
 16867:         epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 16868:         epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 16869:         epbExceptionOperandMantissa = xd;
 16870:         return this.sete (UNFL_RESULTS[EPB_PREC_TPL << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 16871:       }
 16872:       if (16383 < xe) {  //指数部が大きすぎる
 16873:         if (true) {
 16874:           epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 16875:           if (xc << 16 != 0L) {  //端数が0ではない
 16876:             epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 16877:           }
 16878:         } else {
 16879:           epbFpsr |= EPB_FPSR_OF | EPB_FPSR_X2;  //オーバーフロー、不正確な結果
 16880:         }
 16881:         epbExceptionOperandExponent = xf | 0x3fff - 0x6000 + xe << 16;
 16882:         epbExceptionOperandMantissa = xd;
 16883:         return this.sete (OVFL_RESULTS[EPB_PREC_TPL << 3 | roundingMode << 1 | xf >>> 31]);  //±Inf
 16884:       }
 16885:       long xb = 0L;
 16886:       long xa = 0L;
 16887:       int o = xe <= -16384 ? 48 + -16383 - xe : 48;  //右にずらすbit数。正規化数は48、非正規化数は48+1<=o<=48+80
 16888:       if (o < 64) {
 16889:         xb = xc << -o;
 16890:         xc = xd << -o | xc >>> o;
 16891:         xd >>>= o;
 16892:       } else if (o == 64) {
 16893:         xb = xc;
 16894:         xc = xd;
 16895:         xd = 0L;
 16896:       } else if (o < 128) {
 16897:         xa = xc << -o;
 16898:         xb = xd << -o | xc >>> o;
 16899:         xc = xd >>> o;
 16900:         xd = 0L;
 16901:       } else {
 16902:         xa = xc;
 16903:         xb = xd;
 16904:         xc = 0L;
 16905:         xd = 0L;
 16906:       }
 16907:       if ((xb | xa) != 0L) {  //端数が0ではない
 16908:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 16909:         epbExceptionOperandExponent = x.flg & M | 0x3fff + 0x6000 + x.epp << 16;
 16910:         epbExceptionOperandMantissa = x.dvl;
 16911:         if (roundingMode == EPB_MODE_RN && xb < 0L && (xc << 63 | xb << 1 | xa) != 0L ||  //RNでguard bitが1かつLSBまたはguard bit以外の端数が0ではないまたは
 16912:             roundingMode == EPB_MODE_RM && xf < 0 ||  //端数が0ではなくてRMで-または
 16913:             roundingMode == EPB_MODE_RP && 0 <= xf) {  //端数が0ではなくてRPで+のとき
 16914:           xc++;  //繰り上げる
 16915:           if (xc == 0L) {  //繰り上がって溢れたとき
 16916:             xd++;  //繰り上げる
 16917:             if (xd >>> 16 != 0L) {  //繰り上がって溢れたとき
 16918:               //xd = 1L << 15;
 16919:               xe++;  //指数部をインクリメントする。ここでxe=16384になる場合がある
 16920:               if (16383 < xe) {  //指数部が大きすぎる
 16921:                 epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 16922:                 return this.sete (OVFL_RESULTS[EPB_PREC_TPL << 3 | roundingMode << 1 | xf >>> 31]);  //±Inf
 16923:               }  //if 指数部が大きすぎる
 16924:             } else if (48 < o) {  //非正規化数のとき
 16925:               if (xd << o - 1 < 0L) {  //1bit増えたとき
 16926:                 xe++;  //指数部をインクリメントする
 16927: /* roundy2 */
 16928:                 if (xe == -16383) {  //非正規化数が繰り上がって正規化数になったとき
 16929:                   //xd = 1L << 15;
 16930:                   epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 16931:                   epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + xe << 16;
 16932:                   epbExceptionOperandMantissa = xd;
 16933:                 }
 16934: /**/
 16935:               }
 16936:             }
 16937:           }
 16938:         }
 16939:         //RZ toward zeroのときは端数を切り捨てるだけなので何もしなくてよい
 16940:         if (xe <= -16384) {  //非正規化数
 16941:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 16942:           if ((xd | xc) == 0L) {  //非正規化数でxe==-16463だったとき、先頭の1がxbにあって丸めで繰り上がらなかった
 16943:             return this.sete (UNFL_RESULTS[EPB_PREC_TPL << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 16944:           }
 16945:         }  //if 非正規化数
 16946:       } else {  //端数が0
 16947:         if (xe <= -16384) {  //非正規化数
 16948:           epbFpsr |= EPB_FPSR_UF;  //アンダーフロー
 16949:           epbExceptionOperandExponent = x.flg & M | 0x3fff + 0x6000 + x.epp << 16;
 16950:           epbExceptionOperandMantissa = x.dvl;
 16951:           if ((xd | xc) == 0L) {  //非正規化数でxe==-16463だったとき、先頭の1がxbにあって丸めで繰り上がらなかった
 16952:             return this.sete (UNFL_RESULTS[EPB_PREC_TPL << 3 | roundingMode << 1 | xf >>> 31]);  //±0
 16953:           }
 16954:         }  //if 非正規化数
 16955:       }  //if 端数が0ではない/端数が0
 16956:       if (xd != 0L) {
 16957:         o = Long.numberOfLeadingZeros (xd);
 16958:         xd = xd << o | xc >>> -o;
 16959:         xc <<= o;  //xbとxaはゴミが残っているので加えないこと
 16960:       } else {
 16961:         xd = xc << Long.numberOfLeadingZeros (xc);  //xbとxaはゴミが残っているので加えないこと
 16962:         xc = 0L;
 16963:       }
 16964:       //結果
 16965:       this.flg = xf;
 16966:       this.epp = xe;
 16967:       this.dvl = xd;
 16968:       this.cvl = xc;
 16969:       return this;
 16970:     }  //efp.roundy(EFP,int)
 16971: 
 16972:     //------------------------------------------------------------------------
 16973:     //x = x.scale (y)
 16974:     //  x*=2^trunc(y)
 16975:     //z = z.scale (x, y)
 16976:     //  z=x*2^trunc(y)
 16977:     //  2^trunc(y)倍
 16978:     //
 16979:     public final EFP scale (EFP y) {
 16980:       return this.scale (this, y);
 16981:     }  //efp.scale(EFP)
 16982:     public final EFP scale (EFP x, EFP y) {
 16983:       int xf = x.flg;
 16984:       int yf = y.flg;
 16985:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
 16986:         if ((xf | yf) << 3 < 0) {  //どちらかがNaN
 16987:           this.flg = N;
 16988:         } else if (yf << 1 < 0) {  //scale(±0,±0)=±0, scale(±Inf,±0)=±Inf, scale(±x,±0)=±x
 16989:           this.finish (x.flg, x.epp, x.dvl, x.cvl, 0L);
 16990:         } else if (yf << 2 < 0) {  //scale(±0,±Inf)=NaN,OE, scale(±Inf,±Inf)=NaN,OE, scale(±x,±Inf)=NaN,OE
 16991:           epbFpsr |= EPB_FPSR_OE;
 16992:           epbExceptionOperandExponent = yf & M | 0x7fff << 16;
 16993:           epbExceptionOperandMantissa = 0x0000000000000000L;
 16994:           this.flg = N;
 16995:         } else if (xf << 1 < 0) {  //scale(±0,±y)=±0
 16996:           this.flg = xf;
 16997:         } else if (xf << 2 < 0) {  //scale(±Inf,±y)=±Inf
 16998:           this.flg = xf;
 16999:         }
 17000:         return this;
 17001:       }
 17002:       //両方±0,±Inf,NaN以外
 17003:       //  スケールをround-to-zeroで整数にする
 17004:       //  geti()は飽和変換だが飽和させるとオペランドエラーがセットされてしまうので先に範囲を確認する
 17005:       int i = (16 <= y.epp ? yf < 0 ? -1 << 16 : 1 << 16 :   //スケールの絶対値が2^16以上
 17006:                y.geti ());
 17007:       if (i <= -1 << 14) {  //スケールが-2^14以下のとき常にアンダーフロー。MC68882に合わせる
 17008:         epbFpsr |= EPB_FPSR_UF | EPB_FPSR_X2;  //アンダーフロー、不正確な結果
 17009:         if (i <= -1 << 16) {  //スケールが-2^16以下
 17010:           epbExceptionOperandExponent = xf;
 17011:           epbExceptionOperandMantissa = x.dvl;
 17012:         } else {
 17013:           epbExceptionOperandExponent = xf | 0x3fff + 0x6000 + i << 16;
 17014:           epbExceptionOperandMantissa = x.dvl;
 17015:         }
 17016:         return this.sete (UNFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | xf >>> 31]).finish ();  //±0
 17017:       }
 17018:       if (1 << 14 <= i) {  //スケールが2^14以上のとき常にオーバーフロー。MC68882に合わせる
 17019:         epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 17020:         if (1 << 16 <= i) {  //スケールが2^16以上
 17021:           epbExceptionOperandExponent = xf;
 17022:           epbExceptionOperandMantissa = x.dvl;
 17023:         } else {
 17024:           epbExceptionOperandExponent = xf | 0x3fff - 0x6000 + i << 16;
 17025:           epbExceptionOperandMantissa = x.dvl;
 17026:         }
 17027:         return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | xf >>> 31]).finish ();  //±Inf
 17028:       }
 17029:       return this.finish2 (xf, x.epp + i, x.dvl, x.cvl, 0L);  //スケールを加える
 17030:     }  //efp.scale(EFP,EFP)
 17031: 
 17032:     //------------------------------------------------------------------------
 17033:     //x = x.sec ()
 17034:     //  x=sec(x)
 17035:     //y = y.sec (x)
 17036:     //  y=sec(x)
 17037:     //  正割 secant セカント
 17038:     //
 17039:     //  グラフ
 17040:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{sec($_[0])});print$g"
 17041:     //    echo read("../misc/efp.gp");eval("sec(x)=1/cos(x)");graph(sec) | gp -q
 17042:     //    +---------+---------+------*--+---------+---------+--*------+---------+---------+
 17043:     //    |                          *            |            *                          |
 17044:     //    |                          *            |            *                          |
 17045:     //    |                          *            |            *                          |
 17046:     //    |                          **           |           **                          |
 17047:     //    +                           *           +           *                           +
 17048:     //    |                           *           |           *                           |
 17049:     //    |                           *           |           *                           |
 17050:     //    |                           **          |          **                           |
 17051:     //    |                            *          |          *                            |
 17052:     //    +                            **         +         **                            +
 17053:     //    |                             **        |        **                             |
 17054:     //    |                              **       |       **                              |
 17055:     //    |                               **      |      **                               |
 17056:     //    |                                ****   |   ****                                |
 17057:     //    +                                   *********                                   +
 17058:     //    |                                       |                                       |
 17059:     //    |                                       |                                       |
 17060:     //    |                                       |                                       |
 17061:     //    |                                       |                                       |
 17062:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 17063:     //    |                                       |                                       |
 17064:     //    |                                       |                                       |
 17065:     //    |                                       |                                       |
 17066:     //    |                                       |                                       |
 17067:     //    +   **********                          +                          **********   +
 17068:     //    | ***        ****                       |                       ****        *** |
 17069:     //    ***             **                      |                      **             ***
 17070:     //    *                **                     |                     **                *
 17071:     //    |                 **                    |                    **                 |
 17072:     //    +                  *                    +                    *                  +
 17073:     //    |                  **                   |                   **                  |
 17074:     //    |                   *                   |                   *                   |
 17075:     //    |                   *                   |                   *                   |
 17076:     //    |                   **                  |                  **                   |
 17077:     //    +                    *                  +                  *                    +
 17078:     //    |                    *                  |                  *                    |
 17079:     //    |                    *                  |                  *                    |
 17080:     //    |                    **                 |                 **                    |
 17081:     //    |                     *                 |                 *                     |
 17082:     //    +---------+---------+-*-------+---------+---------+-------*-+---------+---------+
 17083:     //
 17084:     //  三角関数との関係
 17085:     //    sec(x)=1/cos(x)
 17086:     //
 17087:     public final EFP sec () {
 17088:       return this.sec (this);
 17089:     }  //efp.sec()
 17090:     public final EFP sec (EFP x) {
 17091:       return this.inner ().cos (x).outer ().rcp ();  //1/cos(x)
 17092:     }  //efp.sec(EFP)
 17093: 
 17094:     //------------------------------------------------------------------------
 17095:     //x = x.sech ()
 17096:     //  x=sech(x)
 17097:     //y = y.sech (x)
 17098:     //  y=sech(x)
 17099:     //  双曲線正割 hyperbolic secant ハイパボリックセカント
 17100:     //
 17101:     //  グラフ
 17102:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{sech($_[0])});print$g"
 17103:     //    echo read("../misc/efp.gp");eval("sech(x)=1/cosh(x)");graph(sech) | gp -q
 17104:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 17105:     //    |                                       |                                       |
 17106:     //    |                                       |                                       |
 17107:     //    |                                       |                                       |
 17108:     //    |                                       |                                       |
 17109:     //    +                                       +                                       +
 17110:     //    |                                       |                                       |
 17111:     //    |                                       |                                       |
 17112:     //    |                                       |                                       |
 17113:     //    |                                       |                                       |
 17114:     //    +                                       +                                       +
 17115:     //    |                                       |                                       |
 17116:     //    |                                       |                                       |
 17117:     //    |                                       |                                       |
 17118:     //    |                                       |                                       |
 17119:     //    +                                  ***********                                  +
 17120:     //    |                              *****    |    *****                              |
 17121:     //    |                          *****        |        *****                          |
 17122:     //    |                    *******            |            *******                    |
 17123:     //    |         ************                  |                  ************         |
 17124:     //    ***********---------+---------+---------+---------+---------+---------***********
 17125:     //    |                                       |                                       |
 17126:     //    |                                       |                                       |
 17127:     //    |                                       |                                       |
 17128:     //    |                                       |                                       |
 17129:     //    +                                       +                                       +
 17130:     //    |                                       |                                       |
 17131:     //    |                                       |                                       |
 17132:     //    |                                       |                                       |
 17133:     //    |                                       |                                       |
 17134:     //    +                                       +                                       +
 17135:     //    |                                       |                                       |
 17136:     //    |                                       |                                       |
 17137:     //    |                                       |                                       |
 17138:     //    |                                       |                                       |
 17139:     //    +                                       +                                       +
 17140:     //    |                                       |                                       |
 17141:     //    |                                       |                                       |
 17142:     //    |                                       |                                       |
 17143:     //    |                                       |                                       |
 17144:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 17145:     //
 17146:     //  双曲線関数との関係
 17147:     //    sech(x)=1/cosh(x)
 17148:     //
 17149:     //  指数関数との関係
 17150:     //    sech(x)=2/(e^x+e^-x)
 17151:     //           =2*e^x/((e^x)^2+1)
 17152:     //
 17153:     public final EFP sech () {
 17154:       return this.sech (this);
 17155:     }  //efp.sech()
 17156:     public final EFP sech (EFP x) {
 17157:       return this.inner ().cosh (x).outer ().rcp ();  //1/cosh(x)
 17158:     }  //efp.sech(EFP)
 17159: 
 17160:     //------------------------------------------------------------------------
 17161:     //y = y.set0 ()
 17162:     //  +0代入
 17163:     //
 17164:     public final EFP set0 () {
 17165:       this.flg = P | Z;
 17166:       //this.epp = 0;
 17167:       //this.dvl = 0L;
 17168:       //this.cvl = 0L;
 17169:       return this;
 17170:     }  //efp.set0()
 17171: 
 17172:     //------------------------------------------------------------------------
 17173:     //y = y.set1 ()
 17174:     //  +1代入
 17175:     //
 17176:     public final EFP set1 () {
 17177:       this.flg = P;
 17178:       this.epp = 0;
 17179:       this.dvl = MSB;
 17180:       this.cvl = 0L;
 17181:       return this;
 17182:     }  //efp.set1()
 17183: 
 17184:     //------------------------------------------------------------------------
 17185:     //y = y.setapery ()
 17186:     //  y=ζ(3)
 17187:     //  アペリーの定数 Apéry's constant
 17188:     //
 17189:     //  式
 17190:     //    ζ(3)=sum[n=1..∞]{1/n^3}
 17191:     //
 17192:     //  値
 17193:     //    echo read("../misc/efp.gp");printf("%.100g\n",zeta(3)) | gp -q
 17194:     //    1.202056903159594285399738161511449990764986292340498881792271555341838205786313090186455873609335258
 17195:     //
 17196:     //  参考
 17197:     //    https://ja.wikipedia.org/wiki/%E3%82%A2%E3%83%9A%E3%83%AA%E3%83%BC%E3%81%AE%E5%AE%9A%E6%95%B0
 17198:     //    https://ja.wikipedia.org/wiki/%E3%82%A2%E3%83%9A%E3%83%AA%E3%83%BC%E3%81%AE%E5%AE%9A%E7%90%86
 17199:     //    https://en.wikipedia.org/wiki/Ap%C3%A9ry%27s_constant
 17200:     //    http://society.math.ntu.edu.tw/~journal/tjm/V4N4/tjm0012_3.pdf
 17201:     //    http://www.numberworld.org/digits/Zeta(3)/
 17202:     //
 17203:     public final EFP setapery () {
 17204:       epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 17205:       return this.sete (ROUNDED_APERY[epbRoundingMode]).finish ();
 17206:     }  //efp.setapery()
 17207: 
 17208:     //------------------------------------------------------------------------
 17209:     //y = y.setcatalan ()
 17210:     //  y=G
 17211:     //  カタランの定数 Catalan's_constant
 17212:     //
 17213:     //  式
 17214:     //    G=beta(2)
 17215:     //     =sum[n=0..∞]{(-1)^n/(2*n+1)^2}
 17216:     //     =1/1^2-1/3^2+1/5^2-1/7^2+1/9^2-1/11^2+1/13^2-1/15^2+1/17^2-1/19^2+...
 17217:     //
 17218:     //  値
 17219:     //    echo read("../misc/efp.gp");printf("%.100g\n",Catalan) | gp -q
 17220:     //    0.9159655941772190150546035149323841107741493742816721342664981196217630197762547694793565129261151062
 17221:     //
 17222:     //  参考
 17223:     //    https://en.wikipedia.org/wiki/Catalan%27s_constant
 17224:     //    http://www.numberworld.org/digits/Catalan/
 17225:     //
 17226:     public final EFP setcatalan () {
 17227:       epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 17228:       return this.sete (ROUNDED_CATALAN[epbRoundingMode]).finish ();
 17229:     }  //efp.setcatalan()
 17230: 
 17231:     //------------------------------------------------------------------------
 17232:     //y = y.setd (d)
 17233:     //y = y.setd01 (b, a)
 17234:     //y = y.setd01 (ib, ia)
 17235:     //y = y.setd01 (l)
 17236:     //  double代入
 17237:     //  丸め処理を行わない
 17238:     //
 17239:     public final EFP setd (double d) {
 17240:       return setd01 (Double.doubleToLongBits (d));
 17241:     }  //efp.setd(double)
 17242:     public final EFP setd01 (byte[] b, int a) {
 17243:       return setd01 ((long) b[a] << 56 |
 17244:                      (long) (0xff & b[a + 1]) << 48 |
 17245:                      (long) (0xff & b[a + 2]) << 40 |
 17246:                      (long) (0xff & b[a + 3]) << 32 |
 17247:                      (long) (0xff & b[a + 4]) << 24 |
 17248:                      (long) (0xff & b[a + 5]) << 16 |
 17249:                      (long) (0xff & b[a + 6]) << 8 |
 17250:                      (long) (0xff & b[a + 7]));
 17251:     }  //efp.setd01(byte[],int)
 17252:     public final EFP setd01 (int[] ib, int ia) {
 17253:       return setd01 ((long) ib[ia] << 32 |
 17254:                      (0xffffffffL & ib[ia + 1]));
 17255:     }  //efp.setd012(int[],int)
 17256:     public final EFP setd01 (long l) {
 17257:       int zf = (int) (l >>> 32) & M;  //符号
 17258:       int ze = ((int) (l >>> 52) & 0x7ff) - 1023;  //指数部
 17259:       long zd = 0L;
 17260:       l &= -1L >>> 12;  //仮数部の小数部。doubleは正規化されているとき整数部が省略されているので後で先頭に1を付け足す必要がある
 17261:       if (ze == 1024) {  //±Inf,NaN
 17262:         if (l == 0L) {  //±Inf
 17263:           zf |= I;
 17264:         } else {  //NaN
 17265:           if (l << 12 >= 0L) {  //SNaN
 17266:             epbFpsr |= EPB_FPSR_SN;  //シグナリングNaN
 17267:             epbExceptionOperandExponent = 0x7fff << 16;
 17268:             epbExceptionOperandMantissa = 0xbfffffffffffffffL;
 17269:           }
 17270:           zf = N;
 17271:         }
 17272:       } else if (ze >= -1022) {  //正規化数
 17273:         zd = MSB | l << 11;  //整数部の1を付け足す
 17274:       } else if (l == 0L) {  //±0
 17275:         zf |= Z;
 17276:       } else {  //非正規化数
 17277:         int o = Long.numberOfLeadingZeros (l);
 17278:         ze -= o - 12;
 17279:         zd = l << o;  //非正規化数は整数部が存在しない
 17280:       }
 17281:       this.flg = zf;
 17282:       this.epp = ze;
 17283:       this.dvl = zd;
 17284:       this.cvl = 0L;
 17285:       //非正規化数でもアンダーフロー(UF)をセットしない
 17286:       //丸めない
 17287:       return this;
 17288:     }  //efp.setd01(long)
 17289: 
 17290:     //------------------------------------------------------------------------
 17291:     //y = y.sete (x)
 17292:     //  y=x
 17293:     //  EFP代入
 17294:     //  コピーするだけ
 17295:     //  丸め処理を行わない
 17296:     //
 17297:     public final EFP sete (EFP x) {
 17298:       this.flg = x.flg;
 17299:       this.epp = x.epp;
 17300:       this.dvl = x.dvl;
 17301:       this.cvl = x.cvl;
 17302:       return this;
 17303:     }  //efp.sete(EFP)
 17304: 
 17305:     //------------------------------------------------------------------------
 17306:     //y = y.seteuler ()
 17307:     //  y=γ
 17308:     //  オイラー・マスケローニ定数 Euler-Mascheroni constant
 17309:     //
 17310:     //  式
 17311:     //    γ=lim[n→∞]{sum[k=1..∞]{1/k}-log(n)}
 17312:     //
 17313:     //  値
 17314:     //    echo read("../misc/efp.gp");printf("%.100g\n",Euler) | gp -q
 17315:     //    0.5772156649015328606065120900824024310421593359399235988057672348848677267776646709369470632917467495
 17316:     //
 17317:     //  参考
 17318:     //    https://ja.wikipedia.org/wiki/%E3%82%AA%E3%82%A4%E3%83%A9%E3%83%BC%E3%81%AE%E5%AE%9A%E6%95%B0
 17319:     //    https://en.wikipedia.org/wiki/Euler%E2%80%93Mascheroni_constant
 17320:     //    http://www.numberworld.org/digits/EulerGamma/
 17321:     //
 17322:     public final EFP seteuler () {
 17323:       epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 17324:       return this.sete (ROUNDED_EULER[epbRoundingMode]).finish ();
 17325:     }  //efp.seteuler()
 17326: 
 17327:     //------------------------------------------------------------------------
 17328:     //y = y.setf (f)
 17329:     //y = y.setf0 (b, a)
 17330:     //y = y.setf0 (ib, ia)
 17331:     //y = y.setf0 (i)
 17332:     //  float代入
 17333:     //  丸め処理を行わない
 17334:     //
 17335:     public final EFP setf (float f) {
 17336:       return setf0 (Float.floatToIntBits (f));
 17337:     }  //efp.setf(float)
 17338:     public final EFP setf0 (byte[] b, int a) {
 17339:       return setf0 (b[a] << 24 |
 17340:                     (0xff & b[a + 1]) << 16 |
 17341:                     (0xff & b[a + 2]) << 8 |
 17342:                     (0xff & b[a + 3]));
 17343:     }  //efp.setf0(byte[],int)
 17344:     public final EFP setf0 (int[] ib, int ia) {
 17345:       return setf0 (ib[ia]);
 17346:     }  //efp.setf0(int[],int)
 17347:     public final EFP setf0 (int i) {
 17348:       int zf = i & M;  //符号
 17349:       int ze = (i >>> 23 & 0xff) - 127;  //指数部
 17350:       long zd = 0L;
 17351:       i &= -1 >>> 9;  //仮数部の小数部。floatは正規化されているとき整数部が省略されているので後で先頭に1を付け足す必要がある
 17352:       if (ze == 128) {  //±Inf,NaN
 17353:         if (i == 0) {  //±Inf
 17354:           zf |= I;
 17355:         } else {  //NaN
 17356:           if (i << 9 >= 0) {  //SNaN
 17357:             epbFpsr |= EPB_FPSR_SN;  //シグナリングNaN
 17358:             epbExceptionOperandExponent = 0x7fff << 16;
 17359:             epbExceptionOperandMantissa = 0xbfffffffffffffffL;
 17360:           }
 17361:           zf = N;
 17362:         }
 17363:       } else if (ze >= -126) {  //正規化数
 17364:         zd = (long) (1 << 23 | i) << 32 + 8;  //整数部の1を付け足す
 17365:       } else if (i == 0) {  //±0
 17366:         zf |= Z;
 17367:       } else {  //非正規化数
 17368:         int o = Integer.numberOfLeadingZeros (i);
 17369:         ze -= o - 9;
 17370:         zd = (long) i << 32 + o;  //非正規化数は整数部が存在しない
 17371:       }
 17372:       this.flg = zf;
 17373:       this.epp = ze;
 17374:       this.dvl = zd;
 17375:       this.cvl = 0L;
 17376:       //非正規化数でもアンダーフロー(UF)をセットしない
 17377:       //丸めない
 17378:       return this;
 17379:     }  //efp.setf0(float)
 17380: 
 17381:     //------------------------------------------------------------------------
 17382:     //y = y.seti (i)
 17383:     //  int代入
 17384:     //
 17385:     public final EFP seti (int i) {
 17386:       if (i == 0) {
 17387:         this.flg = P | Z;  //+0
 17388:         return this;
 17389:       }
 17390:       int zf = P;
 17391:       if (i < 0) {  //x<0
 17392:         zf = M;
 17393:         i = -i;
 17394:       }
 17395:       int ze = 31 - Integer.numberOfLeadingZeros (i);
 17396:       long zd = (long) i << 63 - ze;  //0x80000000のとき1拡張になるが余分な1は押し出されるのでマスクは不要
 17397:       return this.finish (zf, ze, zd, 0L, 0L);
 17398:     }  //efp.seti(int)
 17399: 
 17400:     //------------------------------------------------------------------------
 17401:     //y = y.setinf ()
 17402:     //  +Inf代入
 17403:     //
 17404:     public final EFP setinf () {
 17405:       this.flg = P | I;
 17406:       //this.epp = 0;
 17407:       //this.dvl = 0L;
 17408:       //this.cvl = 0L;
 17409:       return this;
 17410:     }  //efp.setinf()
 17411: 
 17412:     //------------------------------------------------------------------------
 17413:     //y = y.setl (l)
 17414:     //  long代入
 17415:     //
 17416:     public final EFP setl (long l) {
 17417:       if (l == 0L) {
 17418:         this.flg = P | Z;  //+0
 17419:         return this;
 17420:       }
 17421:       int zf = P;
 17422:       if (l < 0L) {  //x<0
 17423:         zf = M;
 17424:         l = -l;
 17425:       }
 17426:       int ze = 63 - Long.numberOfLeadingZeros (l);
 17427:       long zd = l << ~ze;
 17428:       return this.finish (zf, ze, zd, 0L, 0L);
 17429:     }  //efp.setl(long)
 17430: 
 17431:     //------------------------------------------------------------------------
 17432:     //y = y.setmax ()
 17433:     //  最大値代入
 17434:     //
 17435:     //  +Infの次に大きい表現可能な値
 17436:     //
 17437:     public final EFP setmax () {
 17438:       return this.finish (P, 32767, 0xffffffffffffffffL, 0xffffffffffffffffL << 128 - LEN, 0L);
 17439:     }  //efp.setmax()
 17440: 
 17441:     //------------------------------------------------------------------------
 17442:     //y = y.setmin ()
 17443:     //  最小値代入
 17444:     //
 17445:     //  -Infの次に小さい表現可能な値
 17446:     //
 17447:     public final EFP setmin () {
 17448:       return this.finish (M, -32767, MSB, 0L, 0L);
 17449:     }  //efp.setmin()
 17450: 
 17451:     //------------------------------------------------------------------------
 17452:     //y = y.setnan ()
 17453:     //  NaN代入
 17454:     //
 17455:     public final EFP setnan () {
 17456:       this.flg = N;
 17457:       //this.epp = 0;
 17458:       //this.dvl = 0L;
 17459:       //this.cvl = 0L;
 17460:       return this;
 17461:     }  //efp.setnan()
 17462: 
 17463:     //------------------------------------------------------------------------
 17464:     //y = y.setnapier ()
 17465:     //  y=e
 17466:     //  ネイピア数 Napier's constant
 17467:     //
 17468:     //  式
 17469:     //    e=sum[n=0..∞]{1/n!}
 17470:     //
 17471:     //  値
 17472:     //    echo read("../misc/efp.gp");printf("%.100g\n",exp(1)) | gp -q
 17473:     //    2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427
 17474:     //
 17475:     //  参考
 17476:     //    https://ja.wikipedia.org/wiki/%E3%83%8D%E3%82%A4%E3%83%94%E3%82%A2%E6%95%B0
 17477:     //    https://en.wikipedia.org/wiki/E_(mathematical_constant)
 17478:     //    http://www.numberworld.org/digits/E/
 17479:     //
 17480:     public final EFP setnapier () {
 17481:       epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 17482:       return this.sete (ROUNDED_NAPIER[epbRoundingMode]).finish ();
 17483:     }  //efp.setnapier()
 17484: 
 17485:     //------------------------------------------------------------------------
 17486:     //y = y.setp012 (b, a)
 17487:     //y = y.setp012 (ib, ia)
 17488:     //y = y.setp012 (i, l)
 17489:     //  packed代入
 17490:     //
 17491:     public final EFP setp012 (byte[] b, int a) {
 17492:       return setp012 (b[a] << 24 |
 17493:                       (0xff & b[a + 1]) << 16 |
 17494:                       (0xff & b[a + 2]) << 8 |
 17495:                       (0xff & b[a + 3]),
 17496:                       (long) b[a + 4] << 56 |
 17497:                       (long) (0xff & b[a + 5]) << 48 |
 17498:                       (long) (0xff & b[a + 6]) << 40 |
 17499:                       (long) (0xff & b[a + 7]) << 32 |
 17500:                       (long) (0xff & b[a + 8]) << 24 |
 17501:                       (long) (0xff & b[a + 9]) << 16 |
 17502:                       (long) (0xff & b[a + 10]) << 8 |
 17503:                       (long) (0xff & b[a + 11]));
 17504:     }  //efp.setp012(byte[],int)
 17505:     public final EFP setp012 (int[] ib, int ia) {
 17506:       return setp012 (ib[ia],
 17507:                       (long) ib[ia + 1] << 32 |
 17508:                       (0xffffffffL & ib[ia + 2]));
 17509:     }  //efp.setp012(int[],int)
 17510:     public final EFP setp012 (int u, long v) {
 17511:       int zf = u & M;  //仮数部の符号
 17512:       int e = XEiJ.FMT_DCB4[u >>> 16 & 0xfff];  //指数部
 17513:       int m0 = XEiJ.FMT_DCB4[u & 0x000f];  //整数部
 17514:       int m1 = XEiJ.FMT_DCB4[(char) (v >>> 48)];  //小数部
 17515:       int m2 = XEiJ.FMT_DCB4[(char) (v >>> 32)];
 17516:       int m3 = XEiJ.FMT_DCB4[(char) (v >>> 16)];
 17517:       int m4 = XEiJ.FMT_DCB4[(char)  v        ];
 17518:       {
 17519:         int t = m0 | m1 | m2 | m3 | m4;
 17520:         if ((u & 0x30000000) != 0 ||  //±Inf,NaN
 17521:             (e | t) < 0) {  //BCDに0..9以外の文字がある
 17522:           if (v == 0L) {  //±Inf
 17523:             this.flg = zf | I;
 17524:           } else {  //NaN
 17525:             if (v << 1 >= 0L) {  //SNaN
 17526:               epbFpsr |= EPB_FPSR_SN;  //シグナリングNaN
 17527:               epbExceptionOperandExponent = 0x7fff << 16;
 17528:               epbExceptionOperandMantissa = 0xbfffffffffffffffL;
 17529:             }
 17530:             this.flg = N;
 17531:           }
 17532:           return this;
 17533:         }
 17534:         if (t == 0) {  //整数部と小数部がすべて0
 17535:           this.flg = zf | Z;  //±0
 17536:           return this;
 17537:         }
 17538:       }
 17539:       //±0,±Inf,NaN以外
 17540:       //FPSRを保存する
 17541:       int savedMode = epbRoundingMode;
 17542:       int savedFpsr = epbFpsr;
 17543:       epbFpsr = 0;
 17544:       //仮数部を変換する
 17545:       this.inner ();
 17546:       EFP t = new EFP ();
 17547:       this.setl ((long) (m0 * 100000000 + m1 * 10000 + m2)).imul (TENXP3).iadd (t.setl ((long) (m3 * 10000 + m4)));  //仮数部
 17548:       //符号を付ける
 17549:       //  符号を付けてから丸めないとRMとRPが逆になってしまう
 17550:       this.flg |= zf;
 17551:       //指数部を変換する
 17552:       if (u << 1 < 0) {  //指数部の符号
 17553:         e = -e;
 17554:       }
 17555:       e -= 16;  //小数点以下の桁数
 17556:       if (e < 0) {  //10^-eで割る
 17557:         e = -e;
 17558:         t.set1 ();
 17559:         for (int i = 0; e != 0; i++, e >>>= 1) {
 17560:           if ((e & 1) != 0) {
 17561:             t.imul (EFP_TEN_POWER_P[i]);
 17562:           }
 17563:         }
 17564:         epbRoundingPrec = EPB_PREC_EXD;
 17565:         epbRoundingMode = savedMode;
 17566:         this.div (t);
 17567:       } else {  //10^eを掛ける
 17568:         t.set1 ();
 17569:         for (int i = 0; e != 0; i++, e >>>= 1) {
 17570:           if ((e & 1) != 0) {
 17571:             t.imul (EFP_TEN_POWER_P[i]);
 17572:           }
 17573:         }
 17574:         epbRoundingPrec = EPB_PREC_EXD;
 17575:         epbRoundingMode = savedMode;
 17576:         this.mul (t);
 17577:       }
 17578:       this.outer ();
 17579:       //基数変換で生じたX2をX1に移す
 17580:       epbFpsr = savedFpsr | epbFpsr >>> 1 & EPB_FPSR_X1;
 17581:       //丸める
 17582:       //  丸めで生じたOF,UF,X2はそのまま返す
 17583:       return this.finish ();
 17584:     }  //efp.setp012(int,long)
 17585: 
 17586:     //------------------------------------------------------------------------
 17587:     //y = y.setpi ()
 17588:     //  y=pi
 17589:     //  円周率
 17590:     //
 17591:     //  式
 17592:     //    Fast multiple-precision evaluation of elementary functions (1976)
 17593:     //      http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.98.4721
 17594:     //    A=1
 17595:     //    B=2^(-1/2)
 17596:     //    T=1/4
 17597:     //    X=1
 17598:     //    while A-B>2^(-n) {
 17599:     //      Y=A
 17600:     //      A=(A+B)/2
 17601:     //      B=sqrt(B*Y)
 17602:     //      T=T-X*(A-Y)^2
 17603:     //      X=2*X
 17604:     //    }
 17605:     //    return A^2/T [or, better, (A+B)^2/(4*T)]
 17606:     //
 17607:     //    AGMアルゴリズム
 17608:     //      http://www.kurims.kyoto-u.ac.jp/~ooura/pi_fft-j.html
 17609:     //    ---- a formula based on the AGM (Arithmetic-Geometric Mean) ----
 17610:     //        c = sqrt(0.125);
 17611:     //        a = 1 + 3 * c;
 17612:     //        b = sqrt(a);
 17613:     //        e = b - 0.625;
 17614:     //        b = 2 * b;
 17615:     //        c = e - c;
 17616:     //        a = a + e;
 17617:     //        npow = 4;
 17618:     //        do {
 17619:     //            npow = 2 * npow;
 17620:     //            e = (a + b) / 2;
 17621:     //            b = sqrt(a * b);
 17622:     //            e = e - b;
 17623:     //            b = 2 * b;
 17624:     //            c = c - e;
 17625:     //            a = e + b;
 17626:     //        } while (e > SQRT_SQRT_EPSILON);
 17627:     //        e = e * e / 4;
 17628:     //        a = a + b;
 17629:     //        pi = (a * a - e - e / 2) / (a * c - e) / npow;
 17630:     //      ---- modification ----
 17631:     //        This is a modified version of Gauss-Legendre formula
 17632:     //        (by T.Ooura). It is faster than original version.
 17633:     //
 17634:     //  値
 17635:     //    echo read("../misc/efp.gp");printf("%.100g\n",Pi) | gp -q
 17636:     //    3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068
 17637:     //
 17638:     //  参考
 17639:     //    https://ja.wikipedia.org/wiki/%E5%86%86%E5%91%A8%E7%8E%87
 17640:     //    https://en.wikipedia.org/wiki/Pi
 17641:     //    http://www.numberworld.org/digits/Pi/
 17642:     //
 17643:     public final EFP setpi () {
 17644:       epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 17645:       return this.sete (ROUNDED_PI[epbRoundingMode]).finish ();
 17646:     }  //efp.setpi()
 17647: 
 17648:     //------------------------------------------------------------------------
 17649:     //y = y.setx012 (b, a)
 17650:     //y = y.setx012 (ib, ia)
 17651:     //y = y.setx012 (i, l)
 17652:     //  extended代入
 17653:     //  丸め処理を行わない
 17654:     //
 17655:     public final EFP setx012 (byte[] b, int a) {
 17656:       return setx012 (b[a] << 24 |
 17657:                       (0xff & b[a + 1]) << 16 |
 17658:                       (0xff & b[a + 2]) << 8 |
 17659:                       (0xff & b[a + 3]),
 17660:                       (long) b[a + 4] << 56 |
 17661:                       (long) (0xff & b[a + 5]) << 48 |
 17662:                       (long) (0xff & b[a + 6]) << 40 |
 17663:                       (long) (0xff & b[a + 7]) << 32 |
 17664:                       (long) (0xff & b[a + 8]) << 24 |
 17665:                       (long) (0xff & b[a + 9]) << 16 |
 17666:                       (long) (0xff & b[a + 10]) << 8 |
 17667:                       (long) (0xff & b[a + 11]));
 17668:     }  //efp.setx012(byte[],int)
 17669:     public final EFP setx012 (int[] ib, int ia) {
 17670:       return setx012 (ib[ia],
 17671:                       (long) ib[ia + 1] << 32 |
 17672:                       (0xffffffffL & ib[ia + 2]));
 17673:     }  //efp.setx012(int[],int)
 17674:     public final EFP setx012 (int i, long l) {
 17675:       int zf = i & M;  //符号
 17676:       int ze = (i >>> 16 & 32767) - 16383;  //指数部
 17677:       if (ze == 16384) {  //±Inf,NaN
 17678:         if (l == 0L) {  //±Inf
 17679:           this.flg = zf | I;
 17680:         } else {  //NaN
 17681:           if (l << 1 >= 0L) {  //SNaN
 17682:             epbFpsr |= EPB_FPSR_SN;  //シグナリングNaN
 17683:             epbExceptionOperandExponent = 0x7fff << 16;
 17684:             epbExceptionOperandMantissa = 0xbfffffffffffffffL;
 17685:           }
 17686:           this.flg = N;
 17687:         }
 17688:         return this;
 17689:       }
 17690:       if (l == 0L) {  //±0
 17691:         this.flg = zf | Z;
 17692:         return this;
 17693:       }
 17694:       if (l >= 0L) {  //未正規化数または非正規化数
 17695:         int o = Long.numberOfLeadingZeros (l);  //1..63
 17696:         ze -= o;
 17697:         l <<= o;
 17698:       }
 17699:       this.flg = zf;
 17700:       this.epp = ze;
 17701:       this.dvl = l;
 17702:       this.cvl = 0L;
 17703:       //非正規化数でもアンダーフロー(UF)をセットしない
 17704:       //丸めない
 17705:       return this;
 17706:     }  //efp.setx012(int,long)
 17707: 
 17708:     //------------------------------------------------------------------------
 17709:     //y = y.sety012 (b, a)
 17710:     //y = y.sety012 (ib, ia)
 17711:     //y = y.sety012 (i, l)
 17712:     //  triple代入
 17713:     //  丸め処理を行わない
 17714:     //
 17715:     public final EFP sety012 (byte[] b, int a) {
 17716:       return sety012 (b[a] << 24 |
 17717:                       (0xff & b[a + 1]) << 16 |
 17718:                       (0xff & b[a + 2]) << 8 |
 17719:                       (0xff & b[a + 3]),
 17720:                       (long) b[a + 4] << 56 |
 17721:                       (long) (0xff & b[a + 5]) << 48 |
 17722:                       (long) (0xff & b[a + 6]) << 40 |
 17723:                       (long) (0xff & b[a + 7]) << 32 |
 17724:                       (long) (0xff & b[a + 8]) << 24 |
 17725:                       (long) (0xff & b[a + 9]) << 16 |
 17726:                       (long) (0xff & b[a + 10]) << 8 |
 17727:                       (long) (0xff & b[a + 11]));
 17728:     }  //efp.sety012(byte[],int)
 17729:     public final EFP sety012 (int[] ib, int ia) {
 17730:       return sety012 (ib[ia],
 17731:                       (long) ib[ia + 1] << 32 |
 17732:                       (0xffffffffL & ib[ia + 2]));
 17733:     }  //efp.sety012(int[],int)
 17734:     public final EFP sety012 (int i, long l) {
 17735:       int zf = i & M;  //符号
 17736:       int ze = (i >>> 16 & 32767) - 16383;  //指数部
 17737:       if (ze == 16384) {  //±Inf,NaN
 17738:         if (l == 0L) {  //±Inf
 17739:           this.flg = zf | I;
 17740:         } else {  //NaN
 17741:           if (l << 1 >= 0L) {  //SNaN
 17742:             epbFpsr |= EPB_FPSR_SN;  //シグナリングNaN
 17743:             epbExceptionOperandExponent = 0x7fff << 16;
 17744:             epbExceptionOperandMantissa = 0xbfffffffffffffffL;
 17745:           }
 17746:           this.flg = N;
 17747:         }
 17748:         return this;
 17749:       }
 17750:       long m = (long) i << 48;  //仮数部の下位16bit
 17751:       if (l == 0L && m == 0L) {  //  //±0
 17752:         this.flg = zf | Z;
 17753:         return this;
 17754:       }
 17755:       if (l >= 0L) {  //未正規化数または非正規化数
 17756:         if (l != 0L) {
 17757:           int o = Long.numberOfLeadingZeros (l);  //1..63
 17758:           ze -= o;
 17759:           l = l << o | m >>> -o;
 17760:           m <<= o;
 17761:         } else {
 17762:           int o = 64 + Long.numberOfLeadingZeros (m);  //64..79
 17763:           ze -= o;
 17764:           l = m << o;
 17765:           m = 0L;
 17766:         }
 17767:       }
 17768:       this.flg = zf;
 17769:       this.epp = ze;
 17770:       this.dvl = l;
 17771:       this.cvl = m;
 17772:       //非正規化数でもアンダーフロー(UF)をセットしない
 17773:       //丸めない
 17774:       return this;
 17775:     }  //efp.sety012(int,long)
 17776: 
 17777:     //------------------------------------------------------------------------
 17778:     //x = x.sgn ()
 17779:     //  x=x<=>0
 17780:     //y = y.sgn (x)
 17781:     //  y=x<=>0
 17782:     //  符号
 17783:     //
 17784:     //  グラフ
 17785:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{$_[0]<=>0});print$g"
 17786:     //    echo read("../misc/efp.gp");graph(sign) | gp -q
 17787:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 17788:     //    |                                       |                                       |
 17789:     //    |                                       |                                       |
 17790:     //    |                                       |                                       |
 17791:     //    |                                       |                                       |
 17792:     //    +                                       +                                       +
 17793:     //    |                                       |                                       |
 17794:     //    |                                       |                                       |
 17795:     //    |                                       |                                       |
 17796:     //    |                                       |                                       |
 17797:     //    +                                       +                                       +
 17798:     //    |                                       |                                       |
 17799:     //    |                                       |                                       |
 17800:     //    |                                       |                                       |
 17801:     //    |                                       |                                       |
 17802:     //    +                                       *****************************************
 17803:     //    |                                       |                                       |
 17804:     //    |                                       |                                       |
 17805:     //    |                                       |                                       |
 17806:     //    |                                       |                                       |
 17807:     //    +---------+---------+---------+---------*---------+---------+---------+---------+
 17808:     //    |                                       |                                       |
 17809:     //    |                                       |                                       |
 17810:     //    |                                       |                                       |
 17811:     //    |                                       |                                       |
 17812:     //    *****************************************                                       +
 17813:     //    |                                       |                                       |
 17814:     //    |                                       |                                       |
 17815:     //    |                                       |                                       |
 17816:     //    |                                       |                                       |
 17817:     //    +                                       +                                       +
 17818:     //    |                                       |                                       |
 17819:     //    |                                       |                                       |
 17820:     //    |                                       |                                       |
 17821:     //    |                                       |                                       |
 17822:     //    +                                       +                                       +
 17823:     //    |                                       |                                       |
 17824:     //    |                                       |                                       |
 17825:     //    |                                       |                                       |
 17826:     //    |                                       |                                       |
 17827:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 17828:     //
 17829:     //  isNaN(x)||x==0?x:x>0?1:-1
 17830:     //
 17831:     //  NaNの扱い
 17832:     //    NaNのときはNaNを返す
 17833:     //
 17834:     //  ±0の扱い
 17835:     //    ±0のときは±0を符号を付けたまま返す
 17836:     //
 17837:     public final EFP sgn () {
 17838:       return this.sgn (this);
 17839:     }  //efp.sgn()
 17840:     public final EFP sgn (EFP x) {
 17841:       int xf = x.flg;
 17842:       if ((xf & (Z | N)) != 0) {  //±0,NaN
 17843:         this.flg = xf;
 17844:       } else {  //±0,NaN以外
 17845:         this.flg = xf & M;  //sgn(±Inf)=±1,sgn(±x)=±1
 17846:         this.epp = 0;
 17847:         this.dvl = MSB;
 17848:         this.cvl = 0L;
 17849:       }
 17850:       return this;
 17851:     }  //efp.sgn(EFP)
 17852: 
 17853:     //------------------------------------------------------------------------
 17854:     //x = x.sgnsub (y)
 17855:     //  x=x<=>y
 17856:     //z = z.sgnsub (x, y)
 17857:     //  z=x<=>y
 17858:     //  比較
 17859:     //
 17860:     //  -Inf<-x<-0==+0<+x<+Inf
 17861:     //
 17862:     //  x.sub(y).sgn()と同じ結果を短い時間で返す
 17863:     //    仮数部を比較する必要があるのはフラグと指数部が一致している場合だけ
 17864:     //    仮数部を比較する場合も減算結果を正規化する必要がない
 17865:     //
 17866:     //  結果をbooleanで返す関数の代用にはならないことに注意
 17867:     //    z.sgnsub(x,y)がNaNを返すとき結果をbooleanで返す関数ではtrueにしなければならない場合とfalseにしなければならない場合がある
 17868:     //
 17869:     //  NaNの扱い
 17870:     //    どちらかがNaNのときはNaNを返す
 17871:     //    x.cmp(y)はどちらかがNaNのときに0を返す
 17872:     //
 17873:     //  ±Infの扱い
 17874:     //    +Inf<=>+Infまたは-Inf<=>-InfのときはNaNを返す
 17875:     //
 17876:     //  ±0の扱い
 17877:     //    両方が±0のときは符号に関係なく+0を返す
 17878:     //
 17879:     //  メモ
 17880:     //    EFPではインスタンスのフラグがコンディションコードを兼ねているので純粋にコンディションコードだけを返すメソッドは作れない
 17881:     //    フラグを書き換えると値が変わってしまう
 17882:     //
 17883:     public final EFP sgnsub (EFP y) {
 17884:       return this.sgnsub (this, y);
 17885:     }  //efp.sgnsub(EFP)
 17886:     public final EFP sgnsub (EFP x, EFP y) {
 17887:       int xf = x.flg;
 17888:       int yf = y.flg;
 17889:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
 17890:         if ((xf & yf) << 1 < 0 && xf == yf) {  //両方±0で符号が同じとき+0
 17891:           this.flg = P | Z;
 17892:         } else if ((xf & yf) << 2 < 0 && xf == yf ||  //両方±Infで符号が同じときNaN
 17893:                    (xf | yf) << 3 < 0) {  //どちらかがNaNのときNaN
 17894:           this.flg = N;
 17895:         } else if ((xf << 1 | yf << 2) < 0) {  //xが±0またはyが±Infのときsgn(-y)
 17896:           if (yf << 1 < 0) {
 17897:             this.flg = yf ^ M;
 17898:           } else {
 17899:             this.flg = yf & M ^ M;
 17900:             this.epp = 0;
 17901:             this.dvl = MSB;
 17902:             this.cvl = 0L;
 17903:           }
 17904:         } else {  //xが±Infまたはyが±0のときsgn(x)
 17905:           this.flg = xf & M;
 17906:           this.epp = 0;
 17907:           this.dvl = MSB;
 17908:           this.cvl = 0L;
 17909:         }
 17910:       } else if (xf != yf) {  //両方±0,±Inf,NaN以外で符号が違う
 17911:         this.flg = xf >= 0 ? P : M;
 17912:         this.epp = 0;
 17913:         this.dvl = MSB;
 17914:         this.cvl = 0L;
 17915:       } else {  //両方±0,±Inf,NaN以外で符号が同じ
 17916:         int s;
 17917:         long t;
 17918:         s = (xf >= 0 ? 1 : -1) * ((s = x.epp - y.epp) != 0 ? s >= 0 ? 1 : -1 :
 17919:                                   (t = x.dvl - y.dvl) != 0L ? t >= 0L ? 1 : -1 :
 17920:                                   (t = (x.cvl >>> 1) - (y.cvl >>> 1)) != 0L ? t >= 0L ? 1 : -1 :
 17921:                                   0);
 17922:         if (s != 0) {  //値が違う
 17923:           this.flg = s >= 0 ? P : M;
 17924:           this.epp = 0;
 17925:           this.dvl = MSB;
 17926:           this.cvl = 0L;
 17927:         } else {  //値が同じ
 17928:           this.flg = P | Z;  //+0
 17929:         }
 17930:       }
 17931:       return this;
 17932:     }  //efp.sgnsub(EFP,EFP)
 17933: 
 17934:     //------------------------------------------------------------------------
 17935:     //x = x.shl (n)
 17936:     //  x*=2^n
 17937:     //y = y.shl (x, n)
 17938:     //  y=x*2^n
 17939:     //  2^n倍(左シフト)
 17940:     //
 17941:     public final EFP shl (int n) {
 17942:       //nが大きすぎてInteger.MAX_VALUEを跨いでしまうと都合が悪いのでnに細工をする
 17943:       n = Math.max (-65536, Math.min (65536, n));
 17944:       return this.finish (this.flg, this.epp + n, this.dvl, this.cvl, 0L);
 17945:     }  //efp.shl(int)
 17946:     public final EFP shl (EFP x, int n) {
 17947:       //nが大きすぎてInteger.MAX_VALUEを跨いでしまうと都合が悪いのでnに細工をする
 17948:       n = Math.max (-65536, Math.min (65536, n));
 17949:       return this.finish (x.flg, x.epp + n, x.dvl, x.cvl, 0L);
 17950:     }  //efp.shl(EFP,int)
 17951: 
 17952:     //------------------------------------------------------------------------
 17953:     //x = x.shr (n)
 17954:     //  x/=2^n
 17955:     //y = y.shr (x, n)
 17956:     //  y=x/2^n
 17957:     //  1/2^n倍(右シフト)
 17958:     //
 17959:     public final EFP shr (int n) {
 17960:       //nが大きすぎてInteger.MAX_VALUEを跨いでしまうと都合が悪いのでnに細工をする
 17961:       n = Math.max (-65536, Math.min (65536, n));
 17962:       return this.finish (this.flg, this.epp - n, this.dvl, this.cvl, 0L);
 17963:     }  //efp.shr(int)
 17964:     public final EFP shr (EFP x, int n) {
 17965:       //nが大きすぎてInteger.MAX_VALUEを跨いでしまうと都合が悪いのでnに細工をする
 17966:       n = Math.max (-65536, Math.min (65536, n));
 17967:       return this.finish (x.flg, x.epp - n, x.dvl, x.cvl, 0L);
 17968:     }  //efp.shr(EFP,int)
 17969: 
 17970:     //------------------------------------------------------------------------
 17971:     //x = x.sin ()
 17972:     //  x=sin(x)
 17973:     //y = y.sin (x)
 17974:     //  y=sin(x)
 17975:     //  正弦 sine サイン
 17976:     //
 17977:     //  グラフ
 17978:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{sin($_[0])});print$g"
 17979:     //    echo read("../misc/efp.gp");graph(sin) | gp -q
 17980:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 17981:     //    |                                       |                                       |
 17982:     //    |                                       |                                       |
 17983:     //    |                                       |                                       |
 17984:     //    |                                       |                                       |
 17985:     //    +                                       +                                       +
 17986:     //    |                                       |                                       |
 17987:     //    |                                       |                                       |
 17988:     //    |                                       |                                       |
 17989:     //    |                                       |                                       |
 17990:     //    +                                       +                                       +
 17991:     //    |                                       |                                       |
 17992:     //    |                                       |                                       |
 17993:     //    |                                       |                                       |
 17994:     //    |                                       |                                       |
 17995:     //    +                                       +          **********                   +
 17996:     //    **                                      |       ****        *****               |
 17997:     //    |***                                    |    ****               ***             |
 17998:     //    |  ****                                 |  ***                    ***           |
 17999:     //    |     ***                               |***                        ***         |
 18000:     //    +-------***---------+---------+--------***--------+---------+---------***-------+
 18001:     //    |         ***                        ***|                               ***     |
 18002:     //    |           ***                    ***  |                                 ****  |
 18003:     //    |             ***               ****    |                                    ***|
 18004:     //    |               *****        ****       |                                      **
 18005:     //    +                   **********          +                                       +
 18006:     //    |                                       |                                       |
 18007:     //    |                                       |                                       |
 18008:     //    |                                       |                                       |
 18009:     //    |                                       |                                       |
 18010:     //    +                                       +                                       +
 18011:     //    |                                       |                                       |
 18012:     //    |                                       |                                       |
 18013:     //    |                                       |                                       |
 18014:     //    |                                       |                                       |
 18015:     //    +                                       +                                       +
 18016:     //    |                                       |                                       |
 18017:     //    |                                       |                                       |
 18018:     //    |                                       |                                       |
 18019:     //    |                                       |                                       |
 18020:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 18021:     //
 18022:     //  定義域
 18023:     //    -inf<=x<=inf
 18024:     //
 18025:     //  値域
 18026:     //    -1<=sin(x)<=1
 18027:     //
 18028:     //  三角関数のとの関係
 18029:     //    sin(x)=2*tan(x/2)/(1+tan(x/2)^2)
 18030:     //
 18031:     //  変数変換
 18032:     //    収束を速くするために|x|<=pi/4にする
 18033:     //    sin(x)=cos(x-pi/2)
 18034:     //          =-sin(x-pi)
 18035:     //          =-cos(x-3*pi/2)
 18036:     //          =sin(x-2*pi)
 18037:     //                  cos(x-pi/2)
 18038:     //                             k=1
 18039:     //                       │    ←
 18040:     //            k=2↓＼    │    ／
 18041:     //                   ＼  │  ／
 18042:     //                     ＼│／
 18043:     //    -sin(x-pi) ────・──── sin(x)
 18044:     //                     ／│＼
 18045:     //                   ／  │  ＼
 18046:     //                 ／    │    ＼↑k=0
 18047:     //                 →    │
 18048:     //                k=3
 18049:     //                -cos(x-3*pi/2)
 18050:     //
 18051:     //  テイラー展開
 18052:     //    sin(x)=x-x^3/3!+x^5/5!-x^7/7!...
 18053:     //    f(n,x)=sum(k=0,n,(-1)^k*x^(2*k+1)/(2*k+1)!)
 18054:     //    除算は不要
 18055:     //
 18056:     //  チェビシェフ展開
 18057:     //    テイラー展開よりも収束が速い
 18058:     //    除算は不要
 18059:     //
 18060:     //  CORDIC
 18061:     //    固定小数点演算用
 18062:     //    浮動小数点演算では結果の指数部が小さいとき有効桁数が不足する
 18063:     //    桁数の少ない浮動小数点演算では加減算と乗算のコストがあまり変わらないので乗算が減っても加減算が増え過ぎるとかえって遅くなる
 18064:     //    参考
 18065:     //      サルでも分かるCORDICアルゴリズム
 18066:     //      http://teamcoil.sp.u-tokai.ac.jp/calculator/100224/
 18067:     //
 18068:     //  sin(x)
 18069:     //    echo read("../misc/efp.gp");eval("f(n,x)=sum(k=0,n,(-1)^k/(2*k+1)!*x^(2*k+1))");for(n=0,26,printf("%4d",floor(closeness(sin,f(n,x),-Pi/4,Pi/4,10000)))) | gp -q
 18070:     //    echo read("../misc/efp.gp");eval("f(x)=sin(x)");a=-Pi/4;b=-a;forstep(n=1,27,2,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
 18071:     //                次数   1   3   5   7   9  11  13  15  17  19  21  23  25  27  29  31  33  35  37  39  41  43  45  47  49  51  53
 18072:     //        テイラー展開   3   8  14  21  28  36  44  53  62  72  81  91 102 112 122 133 144 155 166 178 189 201 213 225 237 249 261
 18073:     //    チェビシェフ展開
 18074:     //        [-pi/4,pi/4]   3  10  17  26  35  45  55  65  76  88  99 111 123 135
 18075:     //
 18076:     public final EFP sin () {
 18077:       return this.sin (this);
 18078:     }  //efp.sin()
 18079:     public final EFP sin (EFP x) {
 18080:       int xf = x.flg;
 18081:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 18082:         if (xf << 1 < 0) {  //±0
 18083:           this.flg = xf;  //sin(±0)=±0
 18084:         } else if (xf << 2 < 0) {  //±Inf
 18085:           epbFpsr |= EPB_FPSR_OE;
 18086:           epbExceptionOperandExponent = xf & M | 0x7fff << 16;
 18087:           epbExceptionOperandMantissa = 0x0000000000000000L;
 18088:           this.flg = N;  //sin(±Inf)=NaN
 18089:         } else {  //NaN
 18090:           this.flg = N;  //sin(NaN)=NaN
 18091:         }
 18092:         return this;
 18093:       }
 18094:       //±0,±Inf,NaN以外
 18095:       int savedFpsr = epbFpsr;
 18096:       this.inner ();
 18097:       if (this == x) {
 18098:         x = new EFP (x);
 18099:       }
 18100:       EFP u = new EFP ();
 18101:       EFP u2 = new EFP ();
 18102:       int k = u.ieeerempi2 (x);  //-pi/2<=u<=pi/2。kはx-uの象限
 18103:       if (false) {  //テイラー展開
 18104:         EFP s = new EFP ();
 18105:         EFP t = new EFP ();
 18106:         u2.isqu (u);  //u^2
 18107:         if ((k & 1) == 0) {  //sin
 18108:           //s.sete (u);  //(-1)^k*x^(2*k+1)/(2*k+1)!
 18109:           s.flg = u.flg;
 18110:           s.epp = u.epp;
 18111:           s.dvl = u.dvl;
 18112:           s.cvl = u.cvl;
 18113:           //t.set0 ();
 18114:           t.flg = P | Z;
 18115:           //this.sete (s);
 18116:           this.flg = s.flg;
 18117:           this.epp = s.epp;
 18118:           this.dvl = s.dvl;
 18119:           this.cvl = s.cvl;
 18120:           for (int twok1 = 3; this.ne (t); twok1 += 2) {  //2*k+1
 18121:             s.imul (u2).divi ((1 - twok1) * twok1);  //(-1)^k*x^(2*k+1)/(2*k+1)!
 18122:             //t.sete (this);
 18123:             t.flg = this.flg;
 18124:             t.epp = this.epp;
 18125:             t.dvl = this.dvl;
 18126:             t.cvl = this.cvl;
 18127:             this.iadd (s);
 18128:           }
 18129:         } else {  //cos
 18130:           //s.set1 ();  //(-1)^k*x^(2*k)/(2*k)!
 18131:           s.flg = P;
 18132:           s.epp = 0;
 18133:           s.dvl = MSB;
 18134:           s.cvl = 0L;
 18135:           //t.set0 ();
 18136:           t.flg = P | Z;
 18137:           //this.sete (s);
 18138:           this.flg = s.flg;
 18139:           this.epp = s.epp;
 18140:           this.dvl = s.dvl;
 18141:           this.cvl = s.cvl;
 18142:           for (int twok = 2; this.ne (t); twok += 2) {  //2*k
 18143:             s.imul (u2).divi ((1 - twok) * twok);  //(-1)^k*x^(2*k)/(2*k)!
 18144:             //t.sete (this);
 18145:             t.flg = this.flg;
 18146:             t.epp = this.epp;
 18147:             t.dvl = this.dvl;
 18148:             t.cvl = this.cvl;
 18149:             this.iadd (s);
 18150:           }
 18151:         }
 18152:       } else {  //チェビシェフ展開
 18153:         if ((k & 1) == 0) {  //sin
 18154:           u2.isqu (u);  //u^2
 18155:           this.imul (SIN_C21, u2)
 18156:             .iadd (SIN_C19).imul (u2)
 18157:               .iadd (SIN_C17).imul (u2)
 18158:                 .iadd (SIN_C15).imul (u2)
 18159:                   .iadd (SIN_C13).imul (u2)
 18160:                     .iadd (SIN_C11).imul (u2)
 18161:                       .iadd (SIN_C9).imul (u2)
 18162:                         .iadd (SIN_C7).imul (u2)
 18163:                           .iadd (SIN_C5).imul (u2)
 18164:                             .iadd (SIN_C3).imul (u2)
 18165:                               .iadd (SIN_C1).imul (u);
 18166:         } else {  //cos
 18167:           u2.isqu (u);  //u^2
 18168:           this.imul (COS_C20, u2)
 18169:             .iadd (COS_C18).imul (u2)
 18170:               .iadd (COS_C16).imul (u2)
 18171:                 .iadd (COS_C14).imul (u2)
 18172:                   .iadd (COS_C12).imul (u2)
 18173:                     .iadd (COS_C10).imul (u2)
 18174:                       .iadd (COS_C8).imul (u2)
 18175:                         .iadd (COS_C6).imul (u2)
 18176:                           .iadd (COS_C4).imul (u2)
 18177:                             .iadd (COS_C2).imul (u2)
 18178:                               .iadd (COS_C0);
 18179:         }
 18180:       }
 18181:       this.outer ().neg (k << 30 < 0);
 18182:       //  n*pi/2はn==0を除いて正確に表現できないので、
 18183:       //    RZまたはRPでsin(x)およびcos(x)が-1になることはあり得ない
 18184:       //    RZまたはRMでsin(x)およびcos(x)がcos(0)以外で+1になることはあり得ない
 18185:       if (this.flg << 1 == 0 && this.epp == 0) {  //結果が±1
 18186:         if (this.flg < 0) {  //結果が-1
 18187:           if (epbRoundingMode == EPB_MODE_RZ || epbRoundingMode == EPB_MODE_RP) {  //RZまたはRPで結果が-1
 18188:             this.sete (NEXTUP_MINUSONE[epbRoundingPrec]);
 18189:           }
 18190:         } else {  //結果が+1
 18191:           if (epbRoundingMode == EPB_MODE_RZ || epbRoundingMode == EPB_MODE_RM) {  //RZまたはRMで結果が+1
 18192:             this.sete (NEXTDOWN_PLUSONE[epbRoundingPrec]);
 18193:           }
 18194:         }
 18195:       }
 18196:       return this.originUpperLower (x).correctUnderflow (savedFpsr);
 18197:     }  //efp.sin(EFP)
 18198: 
 18199:     //------------------------------------------------------------------------
 18200:     //x = x.sinh ()
 18201:     //  x=sinh(x)
 18202:     //y = y.sinh (x)
 18203:     //  y=sinh(x)
 18204:     //  双曲線正弦 hyperbolic sine ハイパボリックサイン
 18205:     //
 18206:     //  グラフ
 18207:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{sinh($_[0])});print$g"
 18208:     //    echo read("../misc/efp.gp");graph(sinh) | gp -q
 18209:     //    +---------+---------+---------+---------+---------+---------+*--------+---------+
 18210:     //    |                                       |                   **                  |
 18211:     //    |                                       |                   *                   |
 18212:     //    |                                       |                  **                   |
 18213:     //    |                                       |                 **                    |
 18214:     //    +                                       +                 *                     +
 18215:     //    |                                       |                **                     |
 18216:     //    |                                       |               **                      |
 18217:     //    |                                       |               *                       |
 18218:     //    |                                       |              **                       |
 18219:     //    +                                       +             **                        +
 18220:     //    |                                       |            **                         |
 18221:     //    |                                       |           **                          |
 18222:     //    |                                       |          **                           |
 18223:     //    |                                       |         **                            |
 18224:     //    +                                       +       ***                             +
 18225:     //    |                                       |      **                               |
 18226:     //    |                                       |    ***                                |
 18227:     //    |                                       |  ***                                  |
 18228:     //    |                                       |***                                    |
 18229:     //    +---------+---------+---------+--------***--------+---------+---------+---------+
 18230:     //    |                                    ***|                                       |
 18231:     //    |                                  ***  |                                       |
 18232:     //    |                                ***    |                                       |
 18233:     //    |                               **      |                                       |
 18234:     //    +                             ***       +                                       +
 18235:     //    |                            **         |                                       |
 18236:     //    |                           **          |                                       |
 18237:     //    |                          **           |                                       |
 18238:     //    |                         **            |                                       |
 18239:     //    +                        **             +                                       +
 18240:     //    |                       **              |                                       |
 18241:     //    |                       *               |                                       |
 18242:     //    |                      **               |                                       |
 18243:     //    |                     **                |                                       |
 18244:     //    +                     *                 +                                       +
 18245:     //    |                    **                 |                                       |
 18246:     //    |                   **                  |                                       |
 18247:     //    |                   *                   |                                       |
 18248:     //    |                  **                   |                                       |
 18249:     //    +---------+--------*+---------+---------+---------+---------+---------+---------+
 18250:     //
 18251:     //  定義域
 18252:     //    -inf<=x<=inf
 18253:     //
 18254:     //  値域
 18255:     //    -inf<=sinh(x)<=inf
 18256:     //
 18257:     //  指数関数との関係
 18258:     //    sinh(x)=(e^x-e^-x)/2
 18259:     //           =((e^x)^2-1)/(2*e^x)
 18260:     //
 18261:     //  テイラー展開
 18262:     //    sinh(x)=x+x^3/3!+x^5/5!+x^7/7!+...
 18263:     //    f(n,x)=sum(k=0,n,x^(2*k+1)/(2*k+1)!)
 18264:     //    echo read("../misc/efp.gp");eval("f(n,x)=sum(k=0,n,1/(2*k+1)!*x^(2*k+1))");a=-0.0625;b=0.0625;for(n=0,12,printf("%4d",floor(closeness(sinh,f(n,x),a,b,10000)))) | gp -q
 18265:     //       1   3   5   7   9  11  13  15  17  19  21  23  25
 18266:     //      10  22  36  50  65  80  96 112 128 145 162 179 197
 18267:     //
 18268:     //  チェビシェフ展開
 18269:     //    0の近くだけチェビシェフ展開を使う
 18270:     //    echo read("../misc/efp.gp");eval("f(x)=sinh(x)");a=-0.0625;b=0.0625;forstep(n=1,25,2,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
 18271:     //       1   3   5   7   9  11  13  15  17  19  21  23  25
 18272:     //      10  24  39  55  71  88 106 124 142 161 179 199 218
 18273:     //    echo read("../misc/efp.gp");eval("f(x)=sinh(x)");a=-0.125;b=0.125;forstep(n=1,25,2,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
 18274:     //       1   3   5   7   9  11  13  15  17  19  21  23  25
 18275:     //       8  20  33  47  61  76  92 108 124 141 157 175 192
 18276:     //
 18277:     public final EFP sinh () {
 18278:       return this.sinh (this);
 18279:     }  //efp.sinh()
 18280:     public final EFP sinh (EFP x) {
 18281:       int xf = x.flg;
 18282:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 18283:         this.flg = xf;
 18284:         return this;
 18285:       }
 18286:       //±0,±Inf,NaN以外
 18287:       epbFpsr |= EPB_FPSR_X2;  //不正確な結果。オーバーフローまたはアンダーフローのときもセットされる
 18288:       epbExceptionOperandExponent = xf | 0x3fff + x.epp << 16;
 18289:       epbExceptionOperandMantissa = x.dvl;
 18290:       if (15 <= x.epp) {  //x<=-32768||32768<=x。sinh(-big)=-Inf,sinh(+big)=+Inf
 18291:         epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 18292:         return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | xf >>> 31]).finish ();  //±Inf
 18293:       }
 18294:       if (x.epp < -3) {  //|x|<0.125
 18295:         int savedFpsr = epbFpsr;
 18296:         this.inner ();
 18297:         if (this == x) {
 18298:           x = new EFP (x);
 18299:         }
 18300:         EFP x2 = new EFP ().isqu (x);  //x^2
 18301:         this.imul (SINH_C13, x2)
 18302:           .iadd (SINH_C11).imul (x2)
 18303:             .iadd (SINH_C9).imul (x2)
 18304:               .iadd (SINH_C7).imul (x2)
 18305:                 .iadd (SINH_C5).imul (x2)
 18306:                   .iadd (SINH_C3).imul (x2)
 18307:                     .iadd (SINH_C1).outer ().mul (x);
 18308:         return this.originLowerUpper (x).correctUnderflow (savedFpsr);
 18309:       }
 18310:       //0.125<=|x|
 18311:       //  xが絶対値の大きい負数のときそのままe^xを計算するとアンダーフローして0になりさらに1/e^xがゼロ除算になる
 18312:       //  オーバーフローだけセットさせるためにxの符号を取ってからe^xを計算する
 18313:       //  丸める前に符号を付けないとRMとRPが逆になってしまうことに注意する
 18314:       this.inner ().abs (x).exp ();  //e^|x|
 18315:       this.sub (new EFP ().rcp (this)).div2 ().outer ().neg (xf < 0);  //(e^|x|-e^-|x|)/2
 18316:       if (this.flg << 2 < 0) {
 18317:         epbFpsr |= EPB_FPSR_OF;  //オーバーフロー
 18318:         return this.sete (OVFL_RESULTS[epbRoundingPrec << 3 | epbRoundingMode << 1 | this.flg >>> 31]).finish ();  //±Inf
 18319:       }
 18320:       return this;
 18321:     }  //efp.sinh(EFP)
 18322: 
 18323:     //------------------------------------------------------------------------
 18324:     //x = x.sqrt ()
 18325:     //  x=sqrt(x)
 18326:     //y = y.sqrt (x)
 18327:     //  y=sqrt(x)
 18328:     //  1/2乗(平方根)
 18329:     //
 18330:     //  グラフ
 18331:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{sqrt($_[0])});print$g"
 18332:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 18333:     //    |                                       |                                       |
 18334:     //    |                                       |                                       |
 18335:     //    |                                       |                                       |
 18336:     //    |                                       |                                       |
 18337:     //    +                                       +                                       +
 18338:     //    |                                       |                                       |
 18339:     //    |                                       |                                       |
 18340:     //    |                                       |                                       |
 18341:     //    |                                       |                                       |
 18342:     //    +                                       +                                   *****
 18343:     //    |                                       |                            ********   |
 18344:     //    |                                       |                      *******          |
 18345:     //    |                                       |                *******                |
 18346:     //    |                                       |           ******                      |
 18347:     //    +                                       +       *****                           +
 18348:     //    |                                       |    ****                               |
 18349:     //    |                                       |  ***                                  |
 18350:     //    |                                       |***                                    |
 18351:     //    |                                       **                                      |
 18352:     //    +---------+---------+---------+---------*---------+---------+---------+---------+
 18353:     //    |                                       |                                       |
 18354:     //    |                                       |                                       |
 18355:     //    |                                       |                                       |
 18356:     //    |                                       |                                       |
 18357:     //    +                                       +                                       +
 18358:     //    |                                       |                                       |
 18359:     //    |                                       |                                       |
 18360:     //    |                                       |                                       |
 18361:     //    |                                       |                                       |
 18362:     //    +                                       +                                       +
 18363:     //    |                                       |                                       |
 18364:     //    |                                       |                                       |
 18365:     //    |                                       |                                       |
 18366:     //    |                                       |                                       |
 18367:     //    +                                       +                                       +
 18368:     //    |                                       |                                       |
 18369:     //    |                                       |                                       |
 18370:     //    |                                       |                                       |
 18371:     //    |                                       |                                       |
 18372:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 18373:     //    echo read("../misc/efp.gp");graph(sqrt) | gp -q
 18374:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 18375:     //    |                                       |                                       |
 18376:     //    |                                       |                                       |
 18377:     //    |                                       |                                       |
 18378:     //    |                                       |                                       |
 18379:     //    +                                       +                                       +
 18380:     //    |                                       |                                       |
 18381:     //    |                                       |                                       |
 18382:     //    |                                       |                                       |
 18383:     //    |                                       |                                       |
 18384:     //    +                                       +                                   *****
 18385:     //    |                                       |                            ********   |
 18386:     //    |                                       |                      *******          |
 18387:     //    |                                       |                ******                 |
 18388:     //    |                                       |           ******                      |
 18389:     //    +                                       +       *****                           +
 18390:     //    |                                       |    ****                               |
 18391:     //    |                                       |  ***                                  |
 18392:     //    |                                       |**                                     |
 18393:     //    |                                       **                                      |
 18394:     //    +---------+---------+---------+---------*---------+---------+---------+---------+
 18395:     //    |                                       |                                       |
 18396:     //    |                                       |                                       |
 18397:     //    |                                       |                                       |
 18398:     //    |                                       |                                       |
 18399:     //    +                                       +                                       +
 18400:     //    |                                       |                                       |
 18401:     //    |                                       |                                       |
 18402:     //    |                                       |                                       |
 18403:     //    |                                       |                                       |
 18404:     //    +                                       +                                       +
 18405:     //    |                                       |                                       |
 18406:     //    |                                       |                                       |
 18407:     //    |                                       |                                       |
 18408:     //    |                                       |                                       |
 18409:     //    +                                       +                                       +
 18410:     //    |                                       |                                       |
 18411:     //    |                                       |                                       |
 18412:     //    |                                       |                                       |
 18413:     //    |                                       |                                       |
 18414:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 18415:     //
 18416:     //  変数変換
 18417:     //    EFPの指数部はdoubleに収まらない
 18418:     //    x=x'*2^(2*k)  2^0<=x'<2^2
 18419:     //    sqrt(x)=sqrt(x'*2^(2*k))
 18420:     //           =sqrt(x')*2^k
 18421:     //
 18422:     //  ニュートン法1
 18423:     //    Math.sqrt()を使ってt=sqrt(x)をdoubleの精度で求めてからニュートン法の反復を1回行う
 18424:     //    f(t)=t^2-x
 18425:     //    f'(t)=2*t
 18426:     //    t'=t-f(t)/f'(t)
 18427:     //      =t-(t^2-x)/(2*t)
 18428:     //      =(2*t^2-(t^2-x))/(2*t)
 18429:     //      =(t^2+x)/(2*t)
 18430:     //      =(t+x/t)/2
 18431:     //    除算が必要
 18432:     //
 18433:     //  ニュートン法2
 18434:     //    Math.sqrt()を使ってt=1/sqrt(x)をdoubleの精度で求めてからニュートン法の反復を1回行ってxを掛ける
 18435:     //    f(t)=1/t^2-x
 18436:     //    f'(t)=-2/t^3
 18437:     //    t1=t-f(t)/f'(t)
 18438:     //      =t-(1/t^2-x)/(-2/t^3)
 18439:     //      =t+t/2-x*t^3/2
 18440:     //      =(3*t-x*t^3)/2
 18441:     //    sqrt(x)=x*t1
 18442:     //           =x*(3*t-x*t^3)/2
 18443:     //    除算は不要
 18444:     //
 18445:     //  整数の平方根
 18446:     //    floor(sqrt(x))
 18447:     //    範囲
 18448:     //      xがs>0桁のときfloor(sqrt(x))はs+1>>1桁
 18449:     //      1<<(s-1>>1) <= floor(sqrt(x)) <= (s&1)!=0?x>>(s>>1):(1<<(s>>1))-1
 18450:     //    ニュートン法
 18451:     //      初期値
 18452:     //        t=(s&1)!=0?x>>(s>>1):(1<<(s>>1))-1
 18453:     //      反復
 18454:     //        t=floor(x/t)+t>>1
 18455:     //      tが減らなくなるまで繰り返す。最後から2番目のtがfloor(sqrt(x))
 18456:     //
 18457:     //  Math.sqrt(-0.0)はNaNにならず-0.0が返るのでこれに合わせる
 18458:     //
 18459:     //  テイラー展開
 18460:     //    x=2^(2*n)の近くはsqrt(1+x)-1のテイラー展開を使う
 18461:     //      coeff(sub(a=0,for n:=0:7 sum sub(x=a,df(sqrt(1+x)-1,x,n))/factorial(n)*(x-a)^n),x);
 18462:     //          1    - 1   1     - 5    7     - 21    33
 18463:     //      {0,---,------,----,------,-----,-------,------}
 18464:     //          2    8     16   128    256   1024    2048
 18465:     //      for n:=0:7 collect (if n=0 then 0 else (-1)^(n-1)/2^(2*n-1)*factorial(2*n-2)/factorial(n-1)/factorial(n));
 18466:     //          1    - 1   1     - 5    7     - 21    33
 18467:     //      {0,---,------,----,------,-----,-------,------}
 18468:     //          2    8     16   128    256   1024    2048
 18469:     //
 18470:     public final EFP sqrt () {
 18471:       return this.sqrt (this);
 18472:     }  //efp.sqrt()
 18473:     public final EFP sqrt (EFP x) {
 18474:       int xf = x.flg;
 18475:       if (xf != 0) {  //-x,±0,±Inf,NaN
 18476:         if (xf == M || xf == (M | I)) {  //sqrt(-x)=NaN, sqrt(-Inf)=NaN
 18477:           epbFpsr |= EPB_FPSR_OE;
 18478:           if (xf << 2 < 0) {  //-Inf
 18479:             epbExceptionOperandExponent = xf & M | 0x7fff << 16;
 18480:             epbExceptionOperandMantissa = 0x0000000000000000L;
 18481:           } else {  //-x
 18482:             epbExceptionOperandExponent = xf & M | 0x3fff + x.epp << 16;
 18483:             epbExceptionOperandMantissa = x.dvl;
 18484:           }
 18485:           this.flg = N;
 18486:         } else {
 18487:           this.flg = xf;  //sqrt(±0)=±0, sqrt(+Inf)=+Inf, sqrt(NaN)=NaN
 18488:         }
 18489:         return this;
 18490:       }
 18491:       //+x
 18492:       if (false) {  //ニュートン法。[92] 535ns
 18493:         this.inner ();
 18494:         EFP t = new EFP (ONE).max (x);
 18495:         EFP u = new EFP (x);  //thisが破壊されるのでxをコピーしておく
 18496:         EFP w = new EFP ();
 18497:         do {
 18498:           //this.sete (t);
 18499:           this.flg = t.flg;
 18500:           this.epp = t.epp;
 18501:           this.dvl = t.dvl;
 18502:           this.cvl = t.cvl;
 18503:           t.iadd (w.sete (u).div (t)).idiv2 ();  //t=(t+x/t)/2
 18504:         } while (this.gt (t));
 18505:         return this.outer ().finish ();
 18506:       } else {  //Math.sqrtを使う。[92] 70.5ns
 18507:         if (this == x) {
 18508:           x = new EFP (x);
 18509:         }
 18510:         int xe = x.epp;
 18511:         if ((xe & 1) != 0 ? (x.dvl >>> -8) == 0xFF : (x.dvl >>> -9) == 0x100) {  //仮数部が1-1/256..1+1/256のとき
 18512:           //  1-1/256=2^-1*0xFF/2^7
 18513:           //  1+1/256=2^0*0x101/2^8
 18514:           this.inner ();
 18515:           x.epp = -(xe & 1);  //指数部を-1または0にする
 18516:           x.dec ();  //1を引く
 18517:           this.imul (x, SQRT1PM1_C11).
 18518:             iadd (SQRT1PM1_C10).imul (x).
 18519:               iadd (SQRT1PM1_C9).imul (x).
 18520:                 iadd (SQRT1PM1_C8).imul (x).
 18521:                   iadd (SQRT1PM1_C7).imul (x).
 18522:                     iadd (SQRT1PM1_C6).imul (x).
 18523:                       iadd (SQRT1PM1_C5).imul (x).
 18524:                         iadd (SQRT1PM1_C4).imul (x).
 18525:                           iadd (SQRT1PM1_C3).imul (x).
 18526:                             iadd (SQRT1PM1_C2).imul (x).
 18527:                               iadd (SQRT1PM1_C1).imul (x);  //テイラー展開
 18528:           this.outer ().inc ();  //1を加えながら丸める
 18529:           if (this.flg << 1 == 0) {
 18530:             //指数部を補正する
 18531:             //  分かりやすいように10進数で書く
 18532:             //         xの範囲      xの指数  sqrt(x)の範囲   sqrt(x)の指数  dec前とinc後の指数  補正値
 18533:             //    0.0099<=x<0.0100    -3     0.099<=x<0.1          -2               -1            -1
 18534:             //    0.0100<=x<0.0101    -2     0.100<=x<0.101        -1                0            -1
 18535:             //     0.099<=x<0.100     -2
 18536:             //     0.100<=x<0.101     -1
 18537:             //      0.99<=x<1         -1      0.99<=x<1            -1               -1             0
 18538:             //         1<=x<1.01       0         1<=x<1.01          0                0             0
 18539:             //       9.9<=x<10         0
 18540:             //        10<=x<10.1       1
 18541:             //        99<=x<100        1       9.9<=x<10            0               -1             1
 18542:             //       100<=x<101        2        10<=x<10.1          1                0             1
 18543:             //       990<=x<1000       2
 18544:             //      1000<=x<1010       3
 18545:             //      9900<=x<10000      3        99<=x<100           1               -1             2
 18546:             //     10000<=x<10100      4       100<=x<101           2                0             2
 18547:             this.epp += xe + 1 >> 1;  //指数部を復元する。負数の右シフトの挙動に注意。ここで指数部が範囲外になることがある
 18548:             this.finish ();
 18549:           }
 18550:           return this;
 18551:         }
 18552:         //  EFPをdoubleに変換する
 18553:         //    EFPの指数部はdoubleの指数部に収まらないので下位1bitだけ使う
 18554:         //    仮数部は上位53bitを使う
 18555:         //  Math.sqrtで53bitの平方根を求める
 18556:         //  doubleをEFPに変換する
 18557:         //    指数部に元の指数部の下位1bitを除いた残りの1/2を加える
 18558:         //  ニュートン法の反復を1回行う
 18559:         //  sqrtでは指数部が正でも負でも半分になるので丸めで制限されるまでオーバーフローもアンダーフローも発生しない
 18560:         //  丸める
 18561:         //  結果を2乗する
 18562:         //  結果の2乗を正確に表現できない場合と結果の2乗と元の値が一致しない場合はX2をセットする
 18563:         long s = Double.doubleToLongBits (Math.sqrt (Double.longBitsToDouble ((long) (1023 + (xe & 1)) << 52 | x.dvl << 1 >>> 12)));
 18564:         EFP t = new EFP (P, (int) (s >>> 52) - 1023 + (xe >> 1), MSB | s << 12 >>> 1, 0L);
 18565:         int savedFpsr = epbFpsr;
 18566:         this.inner ().div (x, t).iadd (t).outer ();
 18567:         this.epp--;  //(t+x/t)/2
 18568:         epbFpsr = 0;
 18569:         this.finish ();
 18570:         savedFpsr |= epbFpsr & (EPB_FPSR_OF | EPB_FPSR_UF);
 18571:         this.inner ();
 18572:         t.squ (this);
 18573:         this.outer ();
 18574:         if ((epbFpsr & EPB_FPSR_X2) != 0 || !t.eq (x)) {
 18575:           savedFpsr |= EPB_FPSR_X2;  //不正確な結果
 18576:           epbExceptionOperandExponent = xf | 0x3fff + x.epp << 16;
 18577:           epbExceptionOperandMantissa = x.dvl;
 18578:         }
 18579:         epbFpsr = savedFpsr;
 18580:         return this;
 18581:       }
 18582:     }  //efp.sqrt(EFP)
 18583: 
 18584:     //------------------------------------------------------------------------
 18585:     //x = x.squ ()
 18586:     //  x*=x
 18587:     //y = y.squ (x)
 18588:     //  y=x^2
 18589:     //  2乗
 18590:     //
 18591:     //  グラフ
 18592:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{$_[0]**2});print$g"
 18593:     //    echo read("../misc/efp.gp");eval("squ(x)=x^2");graph(squ) | gp -q
 18594:     //    +---------+---------*---------+---------+---------+---------*---------+---------+
 18595:     //    |                   **                  |                  **                   |
 18596:     //    |                    *                  |                  *                    |
 18597:     //    |                    **                 |                 **                    |
 18598:     //    |                     *                 |                 *                     |
 18599:     //    +                     **                +                **                     +
 18600:     //    |                      **               |               **                      |
 18601:     //    |                       *               |               *                       |
 18602:     //    |                       **              |              **                       |
 18603:     //    |                        **             |             **                        |
 18604:     //    +                         *             +             *                         +
 18605:     //    |                         **            |            **                         |
 18606:     //    |                          **           |           **                          |
 18607:     //    |                           **          |          **                           |
 18608:     //    |                            **         |         **                            |
 18609:     //    +                             **        +        **                             +
 18610:     //    |                              **       |       **                              |
 18611:     //    |                               **      |      **                               |
 18612:     //    |                                ***    |    ***                                |
 18613:     //    |                                  ***  |  ***                                  |
 18614:     //    +---------+---------+---------+------*******------+---------+---------+---------+
 18615:     //    |                                       |                                       |
 18616:     //    |                                       |                                       |
 18617:     //    |                                       |                                       |
 18618:     //    |                                       |                                       |
 18619:     //    +                                       +                                       +
 18620:     //    |                                       |                                       |
 18621:     //    |                                       |                                       |
 18622:     //    |                                       |                                       |
 18623:     //    |                                       |                                       |
 18624:     //    +                                       +                                       +
 18625:     //    |                                       |                                       |
 18626:     //    |                                       |                                       |
 18627:     //    |                                       |                                       |
 18628:     //    |                                       |                                       |
 18629:     //    +                                       +                                       +
 18630:     //    |                                       |                                       |
 18631:     //    |                                       |                                       |
 18632:     //    |                                       |                                       |
 18633:     //    |                                       |                                       |
 18634:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 18635:     //
 18636:     public final EFP squ () {
 18637:       int xf = this.flg;
 18638:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 18639:         this.flg = xf << 3 < 0 ? N : xf & ~M;  //(±0)^2=+0, (±Inf)^2=+Inf, NaN^2=NaN
 18640:         return this;
 18641:       }
 18642:       //3分割する
 18643:       //  92bitの仮数部を32bit,30bit,30bitに分割する
 18644:       long zd = this.dvl;
 18645:       long zc = this.cvl;
 18646:       long zb = (zd << -2 | zc >>> 2) >>> -30;  //下位30bit
 18647:       zc = zd << 32 >>> -30;  //中位30bit
 18648:       zd >>>= 32;  //上位32bit
 18649:       //2乗する
 18650:       //  (zd*2^60+zc*2^30+zb)^2=zd^2*2^120+2*zd*zc*2^90+(2*zd*zb+zc^2)*2^60+2*zc*zb*2^30+zb^2
 18651:       long t = zb * zb;  //2^0
 18652:       long s = t & 0xffffffffL;  //sticky bit
 18653:       t = (t >>> 30) + (zc * zb << 1);  //2^30
 18654:       s |= t & 0xffffffffL;
 18655:       t = (t >>> 30) + (zd * zb << 1) + zc * zc;  //2^60
 18656:       s |= t & 0xffffffffL;
 18657:       t = (t >>> 30) + (zd * zc << 1);  //2^90
 18658:       zd = (t >>> 30) + zd * zd;  //2^120
 18659:       zc = t << -30 | s;
 18660:       int ze = this.epp << 1;
 18661:       if (zd < 0L) {
 18662:         ze++;
 18663:       } else {
 18664:         zd = zd << 1 | zc >>> -1;
 18665:         zc <<= 1;
 18666:       }
 18667:       return this.finish (P, ze, zd, zc, 0L);
 18668:     }  //efp.squ()
 18669:     public final EFP isqu () {
 18670:       int xf = this.flg;
 18671:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 18672:         this.flg = xf << 3 < 0 ? N : xf & ~M;  //(±0)^2=+0, (±Inf)^2=+Inf, NaN^2=NaN
 18673:         return this;
 18674:       }
 18675:       //3分割する
 18676:       //  92bitの仮数部を32bit,30bit,30bitに分割する
 18677:       long zd = this.dvl;
 18678:       long zc = this.cvl;
 18679:       long zb = (zd << -2 | zc >>> 2) >>> -30;  //下位30bit
 18680:       zc = zd << 32 >>> -30;  //中位30bit
 18681:       zd >>>= 32;  //上位32bit
 18682:       //2乗する
 18683:       //  (zd*2^60+zc*2^30+zb)^2=zd^2*2^120+2*zd*zc*2^90+(2*zd*zb+zc^2)*2^60+2*zc*zb*2^30+zb^2
 18684:       long t = zb * zb;  //2^0
 18685:       long s = t & 0xffffffffL;  //sticky bit
 18686:       t = (t >>> 30) + (zc * zb << 1);  //2^30
 18687:       s |= t & 0xffffffffL;
 18688:       t = (t >>> 30) + (zd * zb << 1) + zc * zc;  //2^60
 18689:       s |= t & 0xffffffffL;
 18690:       t = (t >>> 30) + (zd * zc << 1);  //2^90
 18691:       zd = (t >>> 30) + zd * zd;  //2^120
 18692:       zc = t << -30 | s;
 18693:       int ze = this.epp << 1;
 18694:       if (zd < 0L) {
 18695:         ze++;
 18696:       } else {
 18697:         zd = zd << 1 | zc >>> -1;
 18698:         zc <<= 1;
 18699:       }
 18700:       return this.ifinish (P, ze, zd, zc, 0L);
 18701:     }  //efp.isqu()
 18702:     public final EFP squ (EFP x) {
 18703:       //return this.mul (x, x);  //11.8ns
 18704:       //8.4ns
 18705:       int xf = x.flg;
 18706:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 18707:         this.flg = xf << 3 < 0 ? N : xf & ~M;  //(±0)^2=+0, (±Inf)^2=+Inf, NaN^2=NaN
 18708:         return this;
 18709:       }
 18710:       //3分割する
 18711:       //  92bitの仮数部を32bit,30bit,30bitに分割する
 18712:       long zd = x.dvl;
 18713:       long zc = x.cvl;
 18714:       long zb = (zd << -2 | zc >>> 2) >>> -30;  //下位30bit
 18715:       zc = zd << 32 >>> -30;  //中位30bit
 18716:       zd >>>= 32;  //上位32bit
 18717:       //2乗する
 18718:       //  (zd*2^60+zc*2^30+zb)^2=zd^2*2^120+2*zd*zc*2^90+(2*zd*zb+zc^2)*2^60+2*zc*zb*2^30+zb^2
 18719:       long t = zb * zb;  //2^0
 18720:       long s = t & 0xffffffffL;  //sticky bit
 18721:       t = (t >>> 30) + (zc * zb << 1);  //2^30
 18722:       s |= t & 0xffffffffL;
 18723:       t = (t >>> 30) + (zd * zb << 1) + zc * zc;  //2^60
 18724:       s |= t & 0xffffffffL;
 18725:       t = (t >>> 30) + (zd * zc << 1);  //2^90
 18726:       zd = (t >>> 30) + zd * zd;  //2^120
 18727:       zc = t << -30 | s;
 18728:       int ze = x.epp << 1;
 18729:       if (zd < 0L) {
 18730:         ze++;
 18731:       } else {
 18732:         zd = zd << 1 | zc >>> -1;
 18733:         zc <<= 1;
 18734:       }
 18735:       return this.finish (P, ze, zd, zc, 0L);
 18736:     }  //efp.squ(EFP)
 18737:     public final EFP isqu (EFP x) {
 18738:       //return this.mul (x, x);  //11.8ns
 18739:       //8.4ns
 18740:       int xf = x.flg;
 18741:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 18742:         this.flg = xf << 3 < 0 ? N : xf & ~M;  //(±0)^2=+0, (±Inf)^2=+Inf, NaN^2=NaN
 18743:         return this;
 18744:       }
 18745:       //3分割する
 18746:       //  92bitの仮数部を32bit,30bit,30bitに分割する
 18747:       long zd = x.dvl;
 18748:       long zc = x.cvl;
 18749:       long zb = (zd << -2 | zc >>> 2) >>> -30;  //下位30bit
 18750:       zc = zd << 32 >>> -30;  //中位30bit
 18751:       zd >>>= 32;  //上位32bit
 18752:       //2乗する
 18753:       //  (zd*2^60+zc*2^30+zb)^2=zd^2*2^120+2*zd*zc*2^90+(2*zd*zb+zc^2)*2^60+2*zc*zb*2^30+zb^2
 18754:       long t = zb * zb;  //2^0
 18755:       long s = t & 0xffffffffL;  //sticky bit
 18756:       t = (t >>> 30) + (zc * zb << 1);  //2^30
 18757:       s |= t & 0xffffffffL;
 18758:       t = (t >>> 30) + (zd * zb << 1) + zc * zc;  //2^60
 18759:       s |= t & 0xffffffffL;
 18760:       t = (t >>> 30) + (zd * zc << 1);  //2^90
 18761:       zd = (t >>> 30) + zd * zd;  //2^120
 18762:       zc = t << -30 | s;
 18763:       int ze = x.epp << 1;
 18764:       if (zd < 0L) {
 18765:         ze++;
 18766:       } else {
 18767:         zd = zd << 1 | zc >>> -1;
 18768:         zc <<= 1;
 18769:       }
 18770:       return this.ifinish (P, ze, zd, zc, 0L);
 18771:     }  //efp.isqu(EFP)
 18772: 
 18773:     //------------------------------------------------------------------------
 18774:     //x = x.sub (y)
 18775:     //  x-=y
 18776:     //z = z.sub (x, y)
 18777:     //  z=x-y
 18778:     //  減算
 18779:     //
 18780:     //  (xn/xd)-(yn/yd)
 18781:     //    =((xn*yd)/(xd*yd))-((xd*yn)/(xd*yd))
 18782:     //    =(xn*yd-xd*yn)/(xd*yd)
 18783:     //
 18784:     public final EFP sub (EFP y) {
 18785:       int xf = this.flg;
 18786:       int xe = this.epp;
 18787:       long xd = this.dvl;
 18788:       long xc = this.cvl;
 18789:       long xb = 0L;
 18790:       int yf = y.flg;
 18791:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
 18792:         if ((xf | yf) << 3 < 0) {  //どちらかがNaNのときNaN
 18793:           this.flg = N;
 18794:           return this;
 18795:         }
 18796:         if ((xf & yf) << 2 < 0 && xf == yf) {  //両方±Infで符号が同じときNaN
 18797:           epbFpsr |= EPB_FPSR_OE;
 18798:           epbExceptionOperandExponent = yf & M | 0x7fff << 16;
 18799:           epbExceptionOperandMantissa = 0x0000000000000000L;
 18800:           this.flg = N;
 18801:           return this;
 18802:         }
 18803:         if ((xf & yf) << 1 < 0 && xf == yf) {  //両方±0で符号が同じとき
 18804:           this.flg = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //RMのとき-0,それ以外は+0
 18805:           return this;
 18806:         }
 18807:         if (xf << 1 < 0 || yf << 2 < 0) {  //xが±0またはyが±Infのとき-y
 18808:           xf = yf ^ M;
 18809:           xe = y.epp;
 18810:           xd = y.dvl;
 18811:           xc = y.cvl;
 18812:         }
 18813:         //xが±Infまたはyが±0のときx
 18814:       } else {  //両方±0,±Inf,NaN以外
 18815:         //減算なのでyの符号を反転して加算する
 18816:         yf ^= M;
 18817:         long yd = y.dvl;
 18818:         long yc = y.cvl;
 18819:         int o = xe - y.epp;
 18820:         if (o < 0 || o == 0 && (xd < yd || xd == yd && xc >>> 1 < yc >>> 1)) {  //yの方が絶対値が大きい
 18821:           //xとyを入れ換える
 18822:           xf = yf;
 18823:           xe += o = -o;  //xe=y.epp
 18824:           xd = yd;
 18825:           xc = yc;
 18826:           yf = this.flg;  //後で符号を比較するときに使う
 18827:           yd = this.dvl;
 18828:           yc = this.cvl;
 18829:         }
 18830:         //xの方が絶対値が大きいか等しい
 18831:         //yを右にずらして小数点の位置を合わせる
 18832:         if (0 < o) {
 18833:           if (o <= 63) {
 18834:             xb = yc << -o;
 18835:             yc = yd << -o | yc >>> o;
 18836:             yd >>>= o;
 18837:           } else if (o == 64) {
 18838:             xb = yc;
 18839:             yc = yd;
 18840:             yd = 0L;
 18841:           } else if (o <= 127) {
 18842:             xb = yd << -o | yc;
 18843:             yc = yd >>> o;
 18844:             yd = 0L;
 18845:           } else {
 18846:             xb = yd | yc;  //絶対値減算を行うとき下位からのボローとして必要
 18847:             yc = 0L;
 18848:             yd = 0L;
 18849:           }
 18850:         }
 18851:         //絶対値加算または絶対値減算を行う
 18852:         if (xf == yf) {  //符号が同じなので絶対値加算を行う
 18853:           //yc[1]とyc[0]をsticky bitに押し出す
 18854:           xb |= yc << 62;
 18855:           //右にずらしてxd[63]を空ける
 18856:           xc = xd << 63 | xc >>> 1;
 18857:           xd >>>= 1;
 18858:           yc = yd << 63 | yc >>> 1;
 18859:           yd >>>= 1;
 18860:           //下位を右にずらしてxc[63]を空ける
 18861:           yc >>>= 1;
 18862:           xc >>>= 1;
 18863:           //足す
 18864:           xc += yc;
 18865:           xd += yd + (xc >>> 63);
 18866:           //下位を左にずらしてxc[63]を詰める
 18867:           xc <<= 1;
 18868:           //溢れの処理
 18869:           if (xd < 0L) {  //溢れたとき
 18870:             xe++;
 18871:           } else {  //溢れなかったとき
 18872:             xd = xd << 1 | xc >>> 63;  //左にずらしてxd[63]を詰める
 18873:             xc <<= 1;
 18874:           }
 18875:         } else {  //符号が異なるので絶対値減算を行う
 18876:           //yc[0]をsticky bitに押し出す
 18877:           xb |= yc << 63;
 18878:           //下位を右にずらしてxc[63]を空ける
 18879:           yc >>>= 1;
 18880:           xc >>>= 1;
 18881:           //引く
 18882:           //  xの方が絶対値が大きいか等しいので負になることはないが0になることがある
 18883:           if (xb != 0L) {
 18884:             xc--;
 18885:           }
 18886:           xc -= yc;
 18887:           xd -= yd + (xc >>> 63);
 18888:           //下位を左にずらしてxc[63]を詰める
 18889:           xc <<= 1;
 18890:           //正規化する
 18891:           if (0L <= xd) {
 18892:             if (xd != 0L) {
 18893:               xe -= o = Long.numberOfLeadingZeros (xd);
 18894:               xd = xd << o | xc >>> -o;
 18895:               xc <<= o;
 18896:             } else if (xc != 0L) {
 18897:               xe -= o = 64 + Long.numberOfLeadingZeros (xc);
 18898:               xd = xc << o;
 18899:               xc = 0L;
 18900:             } else {  //0になった
 18901:               xf = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //RMのとき-0,それ以外は+0
 18902:             }
 18903:           }
 18904:         }  //if 符号が同じなので絶対値加算を行う/符号が異なるので絶対値減算を行う
 18905:       }  //if どちらかが±0,±Inf,NaN/両方±0,±Inf,NaN以外
 18906:       return this.finish (xf, xe, xd, xc, xb);
 18907:     }  //efp.sub(EFP)
 18908:     public final EFP sub (EFP x, EFP y) {
 18909:       int xf = x.flg;
 18910:       int xe = x.epp;
 18911:       long xd = x.dvl;
 18912:       long xc = x.cvl;
 18913:       long xb = 0L;
 18914:       int yf = y.flg;
 18915:       if ((xf | yf) << 1 != 0) {  //どちらかが±0,±Inf,NaN
 18916:         if ((xf | yf) << 3 < 0) {  //どちらかがNaNのときNaN
 18917:           this.flg = N;
 18918:           return this;
 18919:         }
 18920:         if ((xf & yf) << 2 < 0 && xf == yf) {  //両方±Infで符号が同じときNaN
 18921:           epbFpsr |= EPB_FPSR_OE;
 18922:           epbExceptionOperandExponent = yf & M | 0x7fff << 16;
 18923:           epbExceptionOperandMantissa = 0x0000000000000000L;
 18924:           this.flg = N;
 18925:           return this;
 18926:         }
 18927:         if ((xf & yf) << 1 < 0 && xf == yf) {  //両方±0で符号が同じとき
 18928:           this.flg = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //RMのとき-0,それ以外は+0
 18929:           return this;
 18930:         }
 18931:         if (xf << 1 < 0 || yf << 2 < 0) {  //xが±0またはyが±Infのとき-y
 18932:           xf = yf ^ M;
 18933:           xe = y.epp;
 18934:           xd = y.dvl;
 18935:           xc = y.cvl;
 18936:         }
 18937:         //xが±Infまたはyが±0のときx
 18938:       } else {  //両方±0,±Inf,NaN以外
 18939:         //減算なのでyの符号を反転して加算する
 18940:         yf ^= M;
 18941:         long yd = y.dvl;
 18942:         long yc = y.cvl;
 18943:         int o = xe - y.epp;
 18944:         if (o < 0 || o == 0 && (xd < yd || xd == yd && xc >>> 1 < yc >>> 1)) {  //yの方が絶対値が大きい
 18945:           //xとyを入れ換える
 18946:           xf = yf;
 18947:           xe += o = -o;  //xe=y.epp
 18948:           xd = yd;
 18949:           xc = yc;
 18950:           yf = x.flg;  //後で符号を比較するときに使う
 18951:           yd = x.dvl;
 18952:           yc = x.cvl;
 18953:         }
 18954:         //xの方が絶対値が大きいか等しい
 18955:         //yを右にずらして小数点の位置を合わせる
 18956:         if (0 < o) {
 18957:           if (o <= 63) {
 18958:             xb = yc << -o;
 18959:             yc = yd << -o | yc >>> o;
 18960:             yd >>>= o;
 18961:           } else if (o == 64) {
 18962:             xb = yc;
 18963:             yc = yd;
 18964:             yd = 0L;
 18965:           } else if (o <= 127) {
 18966:             xb = yd << -o | yc;
 18967:             yc = yd >>> o;
 18968:             yd = 0L;
 18969:           } else {
 18970:             xb = yd | yc;  //絶対値減算を行うとき下位からのボローとして必要
 18971:             yc = 0L;
 18972:             yd = 0L;
 18973:           }
 18974:         }
 18975:         //絶対値加算または絶対値減算を行う
 18976:         if (xf == yf) {  //符号が同じなので絶対値加算を行う
 18977:           //yc[1]とyc[0]をsticky bitに押し出す
 18978:           xb |= yc << 62;
 18979:           //右にずらしてxd[63]を空ける
 18980:           xc = xd << 63 | xc >>> 1;
 18981:           xd >>>= 1;
 18982:           yc = yd << 63 | yc >>> 1;
 18983:           yd >>>= 1;
 18984:           //下位を右にずらしてxc[63]を空ける
 18985:           yc >>>= 1;
 18986:           xc >>>= 1;
 18987:           //足す
 18988:           xc += yc;
 18989:           xd += yd + (xc >>> 63);
 18990:           //下位を左にずらしてxc[63]を詰める
 18991:           xc <<= 1;
 18992:           //溢れの処理
 18993:           if (xd < 0L) {  //溢れたとき
 18994:             xe++;
 18995:           } else {  //溢れなかったとき
 18996:             xd = xd << 1 | xc >>> 63;  //左にずらしてxd[63]を詰める
 18997:             xc <<= 1;
 18998:           }
 18999:         } else {  //符号が異なるので絶対値減算を行う
 19000:           //yc[0]をsticky bitに押し出す
 19001:           xb |= yc << 63;
 19002:           //下位を右にずらしてxc[63]を空ける
 19003:           yc >>>= 1;
 19004:           xc >>>= 1;
 19005:           //引く
 19006:           //  xの方が絶対値が大きいか等しいので負になることはないが0になることがある
 19007:           if (xb != 0L) {
 19008:             xc--;
 19009:           }
 19010:           xc -= yc;
 19011:           xd -= yd + (xc >>> 63);
 19012:           //下位を左にずらしてxc[63]を詰める
 19013:           xc <<= 1;
 19014:           //正規化する
 19015:           if (0L <= xd) {
 19016:             if (xd != 0L) {
 19017:               xe -= o = Long.numberOfLeadingZeros (xd);
 19018:               xd = xd << o | xc >>> -o;
 19019:               xc <<= o;
 19020:             } else if (xc != 0L) {
 19021:               xe -= o = 64 + Long.numberOfLeadingZeros (xc);
 19022:               xd = xc << o;
 19023:               xc = 0L;
 19024:             } else {  //0になった
 19025:               xf = epbRoundingMode == EPB_MODE_RM ? M | Z : P | Z;  //RMのとき-0,それ以外は+0
 19026:             }
 19027:           }
 19028:         }  //if 符号が同じなので絶対値加算を行う/符号が異なるので絶対値減算を行う
 19029:       }  //if どちらかが±0,±Inf,NaN/両方±0,±Inf,NaN以外
 19030:       return this.finish (xf, xe, xd, xc, xb);
 19031:     }  //efp.sub(EFP,EFP)
 19032: 
 19033:     //------------------------------------------------------------------------
 19034:     //x = x.tan ()
 19035:     //  x=tan(x)
 19036:     //y = y.tan (x)
 19037:     //  y=tan(x)
 19038:     //  正接 tangent タンジェント
 19039:     //
 19040:     //  グラフ
 19041:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{tan($_[0])});print$g"
 19042:     //    echo read("../misc/efp.gp");graph(tan) | gp -q
 19043:     //    +---------+---------+-*-------+---------+---------+--*------+---------+---------+
 19044:     //    |                     *                 |            *                          |
 19045:     //    |                     *                 |            *                          |
 19046:     //    |                    **                 |            *                          |
 19047:     //    |                    *                  |            *                          |
 19048:     //    +                    *                  +           **                          +
 19049:     //    |                    *                  |           *                           |
 19050:     //    |                   **                  |           *                           |
 19051:     //    |                   *                   |           *                           |
 19052:     //    |                   *                   |          **                           |
 19053:     //    +                  **                   +          *                            +
 19054:     //    |                  *                    |         **                            |
 19055:     //    |                 **                    |         *                             |
 19056:     //    |                 *                     |        **                             |
 19057:     //    |                **                     |       **                              *
 19058:     //    +               **                      +      **                              **
 19059:     //    |              **                       |     **                              **|
 19060:     //    |            ***                        |    **                             *** |
 19061:     //    |          ***                          |  ***                            ***   |
 19062:     //    |         **                            |***                            ***     |
 19063:     //    +-------***---------+---------+--------***--------+---------+---------***-------+
 19064:     //    |     ***                            ***|                            **         |
 19065:     //    |   ***                            ***  |                          ***          |
 19066:     //    | ***                             **    |                        ***            |
 19067:     //    |**                              **     |                       **              |
 19068:     //    **                              **      +                      **               +
 19069:     //    *                              **       |                     **                |
 19070:     //    |                             **        |                     *                 |
 19071:     //    |                             *         |                    **                 |
 19072:     //    |                            **         |                    *                  |
 19073:     //    +                            *          +                   **                  +
 19074:     //    |                           **          |                   *                   |
 19075:     //    |                           *           |                   *                   |
 19076:     //    |                           *           |                  **                   |
 19077:     //    |                           *           |                  *                    |
 19078:     //    +                          **           +                  *                    +
 19079:     //    |                          *            |                  *                    |
 19080:     //    |                          *            |                 **                    |
 19081:     //    |                          *            |                 *                     |
 19082:     //    |                          *            |                 *                     |
 19083:     //    +---------+---------+------*--+---------+---------+-------*-+---------+---------+
 19084:     //
 19085:     //  定義域
 19086:     //    -inf<=x<=inf
 19087:     //
 19088:     //  値域
 19089:     //    -inf<=tan(x)<=inf
 19090:     //
 19091:     //  三角関数のとの関係
 19092:     //    tan(x)=sin(x)/cos(x)
 19093:     //
 19094:     //  加法定理
 19095:     //    tan(x+y)=(tan(x)+tan(y))/(1-tan(x)*tan(y))
 19096:     //
 19097:     //  倍角と半角
 19098:     //    tan(2*x)=tan(x+x)
 19099:     //            =(tan(x)+tan(x))/(1-tan(x)*tan(x))
 19100:     //            =2*tan(x)/(1-tan(x)^2)
 19101:     //    tan(3*x)=tan(2*x+x)
 19102:     //            =(tan(2*x)+tan(x))/(1-tan(2*x)*tan(x))
 19103:     //            =(2*tan(x)/(1-tan(x)^2)+tan(x))/(1-2*tan(x)/(1-tan(x)^2)*tan(x))
 19104:     //            =(tan(x)^3-3*tan(x))/(3*tan(x)^2-1)
 19105:     //    tan(x)=2*tan(x/2)/(1-tan(x/2)^2)
 19106:     //    tan(x/2)=(+/-sqrt(tan(x)^2+1)-1)/tan(x)
 19107:     //
 19108:     //  変数変換1
 19109:     //    収束を速くするために|x|<=pi/8にする
 19110:     //    tan(pi/4)=1
 19111:     //    tan(x+pi/4)=(tan(x)+tan(pi/4))/(1-tan(x)*tan(pi/4))
 19112:     //               =(tan(x)+1)/(1-tan(x))
 19113:     //    tan(3*pi/4)=-1
 19114:     //    tan(x+3*pi/4)=(tan(x)+tan(3*pi/4))/(1-tan(x)*tan(3*pi/4))
 19115:     //                 =(tan(x)-1)/(1+tan(x))
 19116:     //    tan(x)=(tan(x-pi/4)+1)/(1-tan(x-pi/4))
 19117:     //          =-1/tan(x-pi/2)
 19118:     //          =(tan(x-3*pi/4)-1)/(1+tan(x-3*pi/4))
 19119:     //          =tan(x-pi)
 19120:     //                -1/tan(x-pi/2)
 19121:     //                  k=3     k=2
 19122:     //                  ←      ←
 19123:     //                    \  │  /   (tan(x-pi/4)+1)/(1-tan(x-pi/4))
 19124:     //                 ＼  \ │ /  ／
 19125:     //                   ＼ \│/ ／   ↑k=1
 19126:     //           k=0↓~~-- ＼│／ --~~
 19127:     //     tan(x-pi) ────・──── tan(x)
 19128:     //                __-- ／│＼ --__↑k=0
 19129:     //           k=1↓   ／ /│\ ＼
 19130:     //                 ／  / │ \  ＼
 19131:     //                    /  │  \
 19132:     //                    →      →
 19133:     //                    k=2     k=3
 19134:     //
 19135:     //  変数変換2
 19136:     //    場合分けを増やせばチェビシェフ展開の多項式を短くすることができる
 19137:     //    tan(pi/8)=(sqrt(tan(pi/4)^2+1)-1)/tan(pi/4)
 19138:     //             =(sqrt(1^2+1)-1)/1
 19139:     //             =sqrt(2)-1
 19140:     //    tan(3*pi/8)=(tan(pi/8)^3-3*tan(pi/8))/(3*tan(pi/8)^2-1)
 19141:     //               =((sqrt(2)-1)^3-3*(sqrt(2)-1))/(3*(sqrt(2)-1)^2-1)
 19142:     //               =(2-sqrt(2))/(3*sqrt(2)-4)
 19143:     //               =(2-sqrt(2))*(3*sqrt(2)+4)/(3*sqrt(2)-4)/(3*sqrt(2)+4)
 19144:     //               =(8-6+(6-4)*sqrt(2))/2
 19145:     //               =sqrt(2)+1
 19146:     //    tan(x)=(tan(x-pi/8)+sqrt(2)-1)/(1-tan(x-pi/8)*(sqrt(2)-1))
 19147:     //          =(tan(x-3*pi/8)+sqrt(2)+1)/(1-tan(x-3*pi/8)*(sqrt(2)+1))
 19148:     //          =(tan(x-5*pi/8)-(sqrt(2)+1))/(1+tan(x-3*pi/8)*(sqrt(2)+1))
 19149:     //          =(tan(x-7*pi/8)-(sqrt(2)-1))/(1+tan(x-3*pi/8)*(sqrt(2)-1))
 19150:     //
 19151:     //  ローラン級数展開
 19152:     //    tan(x)=x-x^3/3+2*x^5/15-17*x^7/315+...
 19153:     //          =sum[n=1..inf]{(-1)^n*4^n*(1-4^n)*B(2*n)*x^(2*n-1)/(2*n)!}  |x|<pi/2
 19154:     //    f(n,x)=sum(k=1,n,(-1)^k*4^k*(1-4^k)*bernreal(2*k)*x^(2*k-1)/(2*k)!)
 19155:     //
 19156:     //  チェビシェフ展開
 19157:     //    echo read("../misc/efp.gp");eval("f(x)=tan(x)");a=-Pi/8;b=Pi/8;forstep(n=1,35,2,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
 19158:     //    echo read("../misc/efp.gp");eval("f(x)=tan(x)");a=-Pi/16;b=Pi/16;forstep(n=1,35,2,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
 19159:     //    echo read("../misc/efp.gp");eval("f(x)=tan(x)");a=-Pi/32;b=Pi/32;forstep(n=1,35,2,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
 19160:     //    echo read("../misc/efp.gp");eval("f(x)=tan(x)");a=-Pi/64;b=Pi/64;forstep(n=1,21,2,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
 19161:     //    echo read("../misc/efp.gp");eval("f(x)=tan(x)");a=-Pi/128;b=Pi/128;forstep(n=1,21,2,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
 19162:     //    echo read("../misc/efp.gp");eval("f(x)=tan(x)");a=-Pi/256;b=Pi/256;forstep(n=1,15,2,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
 19163:     //       1   3   5   7   9  11  13  15  17  19  21  23  25  27  29  31  33  35
 19164:     //       4   9  15  20  26  32  38  43  49  55  61  67  72  78  84  90  96 102  |x|<=pi/8
 19165:     //       6  13  21  29  36  44  52  60  67  75  83  91  99 107 115 123 130 138  |x|<=pi/16  pi/8  4要素
 19166:     //       8  17  27  37  46  56  66  76  86  95 105 115 125 135 145 155 165 175  |x|<=pi/32  pi/16  8要素
 19167:     //      10  21  33  45  56  68  80  92 104 115 127  |x|<=pi/64  pi/32  16要素
 19168:     //      12  25  39  53  66  80  94 108 122 135 149  |x|<=pi/128  pi/64  32要素
 19169:     //      14  29  45  61  76  92 108 124  |x|<=pi/256  pi/128  64要素
 19170:     //
 19171:     public final EFP tan () {
 19172:       return this.tan (this);
 19173:     }  //efp.tan()
 19174:     public final EFP tan (EFP x) {
 19175:       int xf = x.flg;
 19176:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 19177:         if (xf << 1 < 0) {  //±0
 19178:           this.flg = xf;  //tan(±0)=±0
 19179:         } else if (xf << 2 < 0) {  //±Inf
 19180:           epbFpsr |= EPB_FPSR_OE;
 19181:           epbExceptionOperandExponent = xf & M | 0x7fff << 16;
 19182:           epbExceptionOperandMantissa = 0x0000000000000000L;
 19183:           this.flg = N;  //tan(±Inf)=NaN
 19184:         } else {  //NaN
 19185:           this.flg = N;  //tan(NaN)=NaN
 19186:         }
 19187:         return this;
 19188:       }
 19189:       //±0,±Inf,NaN以外
 19190:       if (false) {  //sin/cos。[90] 800ns
 19191:         EFP c = new EFP ().inner ().cos (x);  //cos(x)
 19192:         return this.sin (x).outer ().div (c);  //sin(x)/cos(x)
 19193:       } else if (false) {  //4分割。[90] 600ns
 19194:         this.inner ();
 19195:         EFP s = new EFP ();
 19196:         EFP t = new EFP ();
 19197:         EFP u = new EFP ().iabs (x);  //|x|
 19198:         EFP u2 = new EFP ();
 19199:         int k = 0;  //|x|+pi/8の8分象限
 19200:         //if (u.gt (PI_8)) {  //|x|>pi/8
 19201:         if (u.epp >= -1 || (u.epp == -2 && u.dvl >= 0xc90fdaa22168c234L)) {  //|x|>=pi/8。下位の比較は省略する
 19202:           //s.iadd (u, PI_8).quo (PI_4);  //|x|+pi/8をpi/4で割った商
 19203:           s.iadd (u, PI_8).imul (FOUR_PI).trunc ();  //|x|+pi/8をpi/4で割った商
 19204:           //  |x|をpi/4で割った余りを求めるとき|x|がpi/4の整数倍に近いと桁落ちが発生するので倍精度で計算する
 19205:           u.sub (t.imulw (u2, s, PI_4)).sub (u2).sub (t.imul (s, PI_4A));  //|x|をpi/4で割った余り。[-pi/8,pi/8]
 19206:           k = s.geti () & 3;  //|x|+pi/8の8分象限
 19207:         }
 19208:         u2.isqu (u);  //u^2
 19209:         this.imul (TAN_C33, u2)
 19210:           .iadd (TAN_C31).imul (u2)
 19211:             .iadd (TAN_C29).imul (u2)
 19212:               .iadd (TAN_C27).imul (u2)
 19213:                 .iadd (TAN_C25).imul (u2)
 19214:                   .iadd (TAN_C23).imul (u2)
 19215:                     .iadd (TAN_C21).imul (u2)
 19216:                       .iadd (TAN_C19).imul (u2)
 19217:                         .iadd (TAN_C17).imul (u2)
 19218:                           .iadd (TAN_C15).imul (u2)
 19219:                             .iadd (TAN_C13).imul (u2)
 19220:                               .iadd (TAN_C11).imul (u2)
 19221:                                 .iadd (TAN_C9).imul (u2)
 19222:                                   .iadd (TAN_C7).imul (u2)
 19223:                                     .iadd (TAN_C5).imul (u2)
 19224:                                       .iadd (TAN_C3).imul (u2)
 19225:                                         .iadd (TAN_C1).imul (u);
 19226:         if (k == 1) {
 19227:           t.negdec (this);  //1-tan(x-pi/4)
 19228:           this.inc ().div (t);  //(1+tan(x-pi/4))/(1-tan(x-pi/4))
 19229:         } else if (k == 2) {
 19230:           this.rcp ().ineg ();  //-1/tan(x-pi/2)
 19231:         } else if (k == 3) {
 19232:           t.inc (this);  //tan(x-3*pi/4)+1
 19233:           this.dec ().div (t);  //(tan(x-3*pi/4)-1)/(tan(x-3*pi/4)+1)
 19234:         }
 19235:         return this.outer ().neg (xf < 0);  //tanは奇関数なのでxの符号を掛ける
 19236:       } else {  //128分割。[90] 350ns
 19237:         if (x.epp >= 16) {  //|x|が大きすぎる
 19238:           EFP c = new EFP ().inner ().cos (x);  //cos(x)
 19239:           return this.sin (x).outer ().div (c);  //sin(x)/cos(x)
 19240:         }
 19241:         int savedFpsr = epbFpsr;
 19242:         this.inner ();
 19243:         if (this == x) {
 19244:           x = new EFP (x);
 19245:         }
 19246:         if (x.epp < -3) {  //|x|<1/8
 19247:           EFP x2 = new EFP ().isqu (x);  //x^2
 19248:           this.imul (TAN8_C21, x2)
 19249:             .iadd (TAN8_C19).imul (x2)
 19250:               .iadd (TAN8_C17).imul (x2)
 19251:                 .iadd (TAN8_C15).imul (x2)
 19252:                   .iadd (TAN8_C13).imul (x2)
 19253:                     .iadd (TAN8_C11).imul (x2)
 19254:                       .iadd (TAN8_C9).imul (x2)
 19255:                         .iadd (TAN8_C7).imul (x2)
 19256:                           .iadd (TAN8_C5).imul (x2)
 19257:                             .iadd (TAN8_C3).imul (x2)
 19258:                               .iadd (TAN8_C1).outer ().mul (x);
 19259:           return this.originLowerUpper (x).correctUnderflow (savedFpsr);
 19260:         }
 19261:         EFP s = new EFP ();
 19262:         EFP t = new EFP ();
 19263:         EFP u = new EFP ().iabs (x);  //|x|
 19264:         EFP u2 = new EFP ();
 19265:         s.iadd (u, TAN7_X).imul (TAN7_Y).trunc ();  //|x|+pi/256をpi/128で割った商
 19266:         //  |x|をpi/128で割った余りを求めるとき|x|がpi/128の整数倍に近いと桁落ちが発生するので倍精度で計算する
 19267:         u.sub (t.imulw (u2, s, TAN7_Z)).sub (u2).sub (t.imul (s, TAN7_ZA));  //|x|をpi/128で割った余り。[-pi/256,pi/256]
 19268:         int k = s.geti () & 127;  //|x|+pi/256をpi/128で割った商の下位7bit
 19269:         u2.isqu (u);  //u^2
 19270:         this.imul (TAN7_C11, u2)
 19271:           .iadd (TAN7_C9).imul (u2)
 19272:             .iadd (TAN7_C7).imul (u2)
 19273:               .iadd (TAN7_C5).imul (u2)
 19274:                 .iadd (TAN7_C3).imul (u2)
 19275:                   .iadd (TAN7_C1).imul (u);
 19276:         if (k != 0) {
 19277:           if (k <= 63) {
 19278:             t = TAN7_T[k];
 19279:             s.imul (this, t).negdec ();
 19280:             this.iadd (t).div (s);  //(tan(x-k*pi/128)+t)/(1-tan(k*pi/128)*t)
 19281:           } else if (k == 64) {
 19282:             this.rcp ().ineg ();  //-1/tan(x-pi/2)
 19283:           } else {
 19284:             t = TAN7_T[128 - k];
 19285:             s.imul (this, t).inc ();
 19286:             this.sub (t).div (s);  //(tan(x-(128-k)*pi/128)-t)/(1+tan((128-k)*pi/128)*t)
 19287:           }
 19288:         }
 19289:         return this.outer ().neg (xf < 0);  //tanは奇関数なのでxの符号を掛ける
 19290:       }
 19291:     }  //efp.tan(EFP)
 19292: 
 19293:     //------------------------------------------------------------------------
 19294:     //x = x.tanh ()
 19295:     //  x=tanh(x)
 19296:     //y = y.tanh (x)
 19297:     //  y=tanh(x)
 19298:     //  双曲線正接 hyperbolic tangent ハイパボリックタンジェント
 19299:     //
 19300:     //  グラフ
 19301:     //    perl -e "use Math::Trig;use Graph;$g=new Graph();$g->grid();$g->func(sub{tanh($_[0])});print$g"
 19302:     //    echo read("../misc/efp.gp");graph(tanh) | gp -q
 19303:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 19304:     //    |                                       |                                       |
 19305:     //    |                                       |                                       |
 19306:     //    |                                       |                                       |
 19307:     //    |                                       |                                       |
 19308:     //    +                                       +                                       +
 19309:     //    |                                       |                                       |
 19310:     //    |                                       |                                       |
 19311:     //    |                                       |                                       |
 19312:     //    |                                       |                                       |
 19313:     //    +                                       +                                       +
 19314:     //    |                                       |                                       |
 19315:     //    |                                       |                                       |
 19316:     //    |                                       |                                       |
 19317:     //    |                                       |                                       |
 19318:     //    +                                       +              **************************
 19319:     //    |                                       |        *******                        |
 19320:     //    |                                       |    *****                              |
 19321:     //    |                                       |  ***                                  |
 19322:     //    |                                       |***                                    |
 19323:     //    +---------+---------+---------+--------***--------+---------+---------+---------+
 19324:     //    |                                    ***|                                       |
 19325:     //    |                                  ***  |                                       |
 19326:     //    |                              *****    |                                       |
 19327:     //    |                        *******        |                                       |
 19328:     //    **************************              +                                       +
 19329:     //    |                                       |                                       |
 19330:     //    |                                       |                                       |
 19331:     //    |                                       |                                       |
 19332:     //    |                                       |                                       |
 19333:     //    +                                       +                                       +
 19334:     //    |                                       |                                       |
 19335:     //    |                                       |                                       |
 19336:     //    |                                       |                                       |
 19337:     //    |                                       |                                       |
 19338:     //    +                                       +                                       +
 19339:     //    |                                       |                                       |
 19340:     //    |                                       |                                       |
 19341:     //    |                                       |                                       |
 19342:     //    |                                       |                                       |
 19343:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 19344:     //
 19345:     //  定義域
 19346:     //    -inf<=x<=inf
 19347:     //
 19348:     //  値域
 19349:     //    -1<=tanh(x)<=1
 19350:     //
 19351:     //  双曲線関数との関係
 19352:     //    tanh(x)=sinh(x)/cosh(x)
 19353:     //
 19354:     //  指数関数との関係
 19355:     //    tanh(x)=(e^x-e^(-x))/(e^x+e^(-x))
 19356:     //           =(e^(2*x)-1)/(e^(2*x)+1)
 19357:     //    1-tanh(x)=2*e^-x/(e^x+e^-x)
 19358:     //
 19359:     //  微分
 19360:     //    df{tanh(x)}=1-tanh(x)^2
 19361:     //               =sech(x)^2
 19362:     //               =1/cosh(x)^2
 19363:     //
 19364:     //  加法定理
 19365:     //    tanh(x+y)=(tanh(x)+tanh(y))/(1+tanh(x)*tanh(y))
 19366:     //
 19367:     //  定義域の制限
 19368:     //    仮数部がLENbitのとき|x|<=atanh(1-2^-LEN)でなければtanh(x)とsgn(x)を区別できない
 19369:     //    92bitならば
 19370:     //    > atanh(1-2^-92);
 19371:     //    32.231343896037456887901293647754723317576611492206
 19372:     //
 19373:     //  変数変換1
 19374:     //    tanh(x+log((c+1)/(c-1))/2)=tanh(x+log((1+1/c)/(1-1/c))/2)
 19375:     //                              =tanh(x+atanh(1/c))
 19376:     //                              =(tanh(x)+tanh(atanh(1/c)))/(1+tanh(x)*tanh(atanh(1/c)))
 19377:     //                              =(tanh(x)+1/c)/(1+tanh(x)*1/c)
 19378:     //                              =(c*tanh(x)+1)/(c+tanh(x))
 19379:     //                              =(c^2+c*tanh(x)-c^2+1)/(c+tanh(x))
 19380:     //                              =c-(c^2-1)/(c+tanh(x))
 19381:     //    tanh(x+1*log((c+1)/(c-1))/2)=(c*tanh(x)+1)/(c+tanh(x))
 19382:     //    tanh(x+2*log((c+1)/(c-1))/2)=(c^2*tanh(x)+2*c+tanh(x))/(c^2+2*c*tanh(x)+1)
 19383:     //    tanh(x+3*log((c+1)/(c-1))/2)=(c^3*tanh(x)+3*c^2+3*c*tanh(x)+1)/(c^3+3*c^2*tanh(x)+3*c+tanh(x))
 19384:     //    tanh(x+4*log((c+1)/(c-1))/2)=(c^4*tanh(x)+4*c^3+6*c^2*tanh(x)+4*c+tanh(x))/(c^4+4*c^3*tanh(x)+6*c^2+4*c*tanh(x)+1)
 19385:     //    tanh(x+5*log((c+1)/(c-1))/2)=(c^5*tanh(x)+5*c^4+10*c^3*tanh(x)+10*c^2+5*c*tanh(x)+1)/(c^5+5*c^4*tanh(x)+10*c^3+10*c^2*tanh(x)+5*c+tanh(x))
 19386:     //    tanh(x+k*log((c+1)/(c-1))/2)は(c+1)^kを二項展開してkと奇偶が同じ項にtanh(x)を掛けたものをkと奇偶が異なる項にtanh(x)を掛けたもので割ったものになっている
 19387:     //    cが定数でkが大きすぎなければすべてのkについてc0+1/(c1+c2*tanh(x))の形に整理して係数をテーブルに列挙しておくことができる
 19388:     //    log((c+1)/(c-1))/2が2の累乗になるようにcを定めれば分割に除算はいらない
 19389:     //    例えば、|x|<=1/4の範囲をチェビシェフ展開する場合、幅が1/2なので
 19390:     //      log((c+1)/(c-1))/2=1/2
 19391:     //      log((c+1)/(c-1))=1
 19392:     //      (c+1)/(c-1)=e
 19393:     //      c=(e+1)/(e-1)
 19394:     //    を使ってテーブルを作ればよい
 19395:     //    しかし、チェビシェフ展開の項数を減らそうとして幅を狭くするとテーブルが巨大化してしまう
 19396:     //    実用的な範囲ではtanh(x)=(e^(2*x)-1)/(e^(2*x)+1)より速くならないかも知れない
 19397:     //
 19398:     //  変数変換2
 19399:     //    tanh(x+k*log((c+1)/(c-1))/2)でk=2^jの式だけテーブルに展開しておいて平行移動の式を動的に作る
 19400:     //    分子と分母を分けておけば除算は最後の1回だけで済む
 19401:     //
 19402:     //  変数変換3
 19403:     //    xの指数部を見て開始範囲を選択する
 19404:     //    テーブルを参照してxが範囲の中央の1/3に含まれているか確認する
 19405:     //    中央の1/3に含まれていない場合は中央の1/3まで平行移動するための式を分子と分母に分けて作る
 19406:     //    xが十分に小さくなるまで繰り返す
 19407:     //    チェビシェフ展開で計算する
 19408:     //    平行移動の式で元の位置に戻す。最後に1回だけ除算が必要になる
 19409:     //
 19410:     //  ローラン級数展開
 19411:     //    tanh(x)=x+x^3/3+2*x^5/15+17*x^7/315+...
 19412:     //           =sum[n=1..inf]{4^n*(4^n-1)*B(2*n)*x^(2*n-1)/(2*n)!}  |x|<pi/2
 19413:     //    f(n,x)=sum(k=1,n,4^k*(4^k-1)*bernreal(2*k)*x^(2*k-1)/(2*k)!)
 19414:     //    echo for(k=1,10,x=eval("4^k*(4^k-1)*bernfrac(2*k)/(2*k)!");print("    //    ",x,"*x^",2*k-1)) | gp -q
 19415:     //    1*x^1
 19416:     //    -1/3*x^3
 19417:     //    2/15*x^5
 19418:     //    -17/315*x^7
 19419:     //    62/2835*x^9
 19420:     //    -1382/155925*x^11
 19421:     //    21844/6081075*x^13
 19422:     //    -929569/638512875*x^15
 19423:     //    6404582/10854718875*x^17
 19424:     //    -443861162/1856156927625*x^19
 19425:     //
 19426:     //  チェビシェフ展開
 19427:     //    0の近くだけチェビシェフ展開を使う
 19428:     //    echo read("../misc/efp.gp");eval("f(x)=tanh(x)");a=-0.25;b=0.25;forstep(n=1,31,2,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
 19429:     //    echo read("../misc/efp.gp");eval("f(x)=tanh(x)");a=-0.125;b=0.125;forstep(n=1,31,2,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
 19430:     //    echo read("../misc/efp.gp");eval("f(x)=tanh(x)");a=-0.0625;b=0.0625;forstep(n=1,31,2,printf("%4d",floor(closeness(f,chebyshev(f,a,b,n),a,b,10000)))) | gp -q
 19431:     //       1   3   5   7   9  11  13  15  17  19  21  23  25  27  29  31
 19432:     //       6  12  19  26  33  40  47  54  61  69  76  83  90  97 105 112
 19433:     //       8  16  25  34  43  52  61  70  79  88  98 107 116 125 134 144
 19434:     //      10  20  31  42  53  64  75  86  97 108 120 131 142 153 164 176
 19435:     //
 19436:     public final EFP tanh () {
 19437:       return this.tanh (this);
 19438:     }  //efp.tanh()
 19439:     public final EFP tanh (EFP x) {
 19440:       int xf = x.flg;
 19441:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 19442:         if (xf << 2 < 0) {  //tanh(±Inf)=±1
 19443:           this.flg = xf & M;
 19444:           this.epp = 0;
 19445:           this.dvl = MSB;
 19446:           this.cvl = 0L;
 19447:         } else {  //tanh(±0)=±0, tanh(NaN)=NaN
 19448:           this.flg = xf;
 19449:         }
 19450:         return this;
 19451:       }
 19452:       //±0,±Inf,NaN以外
 19453:       //  e^xを経由する方法はオーバーフローを発生させずに計算できる範囲が狭いので|x|が大きい場合を分ける必要がある
 19454:       int xe = x.epp;
 19455:       if (xe < -2) {  //|x|<0.25
 19456:         int savedFpsr = epbFpsr;
 19457:         this.inner ();
 19458:         if (this == x) {
 19459:           x = new EFP (x);
 19460:         }
 19461:         EFP x2 = new EFP ().isqu (x);  //x^2
 19462:         this.imul (TANH_C27, x2)
 19463:           .iadd (TANH_C25).imul (x2)
 19464:             .iadd (TANH_C23).imul (x2)
 19465:               .iadd (TANH_C21).imul (x2)
 19466:                 .iadd (TANH_C19).imul (x2)
 19467:                   .iadd (TANH_C17).imul (x2)
 19468:                     .iadd (TANH_C15).imul (x2)
 19469:                       .iadd (TANH_C13).imul (x2)
 19470:                         .iadd (TANH_C11).imul (x2)
 19471:                           .iadd (TANH_C9).imul (x2)
 19472:                             .iadd (TANH_C7).imul (x2)
 19473:                               .iadd (TANH_C5).imul (x2)
 19474:                                 .iadd (TANH_C3).imul (x2)
 19475:                                   .iadd (TANH_C1).outer ().mul (x);
 19476:         return this.originUpperLower (x).correctUnderflow (savedFpsr);
 19477:       }
 19478:       //0.25<=|x|
 19479:       if (false) {
 19480:         EFP c = new EFP ().inner ().cosh (x);  //cosh(x)
 19481:         return this.sinh (x).outer ().div (c);  //sinh(x)/cosh(x) [90]
 19482:       } else if (6 <= xe) {  //2^6<=|x|
 19483:         //  x=2^6のとき
 19484:         //  1-tanh(x)=1-(e^x-e^(-x))/(e^x+e^(-x))
 19485:         //           =2*e^(-x)/(e^x+e^(-x))
 19486:         //  の値は
 19487:         //  echo x=eval("2^6");log(2*exp(-x)/(exp(x)+exp(-x)))/log(2) | gp -q
 19488:         //  -183.66496523378731614207035916824219359
 19489:         //  であるから2^6<=xのときtanh(x)と1を区別できない
 19490:         //  tanh(x)は奇関数なのでx<=-2^6の場合も同様にtanh(x)と-1を区別できない
 19491:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 19492:         this.flg = xf & M;  //±1
 19493:         this.epp = 0;
 19494:         this.dvl = MSB;
 19495:         this.cvl = 0L;
 19496:         if (xf < 0) {
 19497:           if (epbRoundingMode == EPB_MODE_RZ || epbRoundingMode == EPB_MODE_RP) {
 19498:             this.nextup (epbRoundingPrec);
 19499:           }
 19500:         } else {
 19501:           if (epbRoundingMode == EPB_MODE_RZ || epbRoundingMode == EPB_MODE_RM) {
 19502:             this.nextdown (epbRoundingPrec);
 19503:           }
 19504:         }
 19505:         return this;
 19506:       } else {
 19507:         EFP t = new EFP ().inner ().imul2 (x).exp ();  //e^(2*x)
 19508:         this.dec (t);
 19509:         t.inc ();
 19510:         return this.outer ().div (t);  //(e^(2*x)-1)/(e^(2*x)+1) [90]
 19511:       }
 19512:     }  //efp.tanh(EFP)
 19513: 
 19514:     //------------------------------------------------------------------------
 19515:     //x = x.tgamma ()
 19516:     //  x=Γ(x)
 19517:     //y = y.tgamma (x)
 19518:     //  y=Γ(x)
 19519:     //  ガンマ関数
 19520:     //
 19521:     //  グラフ
 19522:     //    echo read("../misc/efp.gp");graph(gamma) | gp -q
 19523:     //    *---------*---------+**----**-+---------+-*-------+---------+---------+-----**--+
 19524:     //    *         *           *    *            | *                                 *   |
 19525:     //    *         *           *    *            | **                               **   |
 19526:     //    *         *           *    *            |  *                               *    |
 19527:     //    *        **           *    *            |  *                              **    |
 19528:     //    *        *            *   **            +  *                              *     +
 19529:     //    *        *            **  *             |  *                             **     |
 19530:     //    *        *             *  *             |  **                           **      |
 19531:     //    *        *             ****             |   *                          **       |
 19532:     //    *        *                              |   *                          *        |
 19533:     //    *        *                              +   **                       ***        +
 19534:     //    *        *                              |    *                      **          |
 19535:     //    *        *                              |    **                    **           |
 19536:     //    *        *                              |     **                 ***            |
 19537:     //    *        *                              |      ***            ****              |
 19538:     //    **      **                              +        *****  *******                 +
 19539:     //    |*      *                               |            ****                       |
 19540:     //    |*     **                               |                                       |
 19541:     //    |**   **                                |                                       |
 19542:     //    | *****                                 |                                       |
 19543:     //    +---------+---------+---------+---------+---------+---------+---------+---------+
 19544:     //    |                                       |                                       |
 19545:     //    |                                       |                                       |
 19546:     //    |                                       |                                       |
 19547:     //    |            **                         |                                       |
 19548:     //    +           *****                       +                                       +
 19549:     //    |           *   **                      |                                       |
 19550:     //    |          **    *                      |                                       |
 19551:     //    |          *     *                      |                                       |
 19552:     //    |          *     **                     |                                       |
 19553:     //    +          *      *                     +                                       +
 19554:     //    |          *      *                     |                                       |
 19555:     //    |          *      *                     |                                       |
 19556:     //    |          *      *                     |                                       |
 19557:     //    |          *      *                     |                                       |
 19558:     //    +          *      **                    +                                       +
 19559:     //    |          *       *                    |                                       |
 19560:     //    |          *       *                    |                                       |
 19561:     //    |         **       *              ***   |                                       |
 19562:     //    |         *        *              * *   |                                       |
 19563:     //    +---------*--------*+---------+--**-**--+---------+---------+---------+---------+
 19564:     //
 19565:     //  Γ(x)=int[t=0..∞]{e^-t*t^(x-1)*dt}
 19566:     //  Γ(n)=(n-1)!
 19567:     //  Γ(n+1)=n!
 19568:     //        =n*Γ(n)
 19569:     //
 19570:     //  x<0のとき
 19571:     //    Γ(x)*Γ(1-x)=π/sin(π*x)
 19572:     //    で1<xにする
 19573:     //    Γ(x)=π/sin(π*x)/Γ(1-x)
 19574:     //        =π/sin(π*x)/e^lgamma(1-x)
 19575:     //
 19576:     //  x==-0のとき
 19577:     //    -∞
 19578:     //
 19579:     //  x==+0のとき
 19580:     //    +∞
 19581:     //
 19582:     //  0<xのとき
 19583:     //    Γ(x)=e^lgamma(x)
 19584:     //
 19585:     public final EFP tgamma () {
 19586:       return this.tgamma (this);
 19587:     }  //efp.tgamma()
 19588:     public final EFP tgamma (EFP x) {
 19589:       int xf = x.flg;
 19590:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 19591:         this.flg = (xf == (P | Z) || xf == (P | I) ? P | I :  //tgamma(+0)=tgamma(+Inf)=+Inf
 19592:                     xf == (M | Z) ? M | I :  //tgamma(-0)=-Inf
 19593:                     N);  //tgamma(NaN)=tgamma(-Inf)=NaN
 19594:         return this;
 19595:       }
 19596:       //±0,±Inf,NaN以外
 19597:       this.inner ();
 19598:       if (xf < 0) {  //x<0
 19599:         EFP t = new EFP ().mul (PI, x).sin ();  //sin(π*x)
 19600:         this.negdec (x).lgamma ().exp ().mul (t).rcpdiv (PI);  //π/(e^lgamma(1-x)*sin(π*x))
 19601:       } else {  //0<x
 19602:         this.lgamma (x).exp ();  //e^lgamma(x)
 19603:       }
 19604:       return this.outer ().finish ();
 19605:     }  //efp.tgamma(EFP)
 19606: 
 19607:     //------------------------------------------------------------------------
 19608:     //s = x.toString ()
 19609:     //  10進数文字列化
 19610:     //
 19611:     //  絶対値が1以上で整数部が有効bit数を表現するのに十分な桁数に収まるとき
 19612:     //    指数部を付けずに出力する
 19613:     //    小数部の末尾の0を省略する
 19614:     //    小数部がすべて省略されたときは小数点も省略する
 19615:     //  絶対値が1未満で整数部の0と小数部を合わせて有効bit数を表現するのに十分な桁数+3桁に収まるとき
 19616:     //    指数部を付けずに出力する
 19617:     //    小数部の末尾の0を省略する
 19618:     //  それ以外
 19619:     //    整数部が1～9の浮動小数点形式で出力する
 19620:     //
 19621:     @Override public String toString () {
 19622:       int xf = this.flg;
 19623:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 19624:         return (xf == (P | Z) ? "0" :
 19625:                 xf == (M | Z) ? "-0" :
 19626:                 xf == (P | I) ? "Infinity" :
 19627:                 xf == (M | I) ? "-Infinity" :
 19628:                 xf << 3 < 0 ? "NaN" : "???");
 19629:       }
 19630:       //±0,±Inf,NaN以外
 19631:       this.inner ();
 19632:       EFP x = new EFP ().iabs (this);  //絶対値
 19633:       //10進数で表現したときの指数部を求める
 19634:       //  10^e<=x<10^(e+1)となるeを求める
 19635:       int e = (int) Math.floor ((double) x.epp * 0.30102999566398119521373889472);  //log10(2)
 19636:       //10^-eを掛けて1<=x<10にする
 19637:       //  非正規化数の最小値から正規化数の最大値まで処理できなければならない
 19638:       //  10^-eを計算してからまとめて掛ける方法は10^-eがオーバーフローするおそれがあるので不可
 19639:       if (0 < e) {  //10<=x
 19640:         x.imul (EFP_TEN_M16QR[e & 15]);
 19641:         if (16 <= e) {
 19642:           x.imul (EFP_TEN_M16QR[16 + (e >> 4 & 15)]);
 19643:           if (256 <= e) {
 19644:             x.imul (EFP_TEN_M16QR[32 + (e >> 8 & 15)]);
 19645:             if (4096 <= e) {
 19646:               x.imul (EFP_TEN_M16QR[48 + (e >> 12)]);
 19647:             }
 19648:           }
 19649:         }
 19650:       } else if (e < 0) {  //x<1
 19651:         x.imul (EFP_TEN_P16QR[-e & 15]);
 19652:         if (e <= -16) {
 19653:           x.imul (EFP_TEN_P16QR[16 + (-e >> 4 & 15)]);
 19654:           if (e <= -256) {
 19655:             x.imul (EFP_TEN_P16QR[32 + (-e >> 8 & 15)]);
 19656:             if (e <= -4096) {
 19657:               x.imul (EFP_TEN_P16QR[48 + (-e >> 12)]);
 19658:             }
 19659:           }
 19660:         }
 19661:       }
 19662:       this.outer ();
 19663:       //整数部2桁、小数部EFP_DECIMAL_PREC+4&-4桁の10進数に変換する
 19664:       //  1<=x<10なのでw[1]が先頭になるはずだが誤差で前後にずれる可能性がある
 19665:       //  小数部を10000倍して整数部を引くことを繰り返すため、桁数に余裕のない浮動小数点数のまま行うと情報落ちが発生して誤差が蓄積する
 19666:       //  固定小数点に切り替えて誤差なしで計算する
 19667:       int[] w = new int[2 + (EFP_DECIMAL_PREC + 4 & -4)];
 19668:       {
 19669:         int t = 31 - x.epp;
 19670:         long x1 = x.dvl >>> t;  //上位32bitが整数部、下位32bitが小数部
 19671:         long x2 = x.dvl << -t | x.cvl >>> t;  //tは誤差を考慮しても最大32、x.cvlは下位32bitが0なのではみ出さない
 19672:         long x3 = x2 & 0xffffffffL;
 19673:         x2 >>>= 32;
 19674:         t = XEiJ.FMT_BCD4[(int) (x1 >>> 32)];  //整数部
 19675:         w[0] = t >>  4;
 19676:         w[1] = t       & 15;
 19677:         for (int i = 2; i < 2 + (EFP_DECIMAL_PREC + 4 & -4); i += 4) {
 19678:           x3 *= 10000L;
 19679:           x2 = x2 * 10000L + (x3 >>> 32);
 19680:           x3 &= 0xffffffffL;
 19681:           x1 = (x1 & 0xffffffffL) * 10000L + (x2 >>> 32);
 19682:           x2 &= 0xffffffffL;
 19683:           t = XEiJ.FMT_BCD4[(int) (x1 >>> 32)];  //整数部
 19684:           w[i    ] = t >> 12;
 19685:           w[i + 1] = t >>  8 & 15;
 19686:           w[i + 2] = t >>  4 & 15;
 19687:           w[i + 3] = t       & 15;
 19688:         }
 19689:       }
 19690:       //先頭の位置を確認する
 19691:       //  w[h]が先頭(0でない最初の数字)の位置
 19692:       int h = w[0] != 0 ? 0 : w[1] != 0 ? 1 : 2;
 19693:       //EFP_DECIMAL_PREC+1桁目を四捨五入する
 19694:       int o = h + EFP_DECIMAL_PREC;  //w[o]は四捨五入する桁の位置。w[]の範囲内
 19695:       if (5 <= w[o]) {
 19696:         int i = o;
 19697:         while (10 <= ++w[--i]) {
 19698:           w[i] = 0;
 19699:         }
 19700:         if (i < h) {  //先頭から繰り上がった。このとき新しい先頭は1でそれ以外はすべて0
 19701:           h--;  //先頭を左にずらす
 19702:           o--;  //末尾を左にずらす
 19703:         }
 19704:       }
 19705:       //先頭の位置に応じて指数部を更新する
 19706:       //  w[h]が整数部、w[h+1..o-1]が小数部。10^eの小数点はw[h]の右側。整数部の桁数はe+1桁
 19707:       e -= h - 1;
 19708:       //末尾の位置を確認する
 19709:       //  w[o-1]が末尾(0でない最後の数字)の位置
 19710:       while (w[o - 1] == 0) {  //全体は0ではないので必ず止まる。小数点よりも左側で止まる場合があることに注意
 19711:         o--;
 19712:       }
 19713:       //文字列に変換する
 19714:       StringBuilder sb = new StringBuilder ();
 19715:       //符号を付ける
 19716:       if (xf < 0) {
 19717:         sb.append ('-');
 19718:       }
 19719:       //指数形式にするかどうか選択する
 19720:       if (0 <= e && e < EFP_DECIMAL_PREC) {  //1<=x<10^EFP_DECIMAL_PREC。指数形式にしない
 19721:         do {
 19722:           sb.append ((char) ('0' + w[h++]));  //整数部。末尾の位置に関係なく1の位まで書く
 19723:         } while (0 <= --e);
 19724:         if (h < o) {  //小数部がある
 19725:           sb.append ('.');  //小数部があるときだけ小数点を書く
 19726:           do {
 19727:             sb.append ((char) ('0' + w[h++]));  //小数部
 19728:           } while (h < o);
 19729:         }
 19730:       } else if (-4 <= e && e < 0) {  //10^-4<=x<1。指数形式にしない
 19731:         sb.append ('0');  //整数部の0
 19732:         sb.append ('.');  //小数点
 19733:         while (++e < 0) {
 19734:           sb.append ('0');  //小数部の先頭の0の並び
 19735:         }
 19736:         do {
 19737:           sb.append ((char) ('0' + w[h++]));  //小数部
 19738:         } while (h < o);
 19739:       } else {  //x<10^-4または10^EFP_DECIMAL_PREC<=x。指数形式にする
 19740:         sb.append ((char) ('0' + w[h++]));  //整数部
 19741:         if (h < o) {  //小数部がある
 19742:           sb.append ('.');  //小数部があるときだけ小数点を書く
 19743:           do {
 19744:             sb.append ((char) ('0' + w[h++]));  //小数部
 19745:           } while (h < o);
 19746:         }
 19747:         sb.append ('e');  //指数部の始まり
 19748:         if (false) {
 19749:           sb.append (e);
 19750:         } else {
 19751:           if (e < 0) {
 19752:             sb.append ('-');  //指数部の負符号
 19753:             e = -e;
 19754:           } else {
 19755:             sb.append ('+');  //指数部の正符号
 19756:           }
 19757:           e = XEiJ.fmtBcd8 (e);
 19758:           int t = Integer.numberOfLeadingZeros (e);
 19759:           if (t <= 27) {
 19760:             if (t <= 23) {
 19761:               if (t <= 19) {
 19762:                 if (t <= 15) {
 19763:                   sb.append ((char) ('0' + (e >>> 16 & 15)));
 19764:                 }
 19765:                 sb.append ((char) ('0' + (e >>> 12 & 15)));
 19766:               }
 19767:               sb.append ((char) ('0' + (e >>>  8 & 15)));
 19768:             }
 19769:             sb.append ((char) ('0' + (e >>>  4 & 15)));
 19770:           }
 19771:           sb.append ((char) ('0' + (e        & 15)));
 19772:         }
 19773:       }
 19774:       return sb.toString ();
 19775:     }  //efp.toString()
 19776: 
 19777:     //------------------------------------------------------------------------
 19778:     //x = x.trunc ()
 19779:     //  x=trunc(x)
 19780:     //y = y.trunc (x)
 19781:     //  y=trunc(x)
 19782:     //  切り落とし truncate
 19783:     //
 19784:     //  グラフ
 19785:     //    perl -e "use Graph;$g=new Graph();$g->grid();$g->func(sub{int($_[0])});print$g"
 19786:     //    echo read("../misc/efp.gp");graph(truncate) | gp -q
 19787:     //    +---------+---------+---------+---------+---------+---------+---------+---------*
 19788:     //    |                                       |                                       |
 19789:     //    |                                       |                                       |
 19790:     //    |                                       |                                       |
 19791:     //    |                                       |                                       |
 19792:     //    +                                       +                             ***********
 19793:     //    |                                       |                                       |
 19794:     //    |                                       |                                       |
 19795:     //    |                                       |                                       |
 19796:     //    |                                       |                                       |
 19797:     //    +                                       +                   ***********         +
 19798:     //    |                                       |                                       |
 19799:     //    |                                       |                                       |
 19800:     //    |                                       |                                       |
 19801:     //    |                                       |                                       |
 19802:     //    +                                       +         ***********                   +
 19803:     //    |                                       |                                       |
 19804:     //    |                                       |                                       |
 19805:     //    |                                       |                                       |
 19806:     //    |                                       |                                       |
 19807:     //    +---------+---------+---------*********************---------+---------+---------+
 19808:     //    |                                       |                                       |
 19809:     //    |                                       |                                       |
 19810:     //    |                                       |                                       |
 19811:     //    |                                       |                                       |
 19812:     //    +                   ***********         +                                       +
 19813:     //    |                                       |                                       |
 19814:     //    |                                       |                                       |
 19815:     //    |                                       |                                       |
 19816:     //    |                                       |                                       |
 19817:     //    +         ***********                   +                                       +
 19818:     //    |                                       |                                       |
 19819:     //    |                                       |                                       |
 19820:     //    |                                       |                                       |
 19821:     //    |                                       |                                       |
 19822:     //    ***********                             +                                       +
 19823:     //    |                                       |                                       |
 19824:     //    |                                       |                                       |
 19825:     //    |                                       |                                       |
 19826:     //    |                                       |                                       |
 19827:     //    *---------+---------+---------+---------+---------+---------+---------+---------+
 19828:     //
 19829:     //    ±0,±Inf,NaN    そのまま
 19830:     //    e<=-1          すべて小数部なので±0
 19831:     //    0<=e&&e<LEN-1  整数部と小数部が両方あるので小数部を消す
 19832:     //    LEN-1<=e       すべて整数部なのでそのまま
 19833:     //
 19834:     public final EFP trunc () {
 19835:       return trunc (this);
 19836:     }  //efp.trunc()
 19837:     public final EFP trunc (EFP x) {  //1.6ns
 19838:       int xf = x.flg;
 19839:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 19840:         this.flg = xf;
 19841:         return this;
 19842:       }
 19843:       //±0,±Inf,NaN以外
 19844:       int xe = x.epp;
 19845:       if (xe < 0) {  //すべて小数部
 19846:         epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 19847:         this.flg = xf | Z;  //±0
 19848:         return this;
 19849:       }
 19850:       long xd = x.dvl;
 19851:       long xc = x.cvl;
 19852:       if (xe <= 63) {  //0..63。dの途中または末尾まで整数部
 19853:         long m = MSB >> xe;  //整数部のマスク。符号に注意
 19854:         if ((xd & ~m | xc) != 0L) {  //小数部が0ではない
 19855:           epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 19856:           xd &= m;  //小数部を切り捨てる
 19857:           xc = 0L;
 19858:         }
 19859:       } else if (xe <= LEN - 2) {  //64..90。cの途中まで整数部
 19860:         long m = MSB >> xe;  //整数部のマスク。符号に注意
 19861:         if ((xc & ~m) != 0L) {  //小数部が0ではない
 19862:           epbFpsr |= EPB_FPSR_X2;  //不正確な結果
 19863:           xc &= m;  //小数部を切り捨てる
 19864:         }
 19865:       }
 19866:       //すべて整数部のときはそのまま
 19867:       return this.finish (xf, xe, xd, xc, 0L);
 19868:     }  //efp.trunc(EFP)
 19869: 
 19870:     //------------------------------------------------------------------------
 19871:     //x = x.ulp ()
 19872:     //  x=ulp(x)
 19873:     //y = y.ulp (x)
 19874:     //  y=ulp(x)
 19875:     //  ulp
 19876:     //
 19877:     //  最下位bitの単位(ulp;unit last place)
 19878:     //  nextup(abs(x))-abs(x)
 19879:     //  ulp(±0)=指数部が最小の値, ulp(±Inf)=±Inf, ulp(NaN)=NaN
 19880:     //
 19881:     public final EFP ulp () {
 19882:       return this.ulp (this);
 19883:     };  //efp.ulp()
 19884:     public final EFP ulp (EFP x) {
 19885:       int xf = x.flg;
 19886:       if (xf << 1 != 0) {  //±0,±Inf,NaN
 19887:         if (xf << 1 < 0) {  //±0
 19888:           this.flg = P;
 19889:           this.epp = -32768;
 19890:           this.dvl = MSB;
 19891:           this.cvl = 0L;
 19892:         } else {
 19893:           this.flg = xf & ~M;
 19894:         }
 19895:         return this;
 19896:       }
 19897:       //±0,±Inf,NaN以外
 19898:       this.flg = P;
 19899:       this.epp = x.epp - (LEN - 1);
 19900:       this.dvl = MSB;
 19901:       this.cvl = 0L;
 19902:       return this;
 19903:     };  //efp.ulp(EFP)
 19904: 
 19905:   }  //class EFP
 19906: 
 19907: 
 19908: 
 19909:   //------------------------------------------------------------------------
 19910:   //コプロセッサインタフェイス
 19911:   //
 19912:   //  CIR(コプロセッサインタフェイスレジスタ)を介して浮動小数点命令を対話形式で実行する
 19913:   //  on-chip FPUとやることは同じだが、命令の中断、保存、復元、再開ができる
 19914:   //  浮動小数点命令をコマンドワードで分類するところまではon-chip FPUと同じ
 19915:   //  そこからさらに命令の処理段階で分類する
 19916:   //
 19917:   //  CPU空間(FC=7)
 19918:   //    0x...0....  Breakpoint Acknowledge
 19919:   //    0x...1....  Access Level Control
 19920:   //    0x...2....  Coprocessor Communications
 19921:   //    0x00020000  id=0
 19922:   //    0x00022000  id=1  MC68881/MC68882
 19923:   //    0x00024000  id=2
 19924:   //    0x00026000  id=3
 19925:   //    0x00028000  id=4
 19926:   //    0x0002a000  id=5
 19927:   //    0x0002c000  id=6
 19928:   //    0x0002e000  id=7
 19929:   //    0x...f....  Interrupt Acknowledge
 19930:   //
 19931:   //  拡張ボード
 19932:   //    0x00e9e000  JP1  数値演算プロセッサボード(CZ-6BP1/CZ-6BP1A)
 19933:   //    0x00e9e080  JP2  数値演算プロセッサボード(CZ-6BP1/CZ-6BP1A)
 19934:   //
 19935:   //  FSAVE
 19936:   //    $04 save CIRから1ワードのフォーマットワードを読み出す
 19937:   //    $01xxが返ったときはカムアゲインなので読み直す
 19938:   //    MC68882のフォーマットワードは$00xx、$1F38、$1FD4のいずれか
 19939:   //      $00xxはヌルステート。xxは無効。ヌルステートフレームのサイズは0バイト
 19940:   //      $1F38はアイドルステート。アイドルステートフレームのサイズは$38=56バイト
 19941:   //      $1FD4はビジーステート。ビジーステートフレームのサイズは$D4=212バイト
 19942:   //    ヌルステートのときはここで終わり
 19943:   //    $10 operand CIRからステートフレームを読み出す
 19944:   //    FSAVEはプレデクリメントが前提なのでロング単位で逆順に読み出される
 19945:   //    スタックにステートフレームをプッシュする
 19946:   //    スタックにフォーマットワード<<16をプッシュする
 19947:   //  FRESTORE
 19948:   //    スタックからフォーマットワード<<16をポップする
 19949:   //    $06 restore CIRにフォーマットワードを書き込む
 19950:   //    $06 restore CIRからフォーマットワードを読み出す
 19951:   //    書き込んだフォーマットワードがそのまま返ればよい。$02xxが返ったときは不正なフォーマットワードなのでここで失敗
 19952:   //    スタックからステートフレームをポップする
 19953:   //    $10 operand CIRにステートフレームを書き込む
 19954:   //    FRESTOREはポストインクリメントが前提なのでロング単位で正順に書き込む
 19955:   //    異常なステートフレームをリストアすると、マニュアルにないレスポンスが返ったり、オペランドCIRのアクセスがプロトコル違反ではなくてバスエラーになったり、かなりおかしなことになる
 19956:   //    $06 restore CIRにヌルステートの$0000を書き込むとリセットされる
 19957:   //    fp0-fp7はすべてNon-signaling NaNになり、FPCRとFPSRはゼロクリアされる
 19958:   //    --------------------------------
 19959:   //    > cir 00 .
 19960:   //    0802 
 19961:   //    > cir 0a 4000               fmove.l <ea>,fp0
 19962:   //    > cir 00 ....
 19963:   //    9504 8900 8900 8900 
 19964:   //    > cir 10 00000001
 19965:   //    > cir 00 ....
 19966:   //    0802 0802 0802 0802 
 19967:   //    > cir 0a 6000               fmove.l fp0,<ea>
 19968:   //    > cir 00 ....
 19969:   //    8900 B104 0802 0802 
 19970:   //    > cir 10 .
 19971:   //    00000001 
 19972:   //    > cir 00 ....
 19973:   //    0802 0802 0802 0802 
 19974:   //    > cir 0a 6000               fmove.l fp0,<ea>
 19975:   //    > cir 04 .                  fsave
 19976:   //    1F38 
 19977:   //    > cir 10 ..............
 19978:   //    3C0EFFFF 00000001 00000000 00000002 FFFF0000 3FFF0000 20000000 00000000 00000000 00000000 00000200 60000000 0F800000 60006000 
 19979:   //    > cir 00 ....
 19980:   //    0802 0802 0802 0802 
 19981:   //    > cir 06 1F38               frestore
 19982:   //    > cir 06 .
 19983:   //    1F38 
 19984:   //    > cir 10 60006000 0F800000 60000000 00000200 00000000 00000000 00000000 20000000 3FFF0000 FFFF0000 00000002 00000000 00000001 3C0EFFFF
 19985:   //    > cir 00 ....
 19986:   //    8900 B104 0802 0802         fmove.l fp0,<ea>の続き
 19987:   //    > cir 10 .
 19988:   //    00000001 
 19989:   //    > cir 00 ....
 19990:   //    0802 0802 0802 0802 
 19991:   //    --------------------------------
 19992: 
 19993:   public static final boolean CIR_DEBUG_TRACE = false;
 19994: 
 19995:   //CIR
 19996:   //    0x00  word  read         response CIR
 19997:   //    0x02  word        write  control CIR
 19998:   //    0x04  word  read         save CIR
 19999:   //    0x06  word  read  write  restore CIR
 20000:   //    0x08  word  read  write  operation word CIR       MC68882のみ。MC68881ではwriteは無視、readは-1
 20001:   //    0x0a  word        write  command CIR
 20002:   //    0x0c  word  read  write  (reserved)               reserved CIRのアクセスはプロトコル違反にならない
 20003:   //    0x0e  word        write  condition CIR
 20004:   //    0x10  long  read  write  operand CIR
 20005:   //    0x14  word  read         register select CIR
 20006:   //    0x16  word  read  write  (reserved)               reserved CIRのアクセスはプロトコル違反にならない
 20007:   //    0x18  long        write  instruction address CIR
 20008:   //    0x1c  long  read  write  operand address CIR      MC68882のみ。MC68881ではwriteは無視、readは-1
 20009:   public int cirResponse;  //0x00 response CIRのレスポンス。上位ワードが0でないとき下位ワードを1回だけ出力して次回から上位ワードを出力する
 20010:   public int cirFormatWord;  //0x02 save CIRのフォーマットワード
 20011:   public int cirOperationWord;  //0x08 operation word CIR
 20012:   public int cirCommand;  //0x0a command CIR
 20013:   public int cirRegisterList;  //0x14 register select CIRの上位バイト
 20014:   public int cirOperandAddress;  //0x1c operand address CIR
 20015: 
 20016:   //オペランド
 20017:   public final int[] cirOperandBuffer = new int[212];  //ロング単位のオペランドバッファ
 20018:   public int cirOperandLength;  //転送中のオペランドのロング数
 20019:   public int cirOperandIndex;  //転送中のオペランドの次に転送するロング位置
 20020: 
 20021:   //命令の処理段階
 20022:   //  MC68882はデスティネーションオペランドの転送が終わる前にレスポンスプリミティブが0x0802になって次のコマンドを受け付けることができる
 20023:   //  ここではデスティネーションオペランドの転送が終わるまで次のコマンドを受け付けないことにする
 20024:   //  オペランドバッファは転送する直前に構築すること
 20025:   //    オペランドバッファを使わない段階ではFSAVEでオペランドバッファを保存しない
 20026:   public static final int CIR_INPUT_MASK            =                   16;  //オペランドバッファへ入力中
 20027:   public static final int CIR_OUTPUT_MASK           =                   32;  //オペランドバッファから出力中
 20028:   public static final int CIR_IDLE                  =                    0;  //アイドル
 20029:   public static final int CIR_PROGRAM_COUNTER       =                    1;  //プログラムカウンタをinstruction address CIRへ入力中
 20030:   public static final int CIR_DYNAMIC_K_FACTOR      = CIR_INPUT_MASK  |  2;  //動的k-factorをoperand CIRへ入力中
 20031:   public static final int CIR_DYNAMIC_REGISTER_LIST = CIR_INPUT_MASK  |  3;  //動的レジスタリストをoperand CIRへ入力中
 20032:   public static final int CIR_REGISTER_SELECT       =                    4;  //レジスタセレクトをregister select CIRから出力中
 20033:   public static final int CIR_SOURCE_OPERAND        = CIR_INPUT_MASK  |  5;  //ソースオペランドをoperand CIRへ入力中
 20034:   public static final int CIR_DESTINATION_OPERAND   = CIR_OUTPUT_MASK |  6;  //デスティネーションオペランドをoperand CIRから出力中
 20035:   public static final int CIR_FSAVE_STATE_FRAME     = CIR_OUTPUT_MASK |  7;  //FSAVEのステートフレームをoperand CIRから出力中
 20036:   public static final int CIR_FRESTORE_STATE_FRAME  = CIR_INPUT_MASK  |  8;  //FRESTOREのステートフレームをoperand CIRへ入力中
 20037:   public static final int CIR_EXCEPTION_PROCESSING  =                    9;  //例外処理中
 20038:   public static final String[] cirNameOfStage = {
 20039:     "idle",  //0
 20040:     "input program counter into the instruction address CIR",  //1
 20041:     "input dynamic k-factor into the operand CIR",  //2
 20042:     "input dynamic register list into the operand CIR",  //3
 20043:     "output register select from the register select CIR",  //4
 20044:     "input source operand into the operand CIR",  //5
 20045:     "output destination operand from the operand CIR",  //6
 20046:     "output FSAVE state frame from the operand CIR",  //7
 20047:     "input FRESTORE state from into the operand CIR",  //8
 20048:     "exception processing",  //9
 20049:   };
 20050:   public int cirStage;
 20051: 
 20052:   //cirInit ()
 20053:   //  初期化
 20054:   public final void cirInit () {
 20055:     //cirOperandBuffer = new int[212];
 20056:     Arrays.fill (cirOperandBuffer, 0);
 20057:     cirReset ();
 20058:   }  //cirInit()
 20059: 
 20060:   //cirReset ()
 20061:   //  リセット
 20062:   public final void cirReset () {
 20063:     cirIdle (0x0802);
 20064:   }  //cirReset()
 20065: 
 20066:   //cirIdle ()
 20067:   //  アイドルに戻す
 20068:   public final void cirIdle (int response) {
 20069:     if (CIR_DEBUG_TRACE) {
 20070:       System.out.printf ("%08x cirIdle(0x%08x)\n", XEiJ.regPC0, response);
 20071:     }
 20072:     cirResponse = response;
 20073:     cirOperationWord = 0;
 20074:     cirCommand = 0;
 20075:     cirRegisterList = 0;
 20076:     cirOperandAddress = 0;
 20077:     Arrays.fill (cirOperandBuffer, 0);
 20078:     cirOperandLength = 0;
 20079:     cirOperandIndex = 0;
 20080:     cirStage = CIR_IDLE;
 20081:   }  //cirIdle(int)
 20082: 
 20083:   //cirException (response)
 20084:   //  例外発生
 20085:   //  プロトコル違反以外はsave CIRをリードしてアイドルステートフレームを保存するとヌルプリミティブに戻る
 20086:   //  プロトコル違反はcontrol CIRに書き込んで復帰させる
 20087:   //  response CIRに$0000を書き込む方法でも復帰できる
 20088:   //    --------------------------------
 20089:   //    オペランドエラーは次のコマンドをフェッチしたとき発生する
 20090:   //    > cir 00 .
 20091:   //    0802 
 20092:   //    > cir 0a 9800
 20093:   //    > cir 00 ....
 20094:   //    8900 9608 8900 8900 
 20095:   //    > cir 10 00002000 00000000
 20096:   //    > cir 00 ..
 20097:   //    0802 0802 
 20098:   //    > cir 0a 4000
 20099:   //    > cir 00 ..
 20100:   //    D504 8900 
 20101:   //    > cir 18 00000000
 20102:   //    > cir 00 ..
 20103:   //    8900 8900 
 20104:   //    > cir 10 00000000
 20105:   //    > cir 00 ..
 20106:   //    0802 0802 
 20107:   //    > cir 0a 4020
 20108:   //    > cir 00 ..
 20109:   //    D504 8900 
 20110:   //    > cir 18 00000000
 20111:   //    > cir 00 ..
 20112:   //    8900 8900 
 20113:   //    > cir 10 00000000
 20114:   //    > cir 00 .
 20115:   //    0802 
 20116:   //    > cir 00 .
 20117:   //    0802 
 20118:   //    > cir 00 .
 20119:   //    0802 
 20120:   //    > cir 0a 0000
 20121:   //    > cir 00 .
 20122:   //    1C34 
 20123:   //    > cir 06 0000
 20124:   //    > cir 00 ..
 20125:   //    0802 0802 
 20126:   //    --------------------------------
 20127:   //    ゼロ除算は次のコマンドをフェッチしたとき発生する
 20128:   //    fmovem.l #$00000400,#$00000000,fpcr/fpsr
 20129:   //    fmove.l #1,fp0
 20130:   //    fdiv.l #0,fp0
 20131:   //    fmove.x fp0,fp0
 20132:   //    > cir 00 .
 20133:   //    0802 
 20134:   //    > cir 0a 9800
 20135:   //    > cir 00 ....
 20136:   //    8900 9608 8900 8900 
 20137:   //    > cir 10 00000400 00000000
 20138:   //    > cir 00 ..
 20139:   //    0802 0802 
 20140:   //    > cir 0a 4000
 20141:   //    > cir 00 ..
 20142:   //    D504 8900 
 20143:   //    > cir 18 00000000
 20144:   //    > cir 00 ..
 20145:   //    8900 8900 
 20146:   //    > cir 10 00000001
 20147:   //    > cir 00 ..
 20148:   //    0802 0802 
 20149:   //    > cir 0a 4020
 20150:   //    > cir 00 ..
 20151:   //    D504 8900 
 20152:   //    > cir 18 00000000
 20153:   //    > cir 00 ..
 20154:   //    8900 8900 
 20155:   //    > cir 10 00000000
 20156:   //    > cir 00 .
 20157:   //    0802 
 20158:   //    > cir 00 .
 20159:   //    0802 
 20160:   //    > cir 00 .
 20161:   //    0802 
 20162:   //    > cir 0a 0000
 20163:   //    > cir 00 .
 20164:   //    1C32 
 20165:   //    > cir 06 0000
 20166:   //    > cir 00 ..
 20167:   //    0802 0802 
 20168:   //    --------------------------------
 20169:   //    プロトコル違反はFSAVEで復帰できない
 20170:   //    > cir 00 .
 20171:   //    0802 
 20172:   //    > cir 10 .
 20173:   //    9800FFFF 
 20174:   //    > cir 00 .
 20175:   //    1D0D 
 20176:   //    > cir 04 .
 20177:   //    0038 
 20178:   //    > cir 00 .
 20179:   //    1D0D 
 20180:   //    > cir 10 .
 20181:   //    9800FFFF 
 20182:   //    > cir 04 .
 20183:   //    0038 
 20184:   //    > cir 06 0000
 20185:   //    > cir 00 .
 20186:   //    0802 
 20187:   //    --------------------------------
 20188:   //    オペランドエラーはFSAVEで復帰できる
 20189:   //    fmovem.l #$00002000,#$00000000,fpcr/fpsr
 20190:   //    fmove.l #0,fp0
 20191:   //    fdiv.l fp0,fp0
 20192:   //    fmove.x fp0,fp0
 20193:   //    > cir 00 .
 20194:   //    0802 
 20195:   //    > cir 0a 9800
 20196:   //    > cir 00 ....
 20197:   //    8900 9608 8900 8900 
 20198:   //    > cir 10 00002000 00000000
 20199:   //    > cir 00 ..
 20200:   //    0802 0802 
 20201:   //    > cir 0a 4000
 20202:   //    > cir 00 ..
 20203:   //    D504 8900 
 20204:   //    > cir 18 00000000
 20205:   //    > cir 00 ..
 20206:   //    8900 8900 
 20207:   //    > cir 10 00000000
 20208:   //    > cir 00 ..
 20209:   //    0802 0802 
 20210:   //    > cir 0a 0020
 20211:   //    > cir 00 ..
 20212:   //    4900 8900 
 20213:   //    > cir 18 00000000
 20214:   //    > cir 00 ..
 20215:   //    0802 0802 
 20216:   //    > cir 0a 0000
 20217:   //    > cir 00 ..
 20218:   //    1C34 1C34 
 20219:   //    > cir 04 .
 20220:   //    1F38 
 20221:   //    > cir 00 ..
 20222:   //    1C34 1C34 
 20223:   //    > cir 10 ..............
 20224:   //    340EFFFF 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 0F000000 00200000 4F800000 00000020 
 20225:   //    > cir 00 ..
 20226:   //    0802 0802 
 20227:   //    > cir 04 .
 20228:   //    1F38 
 20229:   //    > cir 10 ..............
 20230:   //    7C0EFFFF 00000020 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 0F000000 00200000 00000000 00000020 
 20231:   //    > cir 00 ..
 20232:   //    0802 0802 
 20233:   //    --------------------------------
 20234:   //    FRESTOREに失敗したら$B704というマニュアルに書かれていないレスポンスプリミティブが出てきた
 20235:   //    > cir 00 .
 20236:   //    0802 
 20237:   //    > cir 0a 4000
 20238:   //    > cir 00 ....
 20239:   //    9504 8900 8900 8900 
 20240:   //    > cir 04 .
 20241:   //    1FD4 
 20242:   //    > cir 10 .....................................................
 20243:   //    4C0CFFFF 00000020 40000840 4FFFC000 40000000 3F800000 12C00000 12C00000 12C00000 12C00000 12C00000 00000800 00000000 00000000 00000000 00080000 00000000 00000000 0FFFC000 00000000 00000000 3243F6A8 885A308D 30000000 00080000 00000000 00000000 00010000 4FFFC000 3FFFFFFF FFFFFFFF C0000000 40034000 3D5C0000 00000000 00000000 BFFF4000 3243F6A8 885A308D 40000000 30000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 0F000000 40000000 0F800000 4000FFFF 
 20244:   //    > cir 00 ..
 20245:   //    0802 0802 
 20246:   //    > cir 0a 4080
 20247:   //    > cir 00 ....
 20248:   //    9504 8900 8900 8900 
 20249:   //    > cir 10 00000081
 20250:   //    > cir 00 ..
 20251:   //    0802 0802 
 20252:   //    > cir 06 1FD4
 20253:   //    > cir 00 ..
 20254:   //    0900 0900 
 20255:   //    > cir 10 4C0CFFFF 00000020 40000840 4FFFC000 40000000 3F800000 12C00000 12C00000 12C00000 12C00000 12C00000 00000800 00000000 00000000 00000000 00080000 00000000 00000000 0FFFC000 00000000 00000000 3243F6A8 885A308D 30000000 00080000 00000000 00000000 00010000 4FFFC000 3FFFFFFF FFFFFFFF C0000000 40034000 3D5C0000 00000000 00000000 BFFF4000 3243F6A8 885A308D 40000000 30000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 0F000000 40000000 0F800000 4000FFFF
 20256:   //    > cir 00 ..
 20257:   //    0900 0900 
 20258:   //    > cir 10 00000000
 20259:   //    > cir 00 ..
 20260:   //    0900 0900 
 20261:   //    > cir 10 00000000
 20262:   //    > cir 00 ..
 20263:   //    0900 0900 
 20264:   //    > cir 10 0 0 0 0 0 0 0 0 0 0
 20265:   //    > cir 00 ..
 20266:   //    0900 0900 
 20267:   //    > cir 10 0 0 0 0 0 0 0 0 0 0
 20268:   //    > cir 00 ..
 20269:   //    0900 0900 
 20270:   //    > cir 10 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 20271:   //    ここでバスエラーが出た
 20272:   //    > cir 00 ..
 20273:   //    B704 8900 
 20274:   //    --------------------------------
 20275:   public void cirException (int response) {
 20276:     if (CIR_DEBUG_TRACE) {
 20277:       System.out.printf ("%08x cirException(0x%08x)\n", XEiJ.regPC0, response);
 20278:     }
 20279:     cirResponse = response;
 20280:     cirOperationWord = 0;
 20281:     cirCommand = 0;
 20282:     cirRegisterList = 0;
 20283:     cirOperandAddress = 0;
 20284:     Arrays.fill (cirOperandBuffer, 0);
 20285:     cirOperandLength = 0;
 20286:     cirOperandIndex = 0;
 20287:     cirStage = CIR_EXCEPTION_PROCESSING;
 20288:   }  //cirException(int)
 20289: 
 20290:   //d = cirPeekByteZero (a)
 20291:   //  ピークバイトゼロ拡張
 20292:   public int cirPeekByteZero (int a) {
 20293:     return (a & 1) == 0 ? cirPeekWordZero (a) >>> 8 : cirPeekWordZero (a - 1) & 255;
 20294:   }  //cirPeekByteZero(int)
 20295: 
 20296:   //d = cirPeekWordZero (a)
 20297:   //  ピークワードゼロ拡張
 20298:   public int cirPeekWordZero (int a) {
 20299:     a &= 0x1e;  //bit0は無視される
 20300:     int d = 65535;
 20301:     switch (a) {
 20302:     case 0x00:  //response
 20303:       d = (char) cirResponse;  //下位ワードを出力する
 20304:       break;
 20305:       //case 0x02:  //control
 20306:     case 0x04:  //save
 20307:       if ((cirStage == CIR_EXCEPTION_PROCESSING && cirResponse == 0x1d0d) ||  //プロトコル違反はFSAVEで復帰できない
 20308:           cirStage == CIR_FSAVE_STATE_FRAME ||
 20309:           cirStage == CIR_FRESTORE_STATE_FRAME) {  //FSAVE/FRESTOREの動作中はFSAVE/FRESTOREできない
 20310:         d = 0x0200;
 20311:         //プロトコル違反
 20312:       } else {
 20313:         if ((cirStage & (CIR_INPUT_MASK | CIR_OUTPUT_MASK)) == 0) {  //オペランドバッファを使わない段階
 20314:           d = 0x1f38;  //アイドルステート。0x38/4=56バイト/4=14ロング
 20315:         } else {  //オペランドバッファを使う段階
 20316:           d = 0x1fd4;  //ビジーステート。0xd4/4=212バイト/4=53ロング
 20317:         }
 20318:       }
 20319:       break;
 20320:     case 0x06:  //restore
 20321:       d = (char) cirFormatWord;
 20322:       break;
 20323:     case 0x08:  //operation word
 20324:       d = (char) cirOperationWord;
 20325:       break;
 20326:       //case 0x0a:  //command
 20327:       //case 0x0c:  //(reserved)
 20328:       //reserved CIRのアクセスはプロトコル違反にならない
 20329:       //case 0x0e:  //condition
 20330:     case 0x10 + 0:  //operand CIRの上位ワード
 20331:       //fmove.w fp0,<ea>で使う
 20332:       d = cirPeekLong (a) >>> 16;
 20333:       break;
 20334:     case 0x10 + 2:  //operand CIRの下位ワード
 20335:       d = (char) cirPeekLong (a + 2);
 20336:       break;
 20337:     case 0x14:  //register select
 20338:       if (cirStage == CIR_REGISTER_SELECT) {
 20339:         //  複数レジスタ転送プリミティブの直後に1回だけ有効
 20340:         //  上位バイトにレジスタリストが示される
 20341:         //  MPUは1の数を数えて転送するデータの長さを確定する
 20342:         //  ビットの並び順(どのデータがどのレジスタに格納されるか)はMPUが把握する必要はない
 20343:         d = cirRegisterList << 8;
 20344:       } else {
 20345:         //プロトコル違反
 20346:       }
 20347:       break;
 20348:       //case 0x16:  //(reserved)
 20349:       //reserved CIRのアクセスはプロトコル違反にならない
 20350:       //case 0x18:  //instruction address
 20351:       //case 0x1c:  //operand address
 20352:     case 0x1c + 0:  //operand address CIRの上位ワード
 20353:       d = cirPeekLong (a) >>> 16;
 20354:       break;
 20355:     case 0x1c + 2:  //operand address CIRの下位ワード
 20356:       d = (char) cirPeekLong (a - 2);
 20357:       break;
 20358:     }
 20359:     return d;
 20360:   }  //cirPeekWordZero(int)
 20361: 
 20362:   //d = cirPeekLong (a)
 20363:   //  ピークロング
 20364:   public int cirPeekLong (int a) {
 20365:     a &= 0x1e;  //bit0は無視される
 20366:     int d = -1;
 20367:     switch (a) {
 20368:       //case 0x00:  //response
 20369:       //case 0x02:  //control
 20370:       //case 0x04:  //save
 20371:       //case 0x06:  //restore
 20372:       //case 0x08:  //operation word
 20373:       //case 0x0a:  //command
 20374:       //case 0x0c:  //(reserved)
 20375:       //reserved CIRのアクセスはプロトコル違反にならない
 20376:       //case 0x0e:  //condition
 20377:     case 0x10:  //operand
 20378:       if (cirStage == CIR_DESTINATION_OPERAND && cirOperandIndex < cirOperandLength) {  //デスティネーションオペランドの出力中
 20379:         d = cirOperandBuffer[cirOperandIndex];
 20380:       } else if (cirStage == CIR_FSAVE_STATE_FRAME && cirOperandIndex < cirOperandLength) {  //FSAVEのステートフレームの出力中
 20381:         d = cirOperandBuffer[cirOperandLength - cirOperandIndex - 1];  //FSAVEのステートフレームはロング単位で逆順に出力する
 20382:       } else {  //オペランドが準備されていないのに読み出そうとした
 20383:         //!!! プロトコル違反のとき最後に出力した値が返る
 20384:         //プロトコル違反
 20385:       }
 20386:       break;
 20387:       //case 0x14:  //register select
 20388:       //case 0x16:  //(reserved)
 20389:       //reserved CIRのアクセスはプロトコル違反にならない
 20390:       //case 0x18:  //instruction address
 20391:     case 0x1c:  //operand address
 20392:       d = cirOperandAddress;
 20393:       break;
 20394:     }
 20395:     return d;
 20396:   }  //cirPeekLong(int)
 20397: 
 20398:   //d = cirReadByteZero (a)
 20399:   //  リードバイトゼロ拡張
 20400:   public int cirReadByteZero (int a) {
 20401:     //リードすると状態が変化してしまうので半分だけリードできてもあまり意味がない
 20402:     return (a & 1) == 0 ? cirReadWordZero (a) >>> 8 : cirReadWordZero (a - 1) & 255;
 20403:   }  //cirReadByteZero(int)
 20404: 
 20405:   //d = cirReadWordZero (a)
 20406:   //  リードワードゼロ拡張
 20407:   public int cirReadWordZero (int a) {
 20408:     a &= 0x1e;  //bit0は無視される
 20409:     int d = 65535;
 20410:     switch (a) {
 20411:     case 0x00:  //response
 20412:       d = (char) cirResponse;  //下位ワードを出力する
 20413:       if (d != cirResponse) {  //上位ワードが0でないとき
 20414:         cirResponse >>>= 16;  //次回から上位ワードを出力する
 20415:         if (d == 0x0802) {  //null
 20416:           cirIdle (0x0802);
 20417:         }
 20418:       }
 20419:       break;
 20420:       //case 0x02:  //control
 20421:     case 0x04:  //save
 20422:       if ((cirStage == CIR_EXCEPTION_PROCESSING && cirResponse == 0x1d0d) ||  //プロトコル違反はFSAVEで復帰できない
 20423:           cirStage == CIR_FSAVE_STATE_FRAME ||
 20424:           cirStage == CIR_FRESTORE_STATE_FRAME) {  //FSAVE/FRESTOREの動作中はFSAVE/FRESTOREできない
 20425:         d = 0x0200;
 20426:         cirException (0x1d0d);  //プロトコル違反
 20427:       } else {
 20428:         int i;
 20429:         if ((cirStage & (CIR_INPUT_MASK | CIR_OUTPUT_MASK)) == 0) {  //オペランドバッファを使わない段階
 20430:           d = 0x1f38;  //アイドルステート。0x38/4=56バイト/4=14ロング
 20431:           i = 0;
 20432:         } else {  //オペランドバッファを使う段階
 20433:           d = 0x1fd4;  //ビジーステート。0xd4/4=212バイト/4=53ロング
 20434:           i = 3 * 8;  //オペランドが12バイト*8/4=24ロングあるのでその後
 20435:         }
 20436:         //FSAVEとFRESTOREのステートフレームの構造が同じになるように注意すること
 20437:         cirOperandBuffer[i++] = epbFpcr;
 20438:         cirOperandBuffer[i++] = epbFpsr;
 20439:         cirOperandBuffer[i++] = epbFpiar;
 20440:         cirOperandBuffer[i++] = epbQuotient;
 20441:         cirOperandBuffer[i++] = epbRoundingPrec;
 20442:         cirOperandBuffer[i++] = epbRoundingMode;
 20443:         cirOperandBuffer[i++] = cirResponse;
 20444:         cirOperandBuffer[i++] = cirFormatWord;
 20445:         cirOperandBuffer[i++] = cirOperationWord;
 20446:         cirOperandBuffer[i++] = cirCommand;
 20447:         cirOperandBuffer[i++] = cirRegisterList;
 20448:         cirOperandBuffer[i++] = cirOperandAddress;
 20449:         cirOperandBuffer[i++] = cirOperandLength;
 20450:         cirOperandBuffer[i++] = cirOperandIndex;
 20451:         cirOperandBuffer[i++] = cirStage;
 20452:         cirFormatWord = d;
 20453:         cirOperandLength = (d & 255) >>> 2;
 20454:         cirOperandIndex = 0;
 20455:         cirStage = CIR_FSAVE_STATE_FRAME;
 20456:         cirResponse = 0x0900;
 20457:       }
 20458:       break;
 20459:     case 0x06:  //restore
 20460:       d = (char) cirFormatWord;
 20461:       break;
 20462:     case 0x08:  //operation word
 20463:       d = (char) cirOperationWord;
 20464:       break;
 20465:       //case 0x0a:  //command
 20466:       //case 0x0c:  //(reserved)
 20467:       //reserved CIRのアクセスはプロトコル違反にならない
 20468:       //case 0x0e:  //condition
 20469:     case 0x10 + 0:  //operand CIRの上位ワード
 20470:       //fmove.w fp0,<ea>で使う
 20471:       d = cirReadLong (a) >>> 16;
 20472:       break;
 20473:     case 0x10 + 2:  //operand CIRの下位ワード
 20474:       d = (char) cirReadLong (a + 2);
 20475:       break;
 20476:     case 0x14:  //register select
 20477:       if (cirStage == CIR_REGISTER_SELECT) {
 20478:         //  複数レジスタ転送プリミティブの直後に1回だけ有効
 20479:         //  上位バイトにレジスタリストが示される
 20480:         //  MPUは1の数を数えて転送するデータの長さを確定する
 20481:         //  ビットの並び順(どのデータがどのレジスタに格納されるか)はMPUが把握する必要はない
 20482:         d = cirRegisterList << 8;
 20483:         cirGen ();
 20484:       } else {
 20485:         cirException (0x1d0d);  //プロトコル違反
 20486:       }
 20487:       break;
 20488:       //case 0x16:  //(reserved)
 20489:       //reserved CIRのアクセスはプロトコル違反にならない
 20490:       //case 0x18:  //instruction address
 20491:       //case 0x1c:  //operand address
 20492:     case 0x1c + 0:  //operand address CIRの上位ワード
 20493:       d = cirReadLong (a) >>> 16;
 20494:       break;
 20495:     case 0x1c + 2:  //operand address CIRの下位ワード
 20496:       d = (char) cirReadLong (a - 2);
 20497:       break;
 20498:     }
 20499:     if (CIR_DEBUG_TRACE) {
 20500:       System.out.printf ("%08x cirReadWordZero(0x%08x,0x%04x)\n", XEiJ.regPC0, a, d);
 20501:     }
 20502:     return d;
 20503:   }  //cirReadWordZero(int)
 20504: 
 20505:   //d = cirReadLong (a)
 20506:   //  リードロング
 20507:   public int cirReadLong (int a) {
 20508:     a &= 0x1e;  //bit0は無視される
 20509:     int d = -1;
 20510:     switch (a) {
 20511:       //case 0x00:  //response
 20512:       //case 0x02:  //control
 20513:       //case 0x04:  //save
 20514:       //case 0x06:  //restore
 20515:       //case 0x08:  //operation word
 20516:       //case 0x0a:  //command
 20517:       //case 0x0c:  //(reserved)
 20518:       //reserved CIRのアクセスはプロトコル違反にならない
 20519:       //case 0x0e:  //condition
 20520:     case 0x10:  //operand
 20521:       if (cirStage == CIR_DESTINATION_OPERAND && cirOperandIndex < cirOperandLength) {  //デスティネーションオペランドの出力中
 20522:         d = cirOperandBuffer[cirOperandIndex];
 20523:         cirOperandIndex++;
 20524:         if (cirOperandIndex == cirOperandLength) {  //転送終了
 20525:           cirGen ();
 20526:         }
 20527:       } else if (cirStage == CIR_FSAVE_STATE_FRAME && cirOperandIndex < cirOperandLength) {  //FSAVEのステートフレームの出力中
 20528:         d = cirOperandBuffer[cirOperandLength - cirOperandIndex - 1];  //FSAVEのステートフレームはロング単位で逆順に出力する
 20529:         cirOperandIndex++;
 20530:         if (cirOperandIndex == cirOperandLength) {  //転送終了
 20531:           cirIdle (0x0802);
 20532:         }
 20533:       } else {  //オペランドが準備されていないのに読み出そうとした
 20534:         //!!! プロトコル違反のとき最後に出力した値が返る
 20535:         cirException (0x1d0d);  //プロトコル違反
 20536:       }
 20537:       break;
 20538:       //case 0x14:  //register select
 20539:       //case 0x16:  //(reserved)
 20540:       //reserved CIRのアクセスはプロトコル違反にならない
 20541:       //case 0x18:  //instruction address
 20542:       //case 0x1c:  //operand address
 20543:     case 0x1c:  //operand address
 20544:       d = cirOperandAddress;
 20545:       break;
 20546:     }
 20547:     if (CIR_DEBUG_TRACE) {
 20548:       System.out.printf ("%08x cirReadLong(0x%08x,0x%08x)\n", XEiJ.regPC0, a, d);
 20549:     }
 20550:     return d;
 20551:   }  //cirReadLong(int)
 20552: 
 20553:   //cirWriteByte (a, d)
 20554:   //  ライトバイト
 20555:   public void cirWriteByte (int a, int d) {
 20556:   }  //cirWriteByte(int,int)
 20557: 
 20558:   //cirWriteWord (a, d)
 20559:   //  ライドワード
 20560:   public void cirWriteWord (int a, int d) {
 20561:     if (CIR_DEBUG_TRACE) {
 20562:       System.out.printf ("%08x cirWriteWordZero(0x%08x,0x%04x)\n", XEiJ.regPC0, a, d);
 20563:     }
 20564:     d &= 65535;
 20565:     switch (a & 0x1e) {  //bit0は無視される
 20566:       //case 0x00:  //response
 20567:     case 0x02:  //control
 20568:       //MC68881はデータに関係なくアボート
 20569:       //MC68882はbit0(AB abort)に1を書き込むとアボート、bit1(XA exception acknowledge)に1を書き込むと例外クリア
 20570:       //ここでは例外が発生していればデータに関係なく例外クリア、さもなくばbit0に1を書き込んだときアボートとする
 20571:       if (cirStage == CIR_EXCEPTION_PROCESSING) {  //例外が発生している
 20572:         cirIdle (0x0802);  //例外クリア
 20573:         return;
 20574:       } else if ((d & 1) != 0) {  //bit0に1を書き込んだ
 20575:         cirIdle (0x0802);  //アボート
 20576:         return;
 20577:       }
 20578:       break;
 20579:       //case 0x04:  //save
 20580:     case 0x06:  //restore
 20581:       if (d >>> 8 == 0) {  //ヌルステート
 20582:         cirFormatWord = d;
 20583:         //fp0-fp7はすべてNon-signaling NaNになる
 20584:         for (int n = 0; n < 8; n++) {
 20585:           epbFPn[n].setnan ();
 20586:         }
 20587:         //FPCRとFPSRはゼロクリアされる
 20588:         epbFpcr = 0;
 20589:         epbFpsr = 0;
 20590:         cirIdle (0x0802);
 20591:       } else if (d == 0x1f38 || d == 0x1fd4) {
 20592:         cirFormatWord = d;
 20593:         cirOperandLength = (d & 255) >>> 2;
 20594:         cirOperandIndex = 0;
 20595:         cirStage = CIR_FRESTORE_STATE_FRAME;
 20596:         cirResponse = 0x0900;
 20597:       } else {
 20598:         cirFormatWord = 0x0200;
 20599:       }
 20600:       return;
 20601:     case 0x08:  //operation word
 20602:       //MC68881のときwriteは無視、readは-1
 20603:       //MC68882のときF-line命令を書き込む。FPCPは使わない
 20604:       cirOperationWord = d;
 20605:       return;
 20606:     case 0x0a:  //command
 20607:       if (cirStage == CIR_IDLE) {
 20608:         cirCommand = d;
 20609:         cirGen ();
 20610:         return;
 20611:       }
 20612:       break;
 20613:     case 0x0c:  //(reserved)
 20614:       //reserved CIRのアクセスはプロトコル違反にならない
 20615:       return;
 20616:     case 0x0e:  //condition
 20617:       //!!! 命令の実行中に条件判断を要求されたときは命令の処理が終わってから条件判断を行う
 20618:       if (cirStage == CIR_IDLE) {
 20619:         d &= 0x3f;
 20620:         if ((d & 0x20) != 0 && (epbFpsr & XEiJ.FPU_FPSR_NAN) != 0) {  //IEEEノンアウェアテストでNANがセットされているとき
 20621:           epbFpsr |= XEiJ.FPU_FPSR_EXC_BSUN;  //BSUNをセット
 20622:           epbFpsr |= XEiJ.FPU_FPSR_EXC_TO_AEXC[epbFpsr >> 8 & 255];
 20623:           if ((epbFpcr & XEiJ.FPU_FPCR_BSUN) != 0) {  //BSUN例外許可
 20624:             cirException (0x5c30);  //BSUN
 20625:             return;
 20626:           }
 20627:         }
 20628:         cirResponse = XEiJ.FPU_CCMAP_882[d << 4 | epbFpsr >> 24 & 15] ? 0x0802_0801 : 0x0802_0800;
 20629:         return;
 20630:       }
 20631:       break;
 20632:       //case 0x10:  //operand
 20633:       //case 0x14:  //register select
 20634:     case 0x16:  //(reserved)
 20635:       //reserved CIRのアクセスはプロトコル違反にならない
 20636:       return;
 20637:       //case 0x18:  //instruction address
 20638:       //case 0x1c:  //operand address
 20639:     }
 20640:     cirException (0x1d0d);  //プロトコル違反
 20641:   }  //cirWriteWord(int,int)
 20642: 
 20643:   //cirWriteLong (a, d)
 20644:   //  ライドロング
 20645:   public void cirWriteLong (int a, int d) {
 20646:     if (CIR_DEBUG_TRACE) {
 20647:       System.out.printf ("%08x cirWriteLongZero(0x%08x,0x%08x)\n", XEiJ.regPC0, a, d);
 20648:     }
 20649:     switch (a & 0x1e) {  //bit0は無視される
 20650:       //case 0x00:  //response
 20651:       //case 0x02:  //control
 20652:       //case 0x04:  //save
 20653:       //case 0x06:  //restore
 20654:       //case 0x08:  //operation word
 20655:       //case 0x0a:  //command
 20656:     case 0x0c:  //(reserved)
 20657:       //reserved CIRのアクセスはプロトコル違反にならない
 20658:       return;
 20659:       //case 0x0e:  //condition
 20660:     case 0x10:  //operand
 20661:       if ((cirStage & CIR_INPUT_MASK) != 0 && cirOperandIndex < cirOperandLength) {
 20662:         cirOperandBuffer[cirOperandIndex++] = d;
 20663:         if (cirOperandIndex == cirOperandLength) {  //転送終了
 20664:           if (cirStage == CIR_DYNAMIC_K_FACTOR ||
 20665:               cirStage == CIR_DYNAMIC_REGISTER_LIST ||
 20666:               cirStage == CIR_SOURCE_OPERAND) {
 20667:             cirGen ();
 20668:           } else if (cirStage == CIR_FRESTORE_STATE_FRAME) {
 20669:             int i = cirFormatWord == 0x1f38 ? 0 : 3 * 8;
 20670:             //FSAVEとFRESTOREのステートフレームの構造が同じになるように注意すること
 20671:             epbFpcr = cirOperandBuffer[i++] & EPB_FPCR_ALL;
 20672:             epbFpsr = cirOperandBuffer[i++] & EPB_FPSR_ALL;
 20673:             epbFpiar = cirOperandBuffer[i++];
 20674:             epbQuotient = cirOperandBuffer[i++];
 20675:             epbRoundingPrec = cirOperandBuffer[i++];
 20676:             epbRoundingMode = cirOperandBuffer[i++];
 20677:             cirResponse = cirOperandBuffer[i++];
 20678:             cirFormatWord = cirOperandBuffer[i++];
 20679:             cirOperationWord = cirOperandBuffer[i++];
 20680:             cirCommand = cirOperandBuffer[i++];
 20681:             cirRegisterList = cirOperandBuffer[i++];
 20682:             cirOperandAddress = cirOperandBuffer[i++];
 20683:             cirOperandLength = cirOperandBuffer[i++];
 20684:             cirOperandIndex = cirOperandBuffer[i++];
 20685:             cirStage = cirOperandBuffer[i++];
 20686:           }
 20687:         }
 20688:         return;
 20689:       }
 20690:       break;
 20691:       //case 0x14:  //register select
 20692:     case 0x16:  //(reserved)
 20693:       //reserved CIRのアクセスはプロトコル違反にならない
 20694:       return;
 20695:     case 0x18:  //instruction address
 20696:       if (cirStage == CIR_PROGRAM_COUNTER) {
 20697:         //FMOVEM/FMOVE FPcr/FSAVE/FRESTORE以外の命令でFPCRのException Enable Byte(bit15-8)が0でないときデータ転送プリミティブのPC(bit14)がセットされる
 20698:         //データ転送プリミティブのPC(bit14)がセットされているときデータ転送の前にinstruction address CIRにPCを書き込まないとプロトコル違反になる
 20699:         epbFpiar = d;
 20700:         cirGen ();
 20701:         return;
 20702:       }
 20703:       break;
 20704:     case 0x1c:  //operand address
 20705:       cirOperandAddress = d;
 20706:       break;
 20707:     }
 20708:     cirException (0x1d0d);  //プロトコル違反
 20709:   }  //cirWriteLong(int,int)
 20710: 
 20711: 
 20712:   //cirGen ()
 20713:   //  一般命令の処理
 20714:   //  コマンドを開始するときと転送が終了したときに呼び出される
 20715:   //  cirStageがCIR_IDLEのときは最初から、それ以外は途中から処理する
 20716:   @SuppressWarnings ("fallthrough") public void cirGen () {
 20717:     if (CIR_DEBUG_TRACE) {
 20718:       System.out.printf ("%08x cirGen(command=0x%04x,stage=%d(%s))\n", XEiJ.regPC0, cirCommand, cirStage, cirNameOfStage[cirStage & 15]);
 20719:     }
 20720: 
 20721:     //  111111
 20722:     //  5432109876543210
 20723:     //  hhhmmmnnnccccccc
 20724:     int mmm = cirCommand >> 10 & 7;  //ソースオペランド
 20725:     int nnn = cirCommand >> 7 & 7;  //デスティネーションオペランド
 20726:     int ccccccc = cirCommand & 0x7f;
 20727: 
 20728: 
 20729:     switch (cirCommand >> 13) {
 20730: 
 20731: 
 20732:     case 0b010:  //$4xxx-$5xxx: Fop.* <ea>,FPn
 20733:       if (cirStage == CIR_IDLE) {  //開始
 20734:         epbFpsr &= 0x00ff00ff;
 20735:         epbSetRoundingPrec (epbFpcr >> 6 & 3);  //丸め桁数
 20736:         epbSetRoundingMode (epbFpcr >> 4 & 3);  //丸めモード
 20737:       }
 20738: 
 20739:       switch (mmm) {
 20740: 
 20741:       case 0b000:  //$40xx-$43xx: Fop.L <ea>,FPn
 20742:         //    --------------------------------
 20743:         //    > cir 00 .
 20744:         //    0802 
 20745:         //    > cir 0a 4000
 20746:         //    > cir 00 ...
 20747:         //    9504 8900 8900 
 20748:         //    > cir 10 00000001
 20749:         //    > cir 00 ..
 20750:         //    0802 0802 
 20751:         //    --------------------------------
 20752:         if (cirStage == CIR_IDLE) {  //開始
 20753:           if ((epbFpcr & 0x0000ff00) != 0) {  //例外処理あり
 20754:             cirResponse = 0x8900_d504;  //PCを入力する→ロングのデータを入力する→come-again
 20755:             cirStage = CIR_PROGRAM_COUNTER;  //PC転送開始
 20756:           } else {
 20757:             cirResponse = 0x8900_9504;  //ロングのデータを入力する→come-again
 20758:             cirOperandLength = 1;
 20759:             cirOperandIndex = 0;
 20760:             cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 20761:           }
 20762:           return;
 20763:         }
 20764:         if (cirStage == CIR_PROGRAM_COUNTER) {  //PC転送終了
 20765:           cirOperandLength = 1;
 20766:           cirOperandIndex = 0;
 20767:           cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 20768:           return;
 20769:         }
 20770:         if (cirStage == CIR_SOURCE_OPERAND) {  //ソースオペランド転送終了
 20771:           epbFPn[mmm = EPB_SRC_TMP].seti (cirOperandBuffer[0]);
 20772:           if (cirPreInstruction ()) {
 20773:             return;
 20774:           }
 20775:         }
 20776:         break;
 20777: 
 20778:       case 0b001:  //$44xx-$47xx: Fop.S <ea>,FPn
 20779:         //    --------------------------------
 20780:         //    > cir 00 .
 20781:         //    0802 
 20782:         //    > cir 0a 4400
 20783:         //    > cir 00 ...
 20784:         //    1504 8900 8900 
 20785:         //    > cir 10 00000000
 20786:         //    > cir 00 ..
 20787:         //    0802 0802 
 20788:         //    --------------------------------
 20789:         if (cirStage == CIR_IDLE) {  //開始
 20790:           if ((epbFpcr & 0x0000ff00) != 0) {  //例外処理あり
 20791:             if ((epbMode & EPB_MODE_MC68882) != 0) {  //MC68882
 20792:               cirResponse = 0x8900_5504;  //PCを入力する→シングルのデータを入力する→come-again
 20793:             } else {  //MC68881
 20794:               cirResponse = 0x8900_d504;  //PCを入力する→シングルのデータを入力する→come-again
 20795:             }
 20796:             cirStage = CIR_PROGRAM_COUNTER;  //PC転送開始
 20797:           } else {
 20798:             if ((epbMode & EPB_MODE_MC68882) != 0) {  //MC68882
 20799:               cirResponse = 0x8900_1504;  //シングルのデータを入力する→come-again
 20800:             } else {  //MC68881
 20801:               cirResponse = 0x8900_9504;  //シングルのデータを入力する→come-again
 20802:             }
 20803:             cirOperandLength = 1;
 20804:             cirOperandIndex = 0;
 20805:             cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 20806:           }
 20807:           return;
 20808:         }
 20809:         if (cirStage == CIR_PROGRAM_COUNTER) {  //PC転送終了
 20810:           cirOperandLength = 1;
 20811:           cirOperandIndex = 0;
 20812:           cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 20813:           return;
 20814:         }
 20815:         if (cirStage == CIR_SOURCE_OPERAND) {  //ソースオペランド転送終了
 20816:           epbFPn[mmm = EPB_SRC_TMP].setf0 (cirOperandBuffer[0]);
 20817:           if (cirPreInstruction ()) {
 20818:             return;
 20819:           }
 20820:         }
 20821:         break;
 20822: 
 20823:       case 0b010:  //$48xx-$4Bxx: Fop.X <ea>,FPn
 20824:         //    --------------------------------
 20825:         //    > cir 00 .
 20826:         //    0802 
 20827:         //    > cir 0a 4800
 20828:         //    > cir 00 ...
 20829:         //    160C 8900 8900 
 20830:         //    > cir 10 00000000
 20831:         //    > cir 00 ..
 20832:         //    8900 8900 
 20833:         //    > cir 10 00000000
 20834:         //    > cir 00 ..
 20835:         //    8900 8900 
 20836:         //    > cir 10 00000000
 20837:         //    > cir 00 ..
 20838:         //    0802 0802 
 20839:         //    --------------------------------
 20840:         if (cirStage == CIR_IDLE) {  //開始
 20841:           if ((epbFpcr & 0x0000ff00) != 0) {  //例外処理あり
 20842:             if ((epbMode & EPB_MODE_MC68882) != 0) {  //MC68882
 20843:               cirResponse = 0x8900_560c;  //PCを入力する→エクステンデッドのデータを入力する→come-again
 20844:             } else {  //MC68881
 20845:               cirResponse = 0x8900_d60c;  //PCを入力する→エクステンデッドのデータを入力する→come-again
 20846:             }
 20847:             cirStage = CIR_PROGRAM_COUNTER;  //PC転送開始
 20848:           } else {
 20849:             if ((epbMode & EPB_MODE_MC68882) != 0) {  //MC68882
 20850:               cirResponse = 0x8900_160c;  //エクステンデッドのデータを入力する→come-again
 20851:             } else {  //MC68881
 20852:               cirResponse = 0x8900_960c;  //エクステンデッドのデータを入力する→come-again
 20853:             }
 20854:             cirOperandLength = 3;
 20855:             cirOperandIndex = 0;
 20856:             cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 20857:           }
 20858:           return;
 20859:         }
 20860:         if (cirStage == CIR_PROGRAM_COUNTER) {  //PC転送終了
 20861:           cirOperandLength = 3;
 20862:           cirOperandIndex = 0;
 20863:           cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 20864:           return;
 20865:         }
 20866:         if (cirStage == CIR_SOURCE_OPERAND) {  //ソースオペランド転送終了
 20867:           if (epbIsTriple ()) {  //三倍精度
 20868:             epbFPn[mmm = EPB_SRC_TMP].sety012 (cirOperandBuffer[0], (long) cirOperandBuffer[1] << 32 | cirOperandBuffer[2] & 0xffffffffL);
 20869:           } else {  //拡張精度
 20870:             epbFPn[mmm = EPB_SRC_TMP].setx012 (cirOperandBuffer[0], (long) cirOperandBuffer[1] << 32 | cirOperandBuffer[2] & 0xffffffffL);
 20871:           }
 20872:           if (cirPreInstruction ()) {
 20873:             return;
 20874:           }
 20875:         }
 20876:         break;
 20877: 
 20878:       case 0b011:  //$4Cxx-$4Fxx: Fop.P <ea>,FPn
 20879:         //    --------------------------------
 20880:         //    > cir 00 .
 20881:         //    0802 
 20882:         //    > cir 0a 4c00
 20883:         //    > cir 00 ....
 20884:         //    8900 960C 8900 8900 
 20885:         //    > cir 10 00000000
 20886:         //    > cir 00 ..
 20887:         //    8900 8900 
 20888:         //    > cir 10 00000000
 20889:         //    > cir 00 ..
 20890:         //    8900 8900 
 20891:         //    > cir 10 00000000
 20892:         //    > cir 00 ..
 20893:         //    0802 0802 
 20894:         //    --------------------------------
 20895:         if (cirStage == CIR_IDLE) {  //開始
 20896:           if ((epbFpcr & 0x0000ff00) != 0) {  //例外処理あり
 20897:             cirResponse = 0x8900_d60c;  //PCを入力する→パックトのデータを入力する→come-again
 20898:             cirStage = CIR_PROGRAM_COUNTER;  //PC転送開始
 20899:           } else {
 20900:             cirResponse = 0x8900_960c;  //パックトのデータを入力する→come-again
 20901:             cirOperandLength = 3;
 20902:             cirOperandIndex = 0;
 20903:             cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 20904:           }
 20905:           return;
 20906:         }
 20907:         if (cirStage == CIR_PROGRAM_COUNTER) {  //PC転送終了
 20908:           cirOperandLength = 3;
 20909:           cirOperandIndex = 0;
 20910:           cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 20911:           return;
 20912:         }
 20913:         if (cirStage == CIR_SOURCE_OPERAND) {  //ソースオペランド転送終了
 20914:           epbFPn[mmm = EPB_SRC_TMP].setp012 (cirOperandBuffer[0], (long) cirOperandBuffer[1] << 32 | cirOperandBuffer[2] & 0xffffffffL);
 20915:           if (cirPreInstruction ()) {
 20916:             return;
 20917:           }
 20918:         }
 20919:         break;
 20920: 
 20921:       case 0b100:  //$50xx-$53xx: Fop.W <ea>,FPn
 20922:         //    --------------------------------
 20923:         //    > cir 00 .
 20924:         //    0802 
 20925:         //    > cir 0a 5000
 20926:         //    > cir 00 ...
 20927:         //    9502 8900 8900 
 20928:         //    > cir 10 00010002
 20929:         //    > cir 00 ..
 20930:         //    0802 0802 
 20931:         //    > cir 0a 6000
 20932:         //    > cir 00 ...
 20933:         //    8900 B104 0802 
 20934:         //    > cir 10 .
 20935:         //    00000001 
 20936:         //    > cir 00 ..
 20937:         //    0802 0802 
 20938:         //    --------------------------------
 20939:         if (cirStage == CIR_IDLE) {  //開始
 20940:           if ((epbFpcr & 0x0000ff00) != 0) {  //例外処理あり
 20941:             cirResponse = 0x8900_d502;  //PCを入力する→ワードのデータを入力する→come-again
 20942:             cirStage = CIR_PROGRAM_COUNTER;  //PC転送開始
 20943:           } else {
 20944:             cirResponse = 0x8900_9502;  //ワードのデータを入力する→come-again
 20945:             cirOperandLength = 1;
 20946:             cirOperandIndex = 0;
 20947:             cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 20948:           }
 20949:           return;
 20950:         }
 20951:         if (cirStage == CIR_PROGRAM_COUNTER) {  //PC転送終了
 20952:           cirOperandLength = 1;
 20953:           cirOperandIndex = 0;
 20954:           cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 20955:           return;
 20956:         }
 20957:         if (cirStage == CIR_SOURCE_OPERAND) {  //ソースオペランド転送終了
 20958:           epbFPn[mmm = EPB_SRC_TMP].seti (cirOperandBuffer[0] >> 16);  //左詰めになっている
 20959:           if (cirPreInstruction ()) {
 20960:             return;
 20961:           }
 20962:         }
 20963:         break;
 20964: 
 20965:       case 0b101:  //$54xx-$57xx: Fop.D <ea>,FPn
 20966:         //    --------------------------------
 20967:         //    > cir 00 .
 20968:         //    0802 
 20969:         //    > cir 0a 5400
 20970:         //    > cir 00 ...
 20971:         //    1608 8900 8900 
 20972:         //    > cir 10 00000000
 20973:         //    > cir 00 ..
 20974:         //    8900 8900 
 20975:         //    > cir 10 00000000
 20976:         //    > cir 00 ..
 20977:         //    0802 0802 
 20978:         //    --------------------------------
 20979:         if (cirStage == CIR_IDLE) {  //開始
 20980:           if ((epbFpcr & 0x0000ff00) != 0) {  //例外処理あり
 20981:             if ((epbMode & EPB_MODE_MC68882) != 0) {  //MC68882
 20982:               cirResponse = 0x8900_5608;  //PCを入力する→ダブルのデータを入力する→come-again
 20983:             } else {  //MC68881
 20984:               cirResponse = 0x8900_d608;  //PCを入力する→ダブルのデータを入力する→come-again
 20985:             }
 20986:             cirStage = CIR_PROGRAM_COUNTER;  //PC転送開始
 20987:           } else {
 20988:             if ((epbMode & EPB_MODE_MC68882) != 0) {  //MC68882
 20989:               cirResponse = 0x8900_1608;  //ダブルのデータを入力する→come-again
 20990:             } else {  //MC68881
 20991:               cirResponse = 0x8900_9608;  //ダブルのデータを入力する→come-again
 20992:             }
 20993:             cirOperandLength = 2;
 20994:             cirOperandIndex = 0;
 20995:             cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 20996:           }
 20997:           return;
 20998:         }
 20999:         if (cirStage == CIR_PROGRAM_COUNTER) {  //PC転送終了
 21000:           cirOperandLength = 2;
 21001:           cirOperandIndex = 0;
 21002:           cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 21003:           return;
 21004:         }
 21005:         if (cirStage == CIR_SOURCE_OPERAND) {  //ソースオペランド転送終了
 21006:           epbFPn[mmm = EPB_SRC_TMP].setd01 ((long) cirOperandBuffer[0] << 32 | cirOperandBuffer[1] & 0xffffffffL);
 21007:           if (cirPreInstruction ()) {
 21008:             return;
 21009:           }
 21010:         }
 21011:         break;
 21012: 
 21013:       case 0b110:  //$58xx-$5Bxx: Fop.B <ea>,FPn
 21014:         //    --------------------------------
 21015:         //    > cir 00 .
 21016:         //    0802 
 21017:         //    > cir 0a 5800
 21018:         //    > cir 00 ...
 21019:         //    9501 8900 8900 
 21020:         //    > cir 10 01020304
 21021:         //    > cir 00 ..
 21022:         //    0802 0802 
 21023:         //    > cir 0a 6000
 21024:         //    > cir 00 ...
 21025:         //    8900 B104 0802 
 21026:         //    > cir 10 .
 21027:         //    00000001 
 21028:         //    > cir 00 ..
 21029:         //    0802 0802 
 21030:         //    --------------------------------
 21031:         if (cirStage == CIR_IDLE) {  //開始
 21032:           if ((epbFpcr & 0x0000ff00) != 0) {  //例外処理あり
 21033:             cirResponse = 0x8900_d501;  //バイトのデータを入力する→come-again
 21034:             cirStage = CIR_PROGRAM_COUNTER;  //PC転送開始
 21035:           } else {
 21036:             cirResponse = 0x8900_9501;  //バイトのデータを入力する→come-again
 21037:             cirOperandLength = 1;
 21038:             cirOperandIndex = 0;
 21039:             cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 21040:           }
 21041:           return;
 21042:         }
 21043:         if (cirStage == CIR_PROGRAM_COUNTER) {  //PC転送終了
 21044:           cirOperandLength = 1;
 21045:           cirOperandIndex = 0;
 21046:           cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 21047:           return;
 21048:         }
 21049:         if (cirStage == CIR_SOURCE_OPERAND) {  //ソースオペランド転送終了
 21050:           epbFPn[mmm = EPB_SRC_TMP].seti (cirOperandBuffer[0] >> 24);  //左詰めになっている
 21051:           if (cirPreInstruction ()) {
 21052:             return;
 21053:           }
 21054:         }
 21055:         break;
 21056: 
 21057:       case 0b111:  //$5Cxx-$5Fxx: FMOVECR.X #ccc,FPn
 21058:         //    --------------------------------
 21059:         //    > cir 00 .
 21060:         //    0802 
 21061:         //    > cir 0a 5c00
 21062:         //    > cir 00 ..
 21063:         //    0900 0802 
 21064:         //    > cir 0a 6800
 21065:         //    > cir 00 ....
 21066:         //    8900 320C 8900 8900 
 21067:         //    > cir 10 .
 21068:         //    40000000 
 21069:         //    > cir 00 ..
 21070:         //    8900 8900 
 21071:         //    > cir 10 .
 21072:         //    C90FDAA2 
 21073:         //    > cir 00 ..
 21074:         //    0802 0802 
 21075:         //    > cir 10 .
 21076:         //    2168C235 
 21077:         //    > cir 00 ..
 21078:         //    0802 0802 
 21079:         //    --------------------------------
 21080:       default:
 21081:         if (0x40 <= ccccccc) {
 21082:           //マニュアルにはFMOVECRの命令フォーマットのROMオフセットが7bitあるように書かれているが実際は6bit
 21083:           //MC68882で0x40以上を指定すると命令実行前例外のF-line emulator(レスポンスプリミティブ0x1c0b)が返る
 21084:           cirException (0x1c0b);  //F-line emulator
 21085:           return;
 21086:         }
 21087:         if (false) {
 21088:           mmm = EPB_CONST_START + ccccccc;  //ソースオペランドをROMに変更する
 21089:           ccccccc = 0;  //命令をFMOVEに変更する
 21090:         } else {
 21091:           //FMOVECR
 21092:           epbFmovecr (epbFPn[nnn], ccccccc);
 21093:           if (cirMidInstruction ()) {
 21094:             return;
 21095:           }
 21096:           //終了
 21097:           cirIdle (0x0802);
 21098:           return;
 21099:         }
 21100: 
 21101:       }
 21102:       //Fop.X <ea>,FPn → Fop.X FP[EPB_SRC_TMP],FPn
 21103:       //FMOVECR.X #ccc,FPn → FMOVE.X FPc,FPn
 21104: 
 21105: 
 21106:       //fallthrough
 21107:     case 0b000:  //$0xxx-$1xxx: Fop.X FPm,FPn
 21108:       if (cirStage == CIR_IDLE) {  //開始
 21109:         epbFpsr &= 0x00ff00ff;
 21110:       }
 21111: 
 21112:       switch (ccccccc) {
 21113: 
 21114:       case 0b000_0000:  //$xx00: FMOVE.* *m,FPn
 21115:         //    --------------------------------
 21116:         //    > cir 00 .
 21117:         //    0802 
 21118:         //    > cir 0a 4000
 21119:         //    > cir 00 ...
 21120:         //    9504 8900 8900 
 21121:         //    > cir 10 00000001
 21122:         //    > cir 00 ..
 21123:         //    0802 0802 
 21124:         //    > cir 0a 0000
 21125:         //    > cir 00 ...
 21126:         //    0900 0802 0802 
 21127:         //    --------------------------------
 21128:         //  BSUN   常にクリア
 21129:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21130:         //  OPERR  常にクリア
 21131:         //  OVFL   常にクリア
 21132:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21133:         //  DZ     常にクリア
 21134:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21135:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21136:         epbFPn[nnn].sete (epbFPn[mmm]).finish ();
 21137:         break;
 21138: 
 21139:       case 0b000_0001:  //$xx01: FINT.* *m,FPn
 21140:         //    --------------------------------
 21141:         //    > cir 00 .
 21142:         //    0802 
 21143:         //    > cir 0a 4000
 21144:         //    > cir 00 ...
 21145:         //    9504 8900 8900 
 21146:         //    > cir 10 00000001
 21147:         //    > cir 00 ..
 21148:         //    0802 0802 
 21149:         //    > cir 0a 0001
 21150:         //    > cir 00 ...
 21151:         //    0900 0802 0802 
 21152:         //    --------------------------------
 21153:         //  BSUN   常にクリア
 21154:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21155:         //  OPERR  常にクリア
 21156:         //  OVFL   常にクリア
 21157:         //         正規化数の最大値は整数なので丸めても大きくなることはない
 21158:         //  UNFL   常にクリア
 21159:         //         結果は整数なので非正規化数にはならない
 21160:         //  DZ     常にクリア
 21161:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21162:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21163:         //  FINTはsingleとdoubleの丸め処理を行わない
 21164:         epbSetRoundingPrec (EPB_PREC_EXD);
 21165:         epbFPn[nnn].round (epbFPn[mmm], epbRoundingMode);
 21166:         break;
 21167: 
 21168:       case 0b000_0010:  //$xx02: FSINH.* *m,FPn
 21169:         //    --------------------------------
 21170:         //    > cir 00 .
 21171:         //    0802 
 21172:         //    > cir 0a 4000
 21173:         //    > cir 00 ...
 21174:         //    9504 8900 8900 
 21175:         //    > cir 10 00000001
 21176:         //    > cir 00 ..
 21177:         //    0802 0802 
 21178:         //    > cir 0a 0002
 21179:         //    > cir 00 ...
 21180:         //    0900 0802 0802 
 21181:         //    --------------------------------
 21182:         //  BSUN   常にクリア
 21183:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21184:         //  OPERR  常にクリア
 21185:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21186:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21187:         //  DZ     常にクリア
 21188:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21189:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21190:         epbFPn[nnn].sinh (epbFPn[mmm]);
 21191:         break;
 21192: 
 21193:       case 0b000_0011:  //$xx03: FINTRZ.* *m,FPn
 21194:         //  BSUN   常にクリア
 21195:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21196:         //  OPERR  常にクリア
 21197:         //  OVFL   常にクリア
 21198:         //  UNFL   常にクリア
 21199:         //         結果は整数なので非正規化数にはならない
 21200:         //  DZ     常にクリア
 21201:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21202:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21203:         //  FINTRZはsingleとdoubleの丸め処理を行わない
 21204:         epbSetRoundingPrec (EPB_PREC_EXD);
 21205:         epbFPn[nnn].trunc (epbFPn[mmm]);
 21206:         break;
 21207: 
 21208:       case 0b000_0100:  //$xx04: FSQRT.* *m,FPn
 21209:       case 0b000_0101:  //$xx05: FSQRT.* *m,FPn (MC68882)
 21210:         //  BSUN   常にクリア
 21211:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21212:         //  OPERR  引数が-0を除く負数のときセット、それ以外はクリア
 21213:         //  OVFL   常にクリア
 21214:         //         1よりも大きい数は小さくなるので溢れることはない
 21215:         //  UNFL   常にクリア
 21216:         //         非正規化数の平方根は正規化数なので結果が非正規化数になることはない
 21217:         //  DZ     常にクリア
 21218:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21219:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21220:         epbFPn[nnn].sqrt (epbFPn[mmm]);
 21221:         break;
 21222: 
 21223:       case 0b000_0110:  //$xx06: FLOGNP1.* *m,FPn
 21224:       case 0b000_0111:  //$xx07: FLOGNP1.* *m,FPn (MC68882)
 21225:         //  BSUN   常にクリア
 21226:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21227:         //  OPERR  引数が-1よりも小さいときセット、それ以外はクリア
 21228:         //  OVFL   常にクリア
 21229:         //         log(1+0)=0,log(1+x)<=xなので結果が引数よりも大きくなることはない
 21230:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21231:         //  DZ     引数が-1のときセット、それ以外はクリア
 21232:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21233:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21234:         epbFPn[nnn].log1p (epbFPn[mmm]);
 21235:         break;
 21236: 
 21237:       case 0b000_1000:  //$xx08: FETOXM1.* *m,FPn
 21238:         //  BSUN   常にクリア
 21239:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21240:         //  OPERR  常にクリア
 21241:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21242:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21243:         //  DZ     常にクリア
 21244:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21245:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21246:         epbFPn[nnn].expm1 (epbFPn[mmm]);
 21247:         break;
 21248: 
 21249:       case 0b000_1001:  //$xx09: FTANH.* *m,FPn
 21250:         //  BSUN   常にクリア
 21251:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21252:         //  OPERR  常にクリア
 21253:         //  OVFL   常にクリア
 21254:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21255:         //  DZ     常にクリア
 21256:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21257:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21258:         epbFPn[nnn].tanh (epbFPn[mmm]);
 21259:         break;
 21260: 
 21261:       case 0b000_1010:  //$xx0A: FATAN.* *m,FPn
 21262:       case 0b000_1011:  //$xx0B: FATAN.* *m,FPn (MC68882)
 21263:         //  BSUN   常にクリア
 21264:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21265:         //  OPERR  常にクリア
 21266:         //  OVFL   常にクリア
 21267:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21268:         //  DZ     常にクリア
 21269:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21270:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21271:         epbFPn[nnn].atan (epbFPn[mmm]);
 21272:         break;
 21273: 
 21274:       case 0b000_1100:  //$xx0C: FASIN.* *m,FPn
 21275:         //  BSUN   常にクリア
 21276:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21277:         //  OPERR  引数の絶対値が1よりも大きいときセット、それ以外はクリア
 21278:         //  OVFL   常にクリア
 21279:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21280:         //  DZ     常にクリア
 21281:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21282:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21283:         epbFPn[nnn].asin (epbFPn[mmm]);
 21284:         break;
 21285: 
 21286:       case 0b000_1101:  //$xx0D: FATANH.* *m,FPn
 21287:         //  BSUN   常にクリア
 21288:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21289:         //  OPERR  引数の絶対値が1よりも大きいときセット、それ以外はクリア
 21290:         //  OVFL   常にクリア
 21291:         //         1のとき無限大なのだから1の近くでオーバーフローしそうに思えるがatanh(1-2^-80)≒28.07くらい
 21292:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21293:         //  DZ     引数の絶対値が1のときセット、それ以外はクリア
 21294:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21295:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21296:         epbFPn[nnn].atanh (epbFPn[mmm]);
 21297:         break;
 21298: 
 21299:       case 0b000_1110:  //$xx0E: FSIN.* *m,FPn
 21300:         //  BSUN   常にクリア
 21301:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21302:         //  OPERR  引数が無限大のときセット、それ以外はクリア
 21303:         //  OVFL   常にクリア
 21304:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21305:         //  DZ     常にクリア
 21306:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21307:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21308:         epbFPn[nnn].sin (epbFPn[mmm]);
 21309:         break;
 21310: 
 21311:       case 0b000_1111:  //$xx0F: FTAN.* *m,FPn
 21312:         //  BSUN   常にクリア
 21313:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21314:         //  OPERR  引数が無限大のときセット、それ以外はクリア
 21315:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21316:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21317:         //  DZ     常にクリア
 21318:         //         cos(x)=0を満たすxは正確に表現できないのだからsin(x)/cos(x)がゼロ除算になるのはおかしい
 21319:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21320:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21321:         epbFPn[nnn].tan (epbFPn[mmm]);
 21322:         break;
 21323: 
 21324:       case 0b001_0000:  //$xx10: FETOX.* *m,FPn
 21325:         //  BSUN   常にクリア
 21326:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21327:         //  OPERR  常にクリア
 21328:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21329:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21330:         //  DZ     常にクリア
 21331:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21332:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21333:         epbFPn[nnn].exp (epbFPn[mmm]);
 21334:         break;
 21335: 
 21336:       case 0b001_0001:  //$xx11: FTWOTOX.* *m,FPn
 21337:         //  BSUN   常にクリア
 21338:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21339:         //  OPERR  常にクリア
 21340:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21341:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21342:         //  DZ     常にクリア
 21343:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21344:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21345:         epbFPn[nnn].exp2 (epbFPn[mmm]);
 21346:         break;
 21347: 
 21348:       case 0b001_0010:  //$xx12: FTENTOX.* *m,FPn
 21349:       case 0b001_0011:  //$xx13: FTENTOX.* *m,FPn (MC68882)
 21350:         //  BSUN   常にクリア
 21351:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21352:         //  OPERR  常にクリア
 21353:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21354:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21355:         //  DZ     常にクリア
 21356:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21357:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21358:         epbFPn[nnn].exp10 (epbFPn[mmm]);
 21359:         break;
 21360: 
 21361:       case 0b001_0100:  //$xx14: FLOGN.* *m,FPn
 21362:         //  BSUN   常にクリア
 21363:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21364:         //  OPERR  引数が0よりも小さいときセット、それ以外はクリア
 21365:         //  OVFL   常にクリア
 21366:         //         log(1)=0,log(x)<=x-1なので結果が引数よりも大きくなることはない
 21367:         //  UNFL   常にクリア
 21368:         //         log(1+2^-80)≒2^-80
 21369:         //  DZ     引数がゼロのときセット、それ以外はクリア
 21370:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21371:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21372:         epbFPn[nnn].log (epbFPn[mmm]);
 21373:         break;
 21374: 
 21375:       case 0b001_0101:  //$xx15: FLOG10.* *m,FPn
 21376:         //  BSUN   常にクリア
 21377:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21378:         //  OPERR  引数が0よりも小さいときセット、それ以外はクリア
 21379:         //  OVFL   常にクリア
 21380:         //  UNFL   常にクリア
 21381:         //  DZ     引数がゼロのときセット、それ以外はクリア
 21382:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21383:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21384:         epbFPn[nnn].log10 (epbFPn[mmm]);
 21385:         break;
 21386: 
 21387:       case 0b001_0110:  //$xx16: FLOG2.* *m,FPn
 21388:       case 0b001_0111:  //$xx17: FLOG2.* *m,FPn (MC68882)
 21389:         //  BSUN   常にクリア
 21390:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21391:         //  OPERR  引数が0よりも小さいときセット、それ以外はクリア
 21392:         //  OVFL   常にクリア
 21393:         //  UNFL   常にクリア
 21394:         //  DZ     引数がゼロのときセット、それ以外はクリア
 21395:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21396:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21397:         epbFPn[nnn].log2 (epbFPn[mmm]);
 21398:         break;
 21399: 
 21400:       case 0b001_1000:  //$xx18: FABS.* *m,FPn
 21401:         //  BSUN   常にクリア
 21402:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21403:         //  OPERR  常にクリア
 21404:         //  OVFL   常にクリア
 21405:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21406:         //  DZ     常にクリア
 21407:         //  INEX2  常にクリア
 21408:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21409:         epbFPn[nnn].abs (epbFPn[mmm]);
 21410:         break;
 21411: 
 21412:       case 0b001_1001:  //$xx19: FCOSH.* *m,FPn
 21413:         //  BSUN   常にクリア
 21414:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21415:         //  OPERR  常にクリア
 21416:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21417:         //  UNFL   常にクリア
 21418:         //  DZ     常にクリア
 21419:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21420:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21421:         epbFPn[nnn].cosh (epbFPn[mmm]);
 21422:         break;
 21423: 
 21424:       case 0b001_1010:  //$xx1A: FNEG.* *m,FPn
 21425:       case 0b001_1011:  //$xx1B: FNEG.* *m,FPn (MC68882)
 21426:         //  BSUN   常にクリア
 21427:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21428:         //  OPERR  常にクリア
 21429:         //  OVFL   常にクリア
 21430:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21431:         //  DZ     常にクリア
 21432:         //  INEX2  常にクリア
 21433:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21434:         epbFPn[nnn].neg (epbFPn[mmm]);
 21435:         break;
 21436: 
 21437:       case 0b001_1100:  //$xx1C: FACOS.* *m,FPn
 21438:         //  BSUN   常にクリア
 21439:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21440:         //  OPERR  引数の絶対値が1よりも大きいときセット、それ以外はクリア
 21441:         //  OVFL   常にクリア
 21442:         //  UNFL   常にクリア
 21443:         //         acos(1-ulp(1))はulp(1)よりも大きい
 21444:         //  DZ     常にクリア
 21445:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21446:         //         おそらくセットされないのはacos(1)=0だけ
 21447:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21448:         epbFPn[nnn].acos (epbFPn[mmm]);
 21449:         break;
 21450: 
 21451:       case 0b001_1101:  //$xx1D: FCOS.* *m,FPn
 21452:         //  BSUN   常にクリア
 21453:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21454:         //  OPERR  引数が無限大のときセット、それ以外はクリア
 21455:         //  OVFL   常にクリア
 21456:         //  UNFL   常にクリア
 21457:         //         cos(x)=0を満たすxは正確に表現できず、cos(pi/2)とcos(3*pi/2)が正規化数になってしまう
 21458:         //  DZ     常にクリア
 21459:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21460:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21461:         epbFPn[nnn].cos (epbFPn[mmm]);
 21462:         break;
 21463: 
 21464:       case 0b001_1110:  //$xx1E: FGETEXP.* *m,FPn
 21465:         //  BSUN   常にクリア
 21466:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21467:         //  OPERR  引数が無限大のときセット、それ以外はクリア
 21468:         //  OVFL   常にクリア
 21469:         //  UNFL   常にクリア
 21470:         //  DZ     常にクリア
 21471:         //  INEX2  常にクリア
 21472:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21473:         epbFPn[nnn].getexp (epbFPn[mmm]);
 21474:         break;
 21475: 
 21476:       case 0b001_1111:  //$xx1F: FGETMAN.* *m,FPn
 21477:         //  BSUN   常にクリア
 21478:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21479:         //  OPERR  引数が無限大のときセット、それ以外はクリア
 21480:         //  OVFL   常にクリア
 21481:         //  UNFL   常にクリア
 21482:         //  DZ     常にクリア
 21483:         //  INEX2  常にクリア
 21484:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21485:         epbFPn[nnn].getman (epbFPn[mmm]);
 21486:         break;
 21487: 
 21488:       case 0b010_0000:  //$xx20: FDIV.* *m,FPn
 21489:         //  BSUN   常にクリア
 21490:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21491:         //  OPERR  引数が両方ゼロまたは両方無限大のときセット、それ以外はクリア
 21492:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21493:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21494:         //  DZ     被除数がゼロ、無限大、NaN以外で除数がゼロのときセット、それ以外はクリア
 21495:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21496:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21497:         epbFPn[nnn].div (epbFPn[mmm]);
 21498:         break;
 21499: 
 21500:       case 0b010_0001:  //$xx21: FMOD.* *m,FPn
 21501:         //  BSUN   常にクリア
 21502:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21503:         //  OPERR  除数がゼロまたは被除数が無限大のときセット、それ以外はクリア
 21504:         //  OVFL   常にクリア
 21505:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21506:         //  DZ     常にクリア
 21507:         //         除数がゼロのとき結果は無限大ではなくNaNでありゼロ除算にはならない
 21508:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21509:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21510:         //  FPSRのquotient byteに符号付き商の下位7bitが入る
 21511:         epbFPn[nnn].rem (epbFPn[mmm]);
 21512:         break;
 21513: 
 21514:       case 0b010_0010:  //$xx22: FADD.* *m,FPn
 21515:         //  BSUN   常にクリア
 21516:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21517:         //  OPERR  引数が両方無限大で符号が異なるときセット、それ以外はクリア
 21518:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21519:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21520:         //  DZ     常にクリア
 21521:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21522:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21523:         epbFPn[nnn].add (epbFPn[mmm]);
 21524:         break;
 21525: 
 21526:       case 0b010_0011:  //$xx23: FMUL.* *m,FPn
 21527:         //  BSUN   常にクリア
 21528:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21529:         //  OPERR  引数の一方がゼロで他方が無限大のときセット、それ以外はクリア
 21530:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21531:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21532:         //  DZ     常にクリア
 21533:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21534:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21535:         epbFPn[nnn].mul (epbFPn[mmm]);
 21536:         break;
 21537: 
 21538:       case 0b010_0100:  //$xx24: FSGLDIV.* *m,FPn
 21539:         //  BSUN   常にクリア
 21540:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21541:         //  OPERR  引数が両方ゼロまたは両方無限大のときセット、それ以外はクリア
 21542:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21543:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21544:         //  DZ     被除数がゼロ、無限大、NaN以外で除数がゼロのときセット、それ以外はクリア
 21545:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21546:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21547:         epbSetRoundingPrec (EPB_PREC_XSG);
 21548:         epbFPn[nnn].div (epbFPn[mmm]);
 21549:         break;
 21550: 
 21551:       case 0b010_0101:  //$xx25: FREM.* *m,FPn
 21552:         //  BSUN   常にクリア
 21553:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21554:         //  OPERR  除数がゼロまたは被除数が無限大のときセット、それ以外はクリア
 21555:         //  OVFL   常にクリア
 21556:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21557:         //  DZ     常にクリア
 21558:         //         除数がゼロのとき結果は無限大ではなくNaNでありゼロ除算にはならない
 21559:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21560:         //         マニュアルにClearedと書いてあるのは間違い
 21561:         //         除数が無限大で被除数をそのまま返す場合でもサイズが減ればアンダーフローや不正確な結果になることはマニュアルにも書かれている
 21562:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21563:         //  FPSRのquotient byteに符号付き商の下位7bitが入る
 21564:         epbFPn[nnn].ieeerem (epbFPn[mmm]);
 21565:         break;
 21566: 
 21567:       case 0b010_0110:  //$xx26: FSCALE.* *m,FPn
 21568:         //  BSUN   常にクリア
 21569:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21570:         //  OPERR  引数が無限大のときセット、それ以外はクリア
 21571:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21572:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21573:         //  DZ     常にクリア
 21574:         //  INEX2  常にクリア
 21575:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21576:         //! 本来はソースが整数のとき浮動小数点数を経由しないが、これは経由してしまっている。結果は同じだが効率が悪い
 21577:         epbFPn[nnn].scale (epbFPn[mmm]);
 21578:         break;
 21579: 
 21580:       case 0b010_0111:  //$xx27: FSGLMUL.* *m,FPn
 21581:         //  BSUN   常にクリア
 21582:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21583:         //  OPERR  引数の一方がゼロで他方が無限大のときセット、それ以外はクリア
 21584:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21585:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21586:         //  DZ     常にクリア
 21587:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21588:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21589:         {
 21590:           //引数を24bitに切り捨てるときX2をセットしない
 21591:           int sr = epbFpsr;
 21592:           epbFPn[EPB_SRC_TMP].roundmanf (epbFPn[mmm], EPB_MODE_RZ);
 21593:           epbFPn[EPB_DST_TMP].roundmanf (epbFPn[nnn], EPB_MODE_RZ);
 21594:           epbFpsr = sr;
 21595:         }
 21596:         epbSetRoundingPrec (EPB_PREC_XSG);
 21597:         epbFPn[nnn].mul (epbFPn[EPB_DST_TMP], epbFPn[EPB_SRC_TMP]);
 21598:         break;
 21599: 
 21600:       case 0b010_1000:  //$xx28: FSUB.* *m,FPn
 21601:       case 0b010_1001:  //$xx29: FSUB.* *m,FPn (MC68882)
 21602:       case 0b010_1010:  //$xx2A: FSUB.* *m,FPn (MC68882)
 21603:       case 0b010_1011:  //$xx2B: FSUB.* *m,FPn (MC68882)
 21604:       case 0b010_1100:  //$xx2C: FSUB.* *m,FPn (MC68882)
 21605:       case 0b010_1101:  //$xx2D: FSUB.* *m,FPn (MC68882)
 21606:       case 0b010_1110:  //$xx2E: FSUB.* *m,FPn (MC68882)
 21607:       case 0b010_1111:  //$xx2F: FSUB.* *m,FPn (MC68882)
 21608:         //  BSUN   常にクリア
 21609:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21610:         //  OPERR  引数が両方無限大で符号が同じときセット、それ以外はクリア
 21611:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21612:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21613:         //  DZ     常にクリア
 21614:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21615:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21616:         epbFPn[nnn].sub (epbFPn[mmm]);
 21617:         break;
 21618: 
 21619:       case 0b011_0000:  //$xx30: FSINCOS.* *m,FP0:FPn (c=0,s=n)
 21620:       case 0b011_0001:  //$xx31: FSINCOS.* *m,FP1:FPn (c=1,s=n)
 21621:       case 0b011_0010:  //$xx32: FSINCOS.* *m,FP2:FPn (c=2,s=n)
 21622:       case 0b011_0011:  //$xx33: FSINCOS.* *m,FP3:FPn (c=3,s=n)
 21623:       case 0b011_0100:  //$xx34: FSINCOS.* *m,FP4:FPn (c=4,s=n)
 21624:       case 0b011_0101:  //$xx35: FSINCOS.* *m,FP5:FPn (c=5,s=n)
 21625:       case 0b011_0110:  //$xx36: FSINCOS.* *m,FP6:FPn (c=6,s=n)
 21626:       case 0b011_0111:  //$xx37: FSINCOS.* *m,FP7:FPn (c=7,s=n)
 21627:         //  BSUN   常にクリア
 21628:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21629:         //  OPERR  引数が無限大のときセット、それ以外はクリア
 21630:         //  OVFL   常にクリア
 21631:         //  UNFL   sin(x)の結果が非正規化数のときセット、それ以外はクリア
 21632:         //         cos(x)の結果は非正規化数にならない
 21633:         //  DZ     常にクリア
 21634:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21635:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21636:         {
 21637:           int ccc = ccccccc & 7;
 21638:           //mmm==EPB_SRC_TMP||mmm==nnn||mmm==cccの場合があることに注意する
 21639:           epbFPn[EPB_SRC_TMP].sete (epbFPn[mmm]);
 21640:           epbFPn[ccc].cos (epbFPn[EPB_SRC_TMP]);
 21641:           epbFPn[nnn].sin (epbFPn[EPB_SRC_TMP]);
 21642:         }
 21643:         break;
 21644: 
 21645:       case 0b011_1000:  //$xx38: FCMP.* *m,FPn
 21646:       case 0b011_1001:  //$xx39: FCMP.* *m,FPn (MC68882)
 21647:       case 0b011_1100:  //$xx3C: FCMP.* *m,FPn (MC68882)  コマンドワードの不連続箇所に注意
 21648:       case 0b011_1101:  //$xx3D: FCMP.* *m,FPn (MC68882)
 21649:         //  BSUN   常にクリア
 21650:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21651:         //  OPERR  常にクリア
 21652:         //  OVFL   常にクリア
 21653:         //  UNFL   常にクリア
 21654:         //  DZ     常にクリア
 21655:         //  INEX2  常にクリア
 21656:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21657:         //  FCMPはinfinityを常にクリアする
 21658:         //  efp.compareTo(x,y)を使う
 21659:         //    efp.compareTo(x,y)はefp.sub(x,y)よりも速い
 21660:         //    efp.sub(x,y)はINEX2をセットしてしまう
 21661:         //  efp.compareTo(x,y)は-0<+0だがFCMPは-0==+0なのでこれだけ調節する
 21662:         {
 21663:           int xf = epbFPn[nnn].flg;
 21664:           int yf = epbFPn[mmm].flg;
 21665:           if ((xf | yf) << 3 < 0) {  //どちらかがNaN
 21666:             //epbFPn[EPB_DST_TMP].setnan ();
 21667:             epbFPn[EPB_DST_TMP].flg = N;
 21668:           } else {
 21669:             int i = ((xf & yf) << 1 < 0 ? 0 :  //両方±0
 21670:                      epbFPn[nnn].compareTo (epbFPn[mmm]));  //-Inf==-Inf<-x<-0<+0<+x<+Inf==+Inf<NaN==NaN
 21671:             if (i == 0) {
 21672:               if (xf < 0) {
 21673:                 //epbFPn[EPB_DST_TMP].negset0 ();
 21674:                 epbFPn[EPB_DST_TMP].flg = M | Z;
 21675:               } else {
 21676:                 //epbFPn[EPB_DST_TMP].set0 ();
 21677:                 epbFPn[EPB_DST_TMP].flg = P | Z;
 21678:               }
 21679:             } else if (i < 0) {
 21680:               epbFPn[EPB_DST_TMP].negset1 ();
 21681:             } else {
 21682:               epbFPn[EPB_DST_TMP].set1 ();
 21683:             }
 21684:           }
 21685:           nnn = EPB_DST_TMP;
 21686:         }
 21687:         break;
 21688: 
 21689:       case 0b011_1010:  //$xx3A: FTST.* *m
 21690:       case 0b011_1011:  //$xx3B: FTST.* *m (MC68882)
 21691:       case 0b011_1110:  //$xx3E: FTST.* *m (MC68882)  コマンドワードの不連続箇所に注意
 21692:       case 0b011_1111:  //$xx3F: FTST.* *m (MC68882)
 21693:         //  BSUN   常にクリア
 21694:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21695:         //  OPERR  常にクリア
 21696:         //  OVFL   常にクリア
 21697:         //  UNFL   常にクリア
 21698:         //  DZ     常にクリア
 21699:         //  INEX2  常にクリア
 21700:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21701:         //  ソースオペランドをダミーのデスティネーションオペランドにコピーしてテストする
 21702:         //  デスティネーションオペランドは変化しない
 21703:         //  デスティネーションオペランドにはFP0が指定される場合が多いがFP0である必要はない
 21704:         epbFPn[EPB_DST_TMP].sete (epbFPn[mmm]);
 21705:         nnn = EPB_DST_TMP;
 21706:         break;
 21707: 
 21708:       case 0b100_0000:  //$xx40: FSMOVE.* *m,FPn
 21709:         //  BSUN   常にクリア
 21710:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21711:         //  OPERR  常にクリア
 21712:         //  OVFL   常にクリア
 21713:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21714:         //  DZ     常にクリア
 21715:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21716:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21717:         epbSetRoundingPrec (EPB_PREC_SGL);
 21718:         epbFPn[nnn].sete (epbFPn[mmm]).finish ();
 21719:         break;
 21720: 
 21721:       case 0b100_0001:  //$xx41: FSSQRT.* *m,FPn
 21722:         //  BSUN   常にクリア
 21723:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21724:         //  OPERR  引数が-0を除く負数のときセット、それ以外はクリア
 21725:         //  OVFL   常にクリア
 21726:         //  UNFL   常にクリア
 21727:         //  DZ     常にクリア
 21728:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21729:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21730:         epbSetRoundingPrec (EPB_PREC_SGL);
 21731:         epbFPn[nnn].sqrt (epbFPn[mmm]);
 21732:         break;
 21733: 
 21734:         //case 0b100_0010:  //$xx42:
 21735:         //case 0b100_0011:  //$xx43:
 21736: 
 21737:       case 0b100_0100:  //$xx44: FDMOVE.* *m,FPn
 21738:         //  BSUN   常にクリア
 21739:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21740:         //  OPERR  常にクリア
 21741:         //  OVFL   常にクリア
 21742:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21743:         //  DZ     常にクリア
 21744:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21745:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21746:         epbSetRoundingPrec (EPB_PREC_DBL);
 21747:         epbFPn[nnn].sete (epbFPn[mmm]).finish ();
 21748:         break;
 21749: 
 21750:       case 0b100_0101:  //$xx45: FDSQRT.* *m,FPn
 21751:         //  BSUN   常にクリア
 21752:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21753:         //  OPERR  引数が-0を除く負数のときセット、それ以外はクリア
 21754:         //  OVFL   常にクリア
 21755:         //  UNFL   常にクリア
 21756:         //  DZ     常にクリア
 21757:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21758:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21759:         epbSetRoundingPrec (EPB_PREC_DBL);
 21760:         epbFPn[nnn].sqrt (epbFPn[mmm]);
 21761:         break;
 21762: 
 21763:         //case 0b100_0110:  //$xx46:
 21764:         //case 0b100_0111:  //$xx47:
 21765:         //case 0b100_1000:  //$xx48:
 21766:         //case 0b100_1001:  //$xx49:
 21767:         //case 0b100_1010:  //$xx4A:
 21768:         //case 0b100_1011:  //$xx4B:
 21769:         //case 0b100_1100:  //$xx4C:
 21770:         //case 0b100_1101:  //$xx4D:
 21771:         //case 0b100_1110:  //$xx4E:
 21772:         //case 0b100_1111:  //$xx4F:
 21773:         //case 0b101_0000:  //$xx50:
 21774:         //case 0b101_0001:  //$xx51:
 21775:         //case 0b101_0010:  //$xx52:
 21776:         //case 0b101_0011:  //$xx53:
 21777:         //case 0b101_0100:  //$xx54:
 21778:         //case 0b101_0101:  //$xx55:
 21779:         //case 0b101_0110:  //$xx56:
 21780:         //case 0b101_0111:  //$xx57:
 21781: 
 21782:       case 0b101_1000:  //$xx58: FSABS.* *m,FPn
 21783:         //  BSUN   常にクリア
 21784:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21785:         //  OPERR  常にクリア
 21786:         //  OVFL   常にクリア
 21787:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21788:         //  DZ     常にクリア
 21789:         //  INEX2  常にクリア
 21790:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21791:         epbSetRoundingPrec (EPB_PREC_SGL);
 21792:         epbFPn[nnn].abs (epbFPn[mmm]);
 21793:         break;
 21794: 
 21795:         //case 0b101_1001:  //$xx59:
 21796: 
 21797:       case 0b101_1010:  //$xx5A: FSNEG.* *m,FPn
 21798:         //  BSUN   常にクリア
 21799:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21800:         //  OPERR  常にクリア
 21801:         //  OVFL   常にクリア
 21802:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21803:         //  DZ     常にクリア
 21804:         //  INEX2  常にクリア
 21805:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21806:         epbSetRoundingPrec (EPB_PREC_SGL);
 21807:         epbFPn[nnn].neg (epbFPn[mmm]);
 21808:         break;
 21809: 
 21810:         //case 0b101_1011:  //$xx5B:
 21811: 
 21812:       case 0b101_1100:  //$xx5C: FDABS.* *m,FPn
 21813:         //  BSUN   常にクリア
 21814:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21815:         //  OPERR  常にクリア
 21816:         //  OVFL   常にクリア
 21817:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21818:         //  DZ     常にクリア
 21819:         //  INEX2  常にクリア
 21820:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21821:         epbSetRoundingPrec (EPB_PREC_DBL);
 21822:         epbFPn[nnn].abs (epbFPn[mmm]);
 21823:         break;
 21824: 
 21825:         //case 0b101_1101:  //$xx5D:
 21826: 
 21827:       case 0b101_1110:  //$xx5E: FDNEG.* *m,FPn
 21828:         //  BSUN   常にクリア
 21829:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21830:         //  OPERR  常にクリア
 21831:         //  OVFL   常にクリア
 21832:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21833:         //  DZ     常にクリア
 21834:         //  INEX2  常にクリア
 21835:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21836:         epbSetRoundingPrec (EPB_PREC_DBL);
 21837:         epbFPn[nnn].neg (epbFPn[mmm]);
 21838:         break;
 21839: 
 21840:         //case 0b101_1111:  //$xx5F:
 21841: 
 21842:       case 0b110_0000:  //$xx60: FSDIV.* *m,FPn
 21843:         //  BSUN   常にクリア
 21844:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21845:         //  OPERR  引数が両方ゼロまたは両方無限大のときセット、それ以外はクリア
 21846:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21847:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21848:         //  DZ     被除数がゼロ、無限大、NaN以外で除数がゼロのときセット、それ以外はクリア
 21849:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21850:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21851:         epbSetRoundingPrec (EPB_PREC_SGL);
 21852:         epbFPn[nnn].div (epbFPn[mmm]);
 21853:         break;
 21854: 
 21855:         //case 0b110_0001:  //$xx61:
 21856: 
 21857:       case 0b110_0010:  //$xx62: FSADD.* *m,FPn
 21858:         //  BSUN   常にクリア
 21859:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21860:         //  OPERR  引数が両方無限大で符号が異なるときセット、それ以外はクリア
 21861:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21862:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21863:         //  DZ     常にクリア
 21864:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21865:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21866:         epbSetRoundingPrec (EPB_PREC_SGL);
 21867:         epbFPn[nnn].add (epbFPn[mmm]);
 21868:         break;
 21869: 
 21870:       case 0b110_0011:  //$xx63: FSMUL.* *m,FPn
 21871:         //  BSUN   常にクリア
 21872:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21873:         //  OPERR  引数の一方がゼロで他方が無限大のときセット、それ以外はクリア
 21874:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21875:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21876:         //  DZ     常にクリア
 21877:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21878:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21879:         epbSetRoundingPrec (EPB_PREC_SGL);
 21880:         epbFPn[nnn].mul (epbFPn[mmm]);
 21881:         break;
 21882: 
 21883:       case 0b110_0100:  //$xx64: FDDIV.* *m,FPn
 21884:         //  BSUN   常にクリア
 21885:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21886:         //  OPERR  引数が両方ゼロまたは両方無限大のときセット、それ以外はクリア
 21887:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21888:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21889:         //  DZ     被除数がゼロ、無限大、NaN以外で除数がゼロのときセット、それ以外はクリア
 21890:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21891:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21892:         epbSetRoundingPrec (EPB_PREC_DBL);
 21893:         epbFPn[nnn].div (epbFPn[mmm]);
 21894:         break;
 21895: 
 21896:         //case 0b110_0101:  //$xx65:
 21897: 
 21898:       case 0b110_0110:  //$xx66: FDADD.* *m,FPn
 21899:         //  BSUN   常にクリア
 21900:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21901:         //  OPERR  引数が両方無限大で符号が異なるときセット、それ以外はクリア
 21902:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21903:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21904:         //  DZ     常にクリア
 21905:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21906:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21907:         epbSetRoundingPrec (EPB_PREC_DBL);
 21908:         epbFPn[nnn].add (epbFPn[mmm]);
 21909:         break;
 21910: 
 21911:       case 0b110_0111:  //$xx67: FDMUL.* *m,FPn
 21912:         //  BSUN   常にクリア
 21913:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21914:         //  OPERR  引数の一方がゼロで他方が無限大のときセット、それ以外はクリア
 21915:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21916:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21917:         //  DZ     常にクリア
 21918:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21919:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21920:         epbSetRoundingPrec (EPB_PREC_DBL);
 21921:         epbFPn[nnn].mul (epbFPn[mmm]);
 21922:         break;
 21923: 
 21924:       case 0b110_1000:  //$xx68: FSSUB.* *m,FPn
 21925:         //  BSUN   常にクリア
 21926:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21927:         //  OPERR  引数が両方無限大で符号が同じときセット、それ以外はクリア
 21928:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21929:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21930:         //  DZ     常にクリア
 21931:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21932:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21933:         epbSetRoundingPrec (EPB_PREC_SGL);
 21934:         epbFPn[nnn].sub (epbFPn[mmm]);
 21935:         break;
 21936: 
 21937:         //case 0b110_1001:  //$xx69:
 21938:         //case 0b110_1010:  //$xx6A:
 21939:         //case 0b110_1011:  //$xx6B:
 21940: 
 21941:       case 0b110_1100:  //$xx6C: FDSUB.* *m,FPn
 21942:         //    --------------------------------
 21943:         //    > cir 00 .
 21944:         //    0802 
 21945:         //    > cir 0a 4000
 21946:         //    > cir 00 ...
 21947:         //    9504 8900 8900 
 21948:         //    > cir 10 00000001
 21949:         //    > cir 00 ..
 21950:         //    0802 0802 
 21951:         //    > cir 0a 006c
 21952:         //    > cir 00 ...
 21953:         //    1C0B 1C0B 1C0B 
 21954:         //    > cir 02 0000
 21955:         //    > cir 00 ...
 21956:         //    0802 0802 0802 
 21957:         //    --------------------------------
 21958:         //  BSUN   常にクリア
 21959:         //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 21960:         //  OPERR  引数が両方無限大で符号が同じときセット、それ以外はクリア
 21961:         //  OVFL   オーバーフローしたときセット、それ以外はクリア
 21962:         //  UNFL   結果が非正規化数のときセット、それ以外はクリア
 21963:         //  DZ     常にクリア
 21964:         //  INEX2  結果に誤差があるときセット、それ以外はクリア
 21965:         //  INEX1  引数がpackedで正確に変換できないときセット、それ以外はクリア
 21966:         epbSetRoundingPrec (EPB_PREC_DBL);
 21967:         epbFPn[nnn].sub (epbFPn[mmm]);
 21968:         break;
 21969: 
 21970:         //case 0b110_1101:  //$xx6D:
 21971:         //case 0b110_1110:  //$xx6E:
 21972:         //case 0b110_1111:  //$xx6F:
 21973: 
 21974:       case 0b111_0000:  //$xx70: FLGAMMA *m,FPn
 21975:         if (EFPBox.EPB_EXTRA_OPERATION) {
 21976:           epbFPn[nnn].lgamma (epbFPn[mmm]);
 21977:         } else {
 21978:           cirException (0x1c0b);  //F-line emulator
 21979:         }
 21980:         break;
 21981: 
 21982:       case 0b111_0001:  //$xx71: FTGAMMA *m,FPn
 21983:         if (EFPBox.EPB_EXTRA_OPERATION) {
 21984:           epbFPn[nnn].tgamma (epbFPn[mmm]);
 21985:         } else {
 21986:           cirException (0x1c0b);  //F-line emulator
 21987:         }
 21988:         break;
 21989: 
 21990:         //case 0b111_0010:  //$xx72:
 21991:         //case 0b111_0011:  //$xx73:
 21992:         //case 0b111_0100:  //$xx74:
 21993:         //case 0b111_0101:  //$xx75:
 21994:         //case 0b111_0110:  //$xx76:
 21995:         //case 0b111_0111:  //$xx77:
 21996:         //case 0b111_1000:  //$xx78:
 21997:         //case 0b111_1001:  //$xx79:
 21998:         //case 0b111_1010:  //$xx7A:
 21999:         //case 0b111_1011:  //$xx7B:
 22000:         //case 0b111_1100:  //$xx7C:
 22001:         //case 0b111_1101:  //$xx7D:
 22002:         //case 0b111_1110:  //$xx7E:
 22003:         //case 0b111_1111:  //$xx7F:
 22004: 
 22005:       default:  //未定義
 22006:         cirException (0x1c0b);  //F-line emulator
 22007:         return;
 22008:       }
 22009:       //FPSRのFPCCを設定する
 22010:       epbFpsr |= epbFPn[nnn].flg >>> 4;
 22011:       if (cirMidInstruction ()) {
 22012:         return;
 22013:       }
 22014:       //終了
 22015:       cirIdle (0x0802);
 22016:       return;
 22017: 
 22018: 
 22019:     case 0b011:  //$6xxx-$7xxx: FMOVE.* FPn,<ea>
 22020:       //  BSUN   常にクリア
 22021:       //  SNAN   引数がシグナリングNaNのときセット、それ以外はクリア
 22022:       //  OPERR  byte,word,longで無限大または指定されたサイズに収まらないとき、packedでk-factorが17よりも大きいか指数部が3桁に収まらないときセット、それ以外はクリア
 22023:       //  OVFL   packedではなくてオーバーフローしたときセット、それ以外はクリア
 22024:       //  UNFL   packedではなくて結果が非正規化数のときセット、それ以外はクリア
 22025:       //  DZ     常にクリア
 22026:       //  INEX2  結果に誤差があるときセット、それ以外はクリア
 22027:       //  INEX1  常にクリア
 22028:       if (cirStage == CIR_IDLE) {  //開始
 22029:         epbFpsr &= 0xffff00ff;  //FMOVE.* FPn,<ea>でFPSRのコンディションコードバイトは変化しない
 22030:       } else if (cirStage == CIR_DESTINATION_OPERAND) {  //デスティネーションオペランド転送終了
 22031:         //終了
 22032:         cirIdle (0x0802);
 22033:         return;
 22034:       }
 22035: 
 22036:       switch (mmm) {
 22037: 
 22038:       case 0b000:  //$60xx-$63xx: FMOVE.L FPn,<ea>
 22039:         //    --------------------------------
 22040:         //    > cir 00 .
 22041:         //    0802 
 22042:         //    > cir 0a 4000
 22043:         //    > cir 00 ...
 22044:         //    9504 8900 8900 
 22045:         //    > cir 10 00000001
 22046:         //    > cir 00 .
 22047:         //    0802 
 22048:         //    > cir 0a 6000
 22049:         //    > cir 00 ...
 22050:         //    8900 B104 0802 
 22051:         //    > cir 10 .
 22052:         //    00000001 
 22053:         //    > cir 00 ..
 22054:         //    0802 0802 
 22055:         //    --------------------------------
 22056:         cirOperandBuffer[0] = epbFPn[nnn].geti (epbRoundingMode);
 22057:         if (cirMidInstruction ()) {
 22058:           return;
 22059:         }
 22060:         cirResponse = 0x8900_b104;  //(come-again→)ロングのデータを出力する→come-again
 22061:         cirOperandLength = 1;
 22062:         cirOperandIndex = 0;
 22063:         cirStage = CIR_DESTINATION_OPERAND;  //デスティネーションオペランド転送開始
 22064:         break;
 22065: 
 22066:       case 0b001:  //$64xx-$67xx: FMOVE.S FPn,<ea>
 22067:         //    --------------------------------
 22068:         //    > cir 00 .
 22069:         //    0802 
 22070:         //    > cir 0a 4000
 22071:         //    > cir 00 ...
 22072:         //    9504 8900 8900 
 22073:         //    > cir 10 00000001
 22074:         //    > cir 00 .
 22075:         //    0802 
 22076:         //    > cir 0a 6400
 22077:         //    > cir 00 ....
 22078:         //    8900 3104 0802 0802 
 22079:         //    > cir 10 .
 22080:         //    3F800000 
 22081:         //    > cir 00 ..
 22082:         //    0802 0802 
 22083:         //    --------------------------------
 22084:         cirOperandBuffer[0] = epbFPn[nnn].getf0 (epbRoundingMode);
 22085:         if (cirMidInstruction ()) {
 22086:           return;
 22087:         }
 22088:         if ((epbMode & EPB_MODE_MC68882) != 0) {  //MC68882
 22089:           cirResponse = 0x8900_3104;  //(come-again→)ロングのデータを出力する→come-again
 22090:         } else {  //MC68881
 22091:           cirResponse = 0x8900_b104;  //(come-again→)ロングのデータを出力する→come-again
 22092:         }
 22093:         cirOperandLength = 1;
 22094:         cirOperandIndex = 0;
 22095:         cirStage = CIR_DESTINATION_OPERAND;  //デスティネーションオペランド転送開始
 22096:         break;
 22097: 
 22098:       case 0b010:  //$68xx-$6Bxx: FMOVE.X FPn,<ea>
 22099:         //    --------------------------------
 22100:         //    > cir 00 .
 22101:         //    0802 
 22102:         //    > cir 0a 4000
 22103:         //    > cir 00 ...
 22104:         //    9504 8900 8900 
 22105:         //    > cir 10 00000001
 22106:         //    > cir 00 .
 22107:         //    0802 
 22108:         //    > cir 0a 6800
 22109:         //    > cir 00 ....
 22110:         //    8900 320C 8900 8900 
 22111:         //    > cir 10 .
 22112:         //    3FFF0000 
 22113:         //    > cir 00 ..
 22114:         //    8900 8900 
 22115:         //    > cir 10 .
 22116:         //    80000000 
 22117:         //    > cir 00 ..
 22118:         //    0802 0802 
 22119:         //    > cir 10 .
 22120:         //    00000000 
 22121:         //    > cir 00 ..
 22122:         //    0802 0802 
 22123:         //    --------------------------------
 22124:         {
 22125:           byte[] b = new byte[12];
 22126:           if (epbIsTriple ()) {  //三倍精度
 22127:             epbFPn[nnn].gety012 (b, 0, epbRoundingMode);
 22128:           } else {  //拡張精度
 22129:             epbFPn[nnn].getx012 (b, 0, epbRoundingMode);
 22130:           }
 22131:           if (cirMidInstruction ()) {
 22132:             return;
 22133:           }
 22134:           cirOperandBuffer[0] = b[0] << 24 | (b[1] & 255) << 16 | (char) (b[2] << 8 | b[3] & 255);
 22135:           cirOperandBuffer[1] = b[4] << 24 | (b[5] & 255) << 16 | (char) (b[6] << 8 | b[7] & 255);
 22136:           cirOperandBuffer[2] = b[8] << 24 | (b[9] & 255) << 16 | (char) (b[10] << 8 | b[11] & 255);
 22137:           if ((epbMode & EPB_MODE_MC68882) != 0) {  //MC68882
 22138:             cirResponse = 0x8900_320c;  //(come-again→)エクステンデッドのデータを出力する→come-again
 22139:           } else {  //MC68881
 22140:             cirResponse = 0x8900_320c;  //(come-again→)エクステンデッドのデータを出力する→come-again
 22141:           }
 22142:           cirOperandLength = 3;
 22143:           cirOperandIndex = 0;
 22144:           cirStage = CIR_DESTINATION_OPERAND;  //デスティネーションオペランド転送開始
 22145:           break;
 22146:         }
 22147: 
 22148:       case 0b011:  //$6Cxx-$6Fxx: FMOVE.P FPn,<ea>{#k}
 22149:         //    --------------------------------
 22150:         //    > cir 00 .
 22151:         //    0802 
 22152:         //    > cir 0a 4000
 22153:         //    > cir 00 ...
 22154:         //    9504 8900 8900 
 22155:         //    > cir 10 00000001
 22156:         //    > cir 00 .
 22157:         //    0802 
 22158:         //    > cir 0a 6c00
 22159:         //    > cir 00 ....
 22160:         //    8900 B20C 8900 8900 
 22161:         //    > cir 10 .
 22162:         //    00000001 
 22163:         //    > cir 00 ..
 22164:         //    8900 8900 
 22165:         //    > cir 10 .
 22166:         //    00000000 
 22167:         //    > cir 00 ..
 22168:         //    0802 0802 
 22169:         //    > cir 10 .
 22170:         //    00000000 
 22171:         //    > cir 00 ..
 22172:         //    0802 0802 
 22173:         //    --------------------------------
 22174:         //    > cir 00 .
 22175:         //    0802 
 22176:         //    > cir 0a 5c00
 22177:         //    > cir 00 ..
 22178:         //    0900 0802 
 22179:         //    > cir 0a 6c7e
 22180:         //    > cir 00 ....
 22181:         //    8900 B20C 8900 8900 
 22182:         //    > cir 10 ...
 22183:         //    00000003 14000000 00000000 
 22184:         //    > cir 00 ..
 22185:         //    0802 0802 
 22186:         //    > cir 0a 6c7f
 22187:         //    > cir 00 ....
 22188:         //    8900 B20C 8900 8900 
 22189:         //    > cir 10 ...
 22190:         //    00000003 10000000 00000000 
 22191:         //    > cir 00 ..
 22192:         //    0802 0802 
 22193:         //    > cir 0a 6c00
 22194:         //    > cir 00 ....
 22195:         //    8900 B20C 8900 8900 
 22196:         //    > cir 10 ...
 22197:         //    00000003 00000000 00000000 
 22198:         //    > cir 00 ..
 22199:         //    0802 0802 
 22200:         //    > cir 0a 6c01
 22201:         //    > cir 00 ....
 22202:         //    8900 B20C 8900 8900 
 22203:         //    > cir 10 ...
 22204:         //    00000003 00000000 00000000 
 22205:         //    > cir 00 ..
 22206:         //    0802 0802 
 22207:         //    > cir 0a 6c02
 22208:         //    > cir 00 ....
 22209:         //    8900 B20C 8900 8900 
 22210:         //    > cir 10 ...
 22211:         //    00000003 10000000 00000000 
 22212:         //    > cir 00 ..
 22213:         //    0802 0802 
 22214:         //    > cir 0a 6c03
 22215:         //    > cir 00 ....
 22216:         //    8900 B20C 8900 8900 
 22217:         //    > cir 10 ...
 22218:         //    00000003 14000000 00000000 
 22219:         //    > cir 00 ..
 22220:         //    0802 0802 
 22221:         //    > cir 0a 6c04
 22222:         //    > cir 00 ....
 22223:         //    8900 B20C 8900 8900 
 22224:         //    > cir 10 ...
 22225:         //    00000003 14200000 00000000 
 22226:         //    > cir 00 ..
 22227:         //    0802 0802 
 22228:         //    > cir 0a 6c05
 22229:         //    > cir 00 ....
 22230:         //    8900 B20C 8900 8900 
 22231:         //    > cir 10 ...
 22232:         //    00000003 14160000 00000000 
 22233:         //    > cir 00 ..
 22234:         //    0802 0802 
 22235:         //    > cir 0a 6c7d
 22236:         //    > cir 00 ....
 22237:         //    8900 B20C 8900 8900 
 22238:         //    > cir 10 ...
 22239:         //    00000003 14200000 00000000 
 22240:         //    > cir 00 ..
 22241:         //    0802 0802 
 22242:         //    > cir 0a 6c7c
 22243:         //    > cir 00 ....
 22244:         //    8900 B20C 8900 8900 
 22245:         //    > cir 10 ...
 22246:         //    00000003 14160000 00000000 
 22247:         //    > cir 00 ..
 22248:         //    0802 0802 
 22249:         //    --------------------------------
 22250:         {
 22251:           byte[] b = new byte[12];
 22252:           epbFPn[nnn].getp012 (b, 0, ccccccc);  //k-factor付き
 22253:           if (cirMidInstruction ()) {
 22254:             return;
 22255:           }
 22256:           cirOperandBuffer[0] = b[0] << 24 | (b[1] & 255) << 16 | (char) (b[2] << 8 | b[3] & 255);
 22257:           cirOperandBuffer[1] = b[4] << 24 | (b[5] & 255) << 16 | (char) (b[6] << 8 | b[7] & 255);
 22258:           cirOperandBuffer[2] = b[8] << 24 | (b[9] & 255) << 16 | (char) (b[10] << 8 | b[11] & 255);
 22259:           cirResponse = 0x8900_b20c;  //(come-again→)パックトのデータを出力する→come-again
 22260:           cirOperandLength = 3;
 22261:           cirOperandIndex = 0;
 22262:           cirStage = CIR_DESTINATION_OPERAND;  //デスティネーションオペランド転送開始
 22263:           break;
 22264:         }
 22265: 
 22266:       case 0b100:  //$70xx-$73xx: FMOVE.W FPn,<ea>
 22267:         //    --------------------------------
 22268:         //    > cir 00 .
 22269:         //    0802 
 22270:         //    > cir 0a 4000
 22271:         //    > cir 00 ...
 22272:         //    9504 8900 8900 
 22273:         //    > cir 10 00000001
 22274:         //    > cir 00 .
 22275:         //    0802 
 22276:         //    > cir 0a 7000
 22277:         //    > cir 00 ....
 22278:         //    8900 B102 0802 0802 
 22279:         //    > cir 10 .
 22280:         //    00010000 
 22281:         //    > cir 00 ..
 22282:         //    0802 0802 
 22283:         //    --------------------------------
 22284:         cirOperandBuffer[0] = epbFPn[nnn].gets (epbRoundingMode) << 16;  //左詰めにする
 22285:         if (cirMidInstruction ()) {
 22286:           return;
 22287:         }
 22288:         cirResponse = 0x8900_b102;  //(come-again→)ワードのデータを出力する→come-again
 22289:         cirOperandLength = 1;
 22290:         cirOperandIndex = 0;
 22291:         cirStage = CIR_DESTINATION_OPERAND;  //デスティネーションオペランド転送開始
 22292:         break;
 22293: 
 22294:       case 0b101:  //$74xx-$77xx: FMOVE.D FPn,<ea>
 22295:         //    --------------------------------
 22296:         //    > cir 00 .
 22297:         //    0802 
 22298:         //    > cir 0a 4000
 22299:         //    > cir 00 ...
 22300:         //    9504 8900 8900 
 22301:         //    > cir 10 00000001
 22302:         //    > cir 00 .
 22303:         //    0802 
 22304:         //    > cir 0a 7400
 22305:         //    > cir 00 ....
 22306:         //    8900 3208 8900 8900 
 22307:         //    > cir 10 .
 22308:         //    3FF00000 
 22309:         //    > cir 00 ..
 22310:         //    0802 0802 
 22311:         //    > cir 10 .
 22312:         //    00000000 
 22313:         //    > cir 00 ..
 22314:         //    0802 0802 
 22315:         //    --------------------------------
 22316:         {
 22317:           long l = epbFPn[nnn].getd01 (epbRoundingMode);
 22318:           if (cirMidInstruction ()) {
 22319:             return;
 22320:           }
 22321:           cirOperandBuffer[0] = (int) (l >> 32);
 22322:           cirOperandBuffer[1] = (int) l;
 22323:           if ((epbMode & EPB_MODE_MC68882) != 0) {  //MC68882
 22324:             cirResponse = 0x8900_3208;  //(come-again→)ダブルのデータを出力する→come-again
 22325:           } else {
 22326:             cirResponse = 0x8900_b208;  //(come-again→)ダブルのデータを出力する→come-again
 22327:           }
 22328:           cirOperandLength = 2;
 22329:           cirOperandIndex = 0;
 22330:           cirStage = CIR_DESTINATION_OPERAND;  //デスティネーションオペランド転送開始
 22331:         }
 22332:         break;
 22333: 
 22334:       case 0b110:  //$78xx-$7Bxx: FMOVE.B FPn,<ea>
 22335:         //    --------------------------------
 22336:         //    > cir 00 .
 22337:         //    0802 
 22338:         //    > cir 0a 4000
 22339:         //    > cir 00 ....
 22340:         //    9504 8900 8900 8900 
 22341:         //    > cir 10 00000001
 22342:         //    > cir 00 .
 22343:         //    0802 
 22344:         //    > cir 0a 7800
 22345:         //    > cir 00 ....
 22346:         //    8900 B101 0802 0802 
 22347:         //    > cir 10 .
 22348:         //    01000000 
 22349:         //    > cir 00 ..
 22350:         //    0802 0802 
 22351:         //    --------------------------------
 22352:         cirOperandBuffer[0] = epbFPn[nnn].getb (epbRoundingMode) << 24;  //左詰めにする
 22353:         if (cirMidInstruction ()) {
 22354:           return;
 22355:         }
 22356:         cirResponse = 0x8900_b101;  //(come-again→)バイトのデータを出力する→come-again
 22357:         cirOperandLength = 1;
 22358:         cirOperandIndex = 0;
 22359:         cirStage = CIR_DESTINATION_OPERAND;  //デスティネーションオペランド転送開始
 22360:         break;
 22361: 
 22362:       case 0b111:  //$7Cxx-$7Fxx: FMOVE.P FPn,<ea>{Dl}
 22363:         //    --------------------------------
 22364:         //    > cir 00 .
 22365:         //    0802 
 22366:         //    > cir 0a 4000
 22367:         //    > cir 00 ...
 22368:         //    9504 8900 8900 
 22369:         //    > cir 10 00000100
 22370:         //    > cir 00 .
 22371:         //    0802 
 22372:         //    > cir 0a 7c00
 22373:         //    > cir 00 ....
 22374:         //    8C00 8900 8900 8900 
 22375:         //    > cir 10 00000005
 22376:         //    > cir 00 ...
 22377:         //    B20C 8900 8900 
 22378:         //    > cir 10 .
 22379:         //    00020002 
 22380:         //    > cir 00 ..
 22381:         //    8900 8900 
 22382:         //    > cir 10 .
 22383:         //    56000000 
 22384:         //    > cir 00 ..
 22385:         //    0802 0802 
 22386:         //    > cir 10 .
 22387:         //    00000000 
 22388:         //    > cir 00 ..
 22389:         //    0802 0802 
 22390:         //    --------------------------------
 22391:       default:
 22392:         if (cirStage == CIR_IDLE) {  //開始
 22393:           cirResponse = 0x8900_8c00 + (cirCommand >> 4 & 7);  //データレジスタを入力する→come-again
 22394:           cirOperandLength = 1;
 22395:           cirOperandIndex = 0;
 22396:           cirStage = CIR_DYNAMIC_K_FACTOR;  //動的k-factor転送開始
 22397:           return;
 22398:         } else if (cirStage == CIR_DYNAMIC_K_FACTOR) {  //動的k-factor転送終了
 22399:           byte[] b = new byte[12];
 22400:           epbFPn[nnn].getp012 (b, 0, cirOperandBuffer[0]);  //k-factor付き
 22401:           if (cirMidInstruction ()) {
 22402:             return;
 22403:           }
 22404:           cirOperandBuffer[0] = b[0] << 24 | (b[1] & 255) << 16 | (char) (b[2] << 8 | b[3] & 255);
 22405:           cirOperandBuffer[1] = b[4] << 24 | (b[5] & 255) << 16 | (char) (b[6] << 8 | b[7] & 255);
 22406:           cirOperandBuffer[2] = b[8] << 24 | (b[9] & 255) << 16 | (char) (b[10] << 8 | b[11] & 255);
 22407:           cirResponse = 0x8900_b20c;  //(come-again→)パックトのデータを出力する→come-again
 22408:           cirOperandLength = 3;
 22409:           cirOperandIndex = 0;
 22410:           cirStage = CIR_DESTINATION_OPERAND;  //デスティネーションオペランド転送開始
 22411:         }
 22412:       }
 22413:       return;
 22414: 
 22415: 
 22416:     case 0b100:  //$8xxx-$9xxx: FMOVEM.L <ea>,FPCR/FPSR/FPIAR
 22417:       //  FMOVEM命令は例外を発生させずFPCR/FPSR/FPIARも(デスティネーションに書かれたもの以外)変化しない
 22418:       //  格納順序はFPCRが下位アドレス(連結したとき上位),FPIARが上位アドレス(連結したとき下位)
 22419: 
 22420:       switch (mmm) {
 22421: 
 22422:       case 0b000:  //$8000: FMOVE.L <ea>,<>
 22423:         //    --------------------------------
 22424:         //    > cir 00 .
 22425:         //    0802 
 22426:         //    > cir 0a 8000
 22427:         //    > cir 00 ....
 22428:         //    8900 9704 8900 8900 
 22429:         //    > cir 10 00000000
 22430:         //    > cir 00 ..
 22431:         //    0802 0802 
 22432:         //    --------------------------------
 22433:         //  レジスタを1個も指定しないとFPIARが指定されたものとみなされる
 22434: 
 22435:       case 0b001:  //$8400: FMOVE.L <ea>,FPIAR
 22436:         //    --------------------------------
 22437:         //    > cir 00 .
 22438:         //    0802 
 22439:         //    > cir 0a 8400
 22440:         //    > cir 00 ....
 22441:         //    8900 9704 8900 8900 
 22442:         //    > cir 10 00000000
 22443:         //    > cir 00 ..
 22444:         //    0802 0802 
 22445:         //    --------------------------------
 22446:         if (cirStage == CIR_IDLE) {  //開始
 22447:           cirResponse = 0x8900_9704;  //FPIARを入力する→come_again
 22448:           cirOperandLength = 1;
 22449:           cirOperandIndex = 0;
 22450:           cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 22451:           return;
 22452:         } else {  //ソースオペランド転送終了
 22453:           epbFpiar = cirOperandBuffer[0];
 22454:         }
 22455:         break;
 22456: 
 22457:       case 0b010:  //$8800: FMOVE.L <ea>,FPSR
 22458:         //  fmove.lでfpsrのEXCに書き込んだだけではAEXCは更新されない
 22459:         //  fmove.lでfpsrに0x0000ff00を書き込んですぐに読み出しても0x0000ff00のまま
 22460:         //    --------------------------------
 22461:         //    > cir 00 .
 22462:         //    0802 
 22463:         //    > cir 0a 8800
 22464:         //    > cir 00 ....
 22465:         //    8900 9504 8900 8900 
 22466:         //    > cir 10 00000000
 22467:         //    > cir 00 ..
 22468:         //    0802 0802 
 22469:         //    --------------------------------
 22470:         if (cirStage == CIR_IDLE) {  //開始
 22471:           cirResponse = 0x8900_9504;  //FPSRを入力する→come_again
 22472:           cirOperandLength = 1;
 22473:           cirOperandIndex = 0;
 22474:           cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 22475:           return;
 22476:         } else {  //ソースオペランド転送終了
 22477:           epbFpsr = cirOperandBuffer[0] & EPB_FPSR_ALL;
 22478:         }
 22479:         break;
 22480: 
 22481:       case 0b011:  //$8C00: FMOVEM.L <ea>,FPSR/FPIAR
 22482:         //    --------------------------------
 22483:         //    > cir 00 .
 22484:         //    0802 
 22485:         //    > cir 0a 8c00
 22486:         //    > cir 00 ....
 22487:         //    8900 9608 8900 8900 
 22488:         //    > cir 10 00000000
 22489:         //    > cir 00 ..
 22490:         //    8900 8900 
 22491:         //    > cir 10 00000000
 22492:         //    > cir 00 ..
 22493:         //    0802 0802 
 22494:         //    --------------------------------
 22495:         if (cirStage == CIR_IDLE) {  //開始
 22496:           cirResponse = 0x8900_9608;  //FPSR/FPIARを入力する→come_again
 22497:           cirOperandLength = 2;
 22498:           cirOperandIndex = 0;
 22499:           cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 22500:           return;
 22501:         } else {  //ソースオペランド転送終了
 22502:           epbFpsr = cirOperandBuffer[0] & EPB_FPSR_ALL;
 22503:           epbFpiar = cirOperandBuffer[1];
 22504:         }
 22505:         break;
 22506: 
 22507:       case 0b100:  //$9000: FMOVE.L <ea>,FPCR
 22508:         //    --------------------------------
 22509:         //    > cir 00 .
 22510:         //    0802 
 22511:         //    > cir 0a 9000
 22512:         //    > cir 00 ....
 22513:         //    8900 9504 8900 8900 
 22514:         //    > cir 10 00000000
 22515:         //    > cir 00 ..
 22516:         //    0802 0802 
 22517:         //    --------------------------------
 22518:         if (cirStage == CIR_IDLE) {  //開始
 22519:           cirResponse = 0x8900_9504;  //FPCRを入力する→come_again
 22520:           cirOperandLength = 1;
 22521:           cirOperandIndex = 0;
 22522:           cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 22523:           return;
 22524:         } else {  //ソースオペランド転送終了
 22525:           epbFpcr = cirOperandBuffer[0] & EPB_FPCR_ALL;
 22526:         }
 22527:         break;
 22528: 
 22529:       case 0b101:  //$9400: FMOVEM.L <ea>,FPCR/FPIAR
 22530:         //    --------------------------------
 22531:         //    > cir 00 .
 22532:         //    0802 
 22533:         //    > cir 0a 9400
 22534:         //    > cir 00 ....
 22535:         //    8900 9608 8900 8900 
 22536:         //    > cir 10 00000000
 22537:         //    > cir 00 ..
 22538:         //    8900 8900 
 22539:         //    > cir 10 00000000
 22540:         //    > cir 00 ..
 22541:         //    0802 0802 
 22542:         //    --------------------------------
 22543:         if (cirStage == CIR_IDLE) {  //開始
 22544:           cirResponse = 0x8900_9608;  //FPCR/FPIARを入力する→come_again
 22545:           cirOperandLength = 2;
 22546:           cirOperandIndex = 0;
 22547:           cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 22548:           return;
 22549:         } else {  //ソースオペランド転送終了
 22550:           epbFpcr = cirOperandBuffer[0] & EPB_FPCR_ALL;
 22551:           epbFpiar = cirOperandBuffer[1];
 22552:         }
 22553:         break;
 22554: 
 22555:       case 0b110:  //$9800: FMOVEM.L <ea>,FPCR/FPSR
 22556:         //    --------------------------------
 22557:         //    > cir 00 .
 22558:         //    0802 
 22559:         //    > cir 0a 9800
 22560:         //    > cir 00 ....
 22561:         //    8900 9608 8900 8900 
 22562:         //    > cir 10 00000000
 22563:         //    > cir 00 ..
 22564:         //    8900 8900 
 22565:         //    > cir 10 00000000
 22566:         //    > cir 00 ..
 22567:         //    0802 0802 
 22568:         //    --------------------------------
 22569:         if (cirStage == CIR_IDLE) {  //開始
 22570:           cirResponse = 0x8900_9608;  //FPCR/FPSRを入力する→come_again
 22571:           cirOperandLength = 2;
 22572:           cirOperandIndex = 0;
 22573:           cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 22574:           return;
 22575:         } else {  //ソースオペランド転送終了
 22576:           epbFpcr = cirOperandBuffer[0] & EPB_FPCR_ALL;
 22577:           epbFpsr = cirOperandBuffer[1] & EPB_FPSR_ALL;
 22578:         }
 22579:         break;
 22580: 
 22581:       case 0b111:  //$9C00: FMOVEM.L <ea>,FPCR/FPSR/FPIAR
 22582:         //    --------------------------------
 22583:         //    > cir 00 .
 22584:         //    0802 
 22585:         //    > cir 0a 9c00
 22586:         //    > cir 00 ....
 22587:         //    8900 960C 8900 8900 
 22588:         //    > cir 10 00000000
 22589:         //    > cir 00 ..
 22590:         //    8900 8900 
 22591:         //    > cir 10 00000000
 22592:         //    > cir 00 ..
 22593:         //    8900 8900 
 22594:         //    > cir 10 00000000
 22595:         //    > cir 00 ..
 22596:         //    0802 0802 
 22597:         //    --------------------------------
 22598:       default:
 22599:         if (cirStage == CIR_IDLE) {  //開始
 22600:           cirResponse = 0x8900_960c;  //FPCR/FPSR/FPIARを入力する→come_again
 22601:           cirOperandLength = 3;
 22602:           cirOperandIndex = 0;
 22603:           cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 22604:           return;
 22605:         } else {  //ソースオペランド転送終了
 22606:           epbFpcr = cirOperandBuffer[0] & EPB_FPCR_ALL;
 22607:           epbFpsr = cirOperandBuffer[1] & EPB_FPSR_ALL;
 22608:           epbFpiar = cirOperandBuffer[2];
 22609:         }
 22610:       }
 22611:       //終了
 22612:       cirIdle (0x0802);
 22613:       return;
 22614: 
 22615: 
 22616:     case 0b101:  //$Axxx-$Bxxx: FMOVEM.L FPCR/FPSR/FPIAR,<ea>
 22617:       //  FMOVEM命令は例外を発生させずFPCR/FPSR/FPIARも(デスティネーションに書かれたもの以外)変化しない
 22618:       //  格納順序はFPCRが下位アドレス(連結したとき上位),FPIARが上位アドレス(連結したとき下位)
 22619:       if (cirStage == CIR_DESTINATION_OPERAND) {  //デスティネーションオペランド転送終了
 22620:         //終了
 22621:         cirIdle (0x0802);
 22622:         return;
 22623:       }
 22624: 
 22625:       switch (mmm) {
 22626: 
 22627:       case 0b000:  //$A000: FMOVE.L <>,<ea>
 22628:         //  レジスタを1個も指定しないとFPIARが指定されたものとみなされる
 22629:         //    --------------------------------
 22630:         //    > cir 00 .
 22631:         //    0802 
 22632:         //    > cir 0a a000
 22633:         //    > cir 00 ....
 22634:         //    8900 B304 0802 0802 
 22635:         //    > cir 10 .
 22636:         //    00000000 
 22637:         //    > cir 00 ..
 22638:         //    0802 0802 
 22639:         //    --------------------------------
 22640: 
 22641:       case 0b001:  //$A400: FMOVE.L FPIAR,<ea>
 22642:         //    --------------------------------
 22643:         //    > cir 00 .
 22644:         //    0802 
 22645:         //    > cir 0a a400
 22646:         //    > cir 00 ....
 22647:         //    8900 B304 0802 0802 
 22648:         //    > cir 10 .
 22649:         //    00000000 
 22650:         //    > cir 00 ..
 22651:         //    0802 0802 
 22652:         //    --------------------------------
 22653:         cirOperandBuffer[0] = epbFpiar;
 22654:         cirResponse = 0x8900_b304;  //FPIARを出力する→come_again
 22655:         cirOperandLength = 1;
 22656:         cirOperandIndex = 0;
 22657:         cirStage = CIR_DESTINATION_OPERAND;  //デスティネーションオペランド転送開始
 22658:         return;
 22659: 
 22660:       case 0b010:  //$A800: FMOVE.L FPSR,<ea>
 22661:         //    --------------------------------
 22662:         //    > cir 00 .
 22663:         //    0802 
 22664:         //    > cir 0a a800
 22665:         //    > cir 00 ....
 22666:         //    8900 B104 0802 0802 
 22667:         //    > cir 10 .
 22668:         //    00000000 
 22669:         //    > cir 00 ..
 22670:         //    0802 0802 
 22671:         //    --------------------------------
 22672:         cirOperandBuffer[0] = epbFpsr;
 22673:         cirResponse = 0x8900_b104;  //FPSRを出力する→come_again
 22674:         cirOperandLength = 1;
 22675:         cirOperandIndex = 0;
 22676:         cirStage = CIR_DESTINATION_OPERAND;  //デスティネーションオペランド転送開始
 22677:         return;
 22678: 
 22679:       case 0b011:  //$AC00: FMOVEM.L FPSR/FPIAR,<ea>
 22680:         //    --------------------------------
 22681:         //    > cir 00 .
 22682:         //    0802 
 22683:         //    > cir 0a ac00
 22684:         //    > cir 00 ....
 22685:         //    8900 B208 8900 8900 
 22686:         //    > cir 10 .
 22687:         //    00000000 
 22688:         //    > cir 00 ..
 22689:         //    0802 0802 
 22690:         //    > cir 10 .
 22691:         //    00000000 
 22692:         //    > cir 00 ..
 22693:         //    0802 0802 
 22694:         //    --------------------------------
 22695:         cirOperandBuffer[0] = epbFpsr;
 22696:         cirOperandBuffer[1] = epbFpiar;
 22697:         cirResponse = 0x8900_b208;  //FPSR/FPIARを出力する→come_again
 22698:         cirOperandLength = 2;
 22699:         cirOperandIndex = 0;
 22700:         cirStage = CIR_DESTINATION_OPERAND;  //デスティネーションオペランド転送開始
 22701:         return;
 22702: 
 22703:       case 0b100:  //$B000: FMOVE.L FPCR,<ea>
 22704:         //    --------------------------------
 22705:         //    > cir 00 .
 22706:         //    0802 
 22707:         //    > cir 0a b000
 22708:         //    > cir 00 ....
 22709:         //    8900 B104 0802 0802 
 22710:         //    > cir 10 .
 22711:         //    00000000 
 22712:         //    > cir 00 ..
 22713:         //    0802 0802 
 22714:         //    --------------------------------
 22715:         cirOperandBuffer[0] = epbFpcr;
 22716:         cirResponse = 0x8900_b104;  //FPCRを出力する→come_again
 22717:         cirOperandLength = 1;
 22718:         cirOperandIndex = 0;
 22719:         cirStage = CIR_DESTINATION_OPERAND;  //デスティネーションオペランド転送開始
 22720:         return;
 22721: 
 22722:       case 0b101:  //$B400: FMOVEM.L FPCR/FPIAR,<ea>
 22723:         //    --------------------------------
 22724:         //    > cir 00 .
 22725:         //    0802 
 22726:         //    > cir 0a b400
 22727:         //    > cir 00 ....
 22728:         //    8900 B208 8900 8900 
 22729:         //    > cir 10 .
 22730:         //    00000000 
 22731:         //    > cir 00 ..
 22732:         //    0802 0802 
 22733:         //    > cir 10 .
 22734:         //    00000000 
 22735:         //    > cir 00 ..
 22736:         //    0802 0802 
 22737:         //    --------------------------------
 22738:         cirOperandBuffer[0] = epbFpcr;
 22739:         cirOperandBuffer[1] = epbFpiar;
 22740:         cirResponse = 0x8900_b208;  //FPCR/FPIARを出力する→come_again
 22741:         cirOperandLength = 2;
 22742:         cirOperandIndex = 0;
 22743:         cirStage = CIR_DESTINATION_OPERAND;  //デスティネーションオペランド転送開始
 22744:         return;
 22745: 
 22746:       case 0b110:  //$B800: FMOVEM.L FPCR/FPSR,<ea>
 22747:         //    --------------------------------
 22748:         //    > cir 00 .
 22749:         //    0802 
 22750:         //    > cir 0a b800
 22751:         //    > cir 00 ....
 22752:         //    8900 B208 8900 8900 
 22753:         //    > cir 10 .
 22754:         //    00000000 
 22755:         //    > cir 00 ..
 22756:         //    0802 0802 
 22757:         //    > cir 10 .
 22758:         //    00000000 
 22759:         //    > cir 00 ..
 22760:         //    0802 0802 
 22761:         //    --------------------------------
 22762:         cirOperandBuffer[0] = epbFpcr;
 22763:         cirOperandBuffer[1] = epbFpsr;
 22764:         cirResponse = 0x8900_b208;  //FPCR/FPSRを出力する→come_again
 22765:         cirOperandLength = 2;
 22766:         cirOperandIndex = 0;
 22767:         cirStage = CIR_DESTINATION_OPERAND;  //デスティネーションオペランド転送開始
 22768:         return;
 22769: 
 22770:       case 0b111:  //$BC00: FMOVEM.L FPCR/FPSR/FPIAR,<ea>
 22771:         //    --------------------------------
 22772:         //    > cir 00 .
 22773:         //    0802 
 22774:         //    > cir 0a bc00
 22775:         //    > cir 00 ....
 22776:         //    8900 B20C 8900 8900 
 22777:         //    > cir 10 .
 22778:         //    00000000 
 22779:         //    > cir 00 ..
 22780:         //    8900 8900 
 22781:         //    > cir 10 .
 22782:         //    00000000 
 22783:         //    > cir 00 ..
 22784:         //    0802 0802 
 22785:         //    > cir 10 .
 22786:         //    00000000 
 22787:         //    > cir 00 ..
 22788:         //    0802 0802 
 22789:         //    --------------------------------
 22790:       default:
 22791:         cirOperandBuffer[0] = epbFpcr;
 22792:         cirOperandBuffer[1] = epbFpsr;
 22793:         cirOperandBuffer[2] = epbFpiar;
 22794:         cirResponse = 0x8900_b20c;  //FPCR/FPSR/FPIARを出力する→come_again
 22795:         cirOperandLength = 3;
 22796:         cirOperandIndex = 0;
 22797:         cirStage = CIR_DESTINATION_OPERAND;  //デスティネーションオペランド転送開始
 22798:         return;
 22799:       }
 22800:       //break;
 22801: 
 22802: 
 22803:     case 0b110:  //$Cxxx-$Dxxx: FMOVEM.X <ea>,<list>
 22804:       //  FMOVEM命令は例外を発生させずFPCR/FPSR/FPIARも(デスティネーションに書かれたもの以外)変化しない
 22805:       //    --------------------------------
 22806:       //    > cir 00 .
 22807:       //    0802 
 22808:       //    > cir 0a d0ff
 22809:       //    > cir 00 ....
 22810:       //    8900 810C 8900 8900 
 22811:       //    > cir 14 .
 22812:       //    FF00 
 22813:       //    > cir 00 ..
 22814:       //    8900 8900 
 22815:       //    > cir 10 3fff0000
 22816:       //    > cir 00 ..
 22817:       //    8900 8900 
 22818:       //    > cir 10 80000000
 22819:       //    > cir 00 ..
 22820:       //    8900 8900 
 22821:       //    > cir 10 00000000
 22822:       //    > cir 00 ..
 22823:       //    8900 8900 
 22824:       //    > cir 10 40000000 80000000 00000000
 22825:       //    > cir 10 40010000 80000000 00000000
 22826:       //    > cir 10 40020000 80000000 00000000
 22827:       //    > cir 10 40030000 80000000 00000000
 22828:       //    > cir 10 40040000 80000000 00000000
 22829:       //    > cir 10 40050000 80000000 00000000
 22830:       //    > cir 00 ..
 22831:       //    8900 8900 
 22832:       //    > cir 10 40060000
 22833:       //    > cir 00 ..
 22834:       //    8900 8900 
 22835:       //    > cir 10 80000000
 22836:       //    > cir 00 ..
 22837:       //    8900 8900 
 22838:       //    > cir 10 00000000
 22839:       //    > cir 00 ..
 22840:       //    0802 0802 
 22841:       //    --------------------------------
 22842:       //    レスポンス$810Cが帰った直後に$14 register selectをリードしないとプロトコル違反になる
 22843:       //    > cir 00 .
 22844:       //    0802 
 22845:       //    > cir 0a d0ff
 22846:       //    > cir 00 ....
 22847:       //    8900 810C 8900 8900 
 22848:       //    > cir 10 3fff0000
 22849:       //    > cir 00 ..
 22850:       //    1D0D 1D0D 
 22851:       //    > cir 06 0000
 22852:       //    > cir 00 ..
 22853:       //    0802 0802 
 22854:       //    --------------------------------
 22855:       //    転送するレジスタがなくても$14 register selectを1回だけリードしなければならない
 22856:       //    > cir 00 .
 22857:       //    0802 
 22858:       //    > cir 0a d000
 22859:       //    > cir 00 ....
 22860:       //    8900 810C 0802 0802 
 22861:       //    > cir 0a 0000
 22862:       //    > cir 00 ..
 22863:       //    1D0D 1D0D 
 22864:       //    > cir 06 0000
 22865:       //    > cir 00 ..
 22866:       //    0802 0802 
 22867:       //    > cir 00 .
 22868:       //    0802 
 22869:       //    > cir 0a d000
 22870:       //    > cir 00 ....
 22871:       //    8900 810C 0802 0802 
 22872:       //    > cir 14 .
 22873:       //    0000 
 22874:       //    > cir 00 ..
 22875:       //    0802 0802 
 22876:       //    > cir 14 .
 22877:       //    0000 
 22878:       //    > cir 00 ..
 22879:       //    1D0D 1D0D 
 22880:       //    > cir 06 0000
 22881:       //    > cir 00 ..
 22882:       //    0802 0802 
 22883:       //    --------------------------------
 22884:       //    fmovem.x -(a0),fp0-fp7が許容される。転送順序はFP7→FP6→...→FP1→FP0
 22885:       //    > cir 00 .
 22886:       //    0802 
 22887:       //    > cir 0a c0ff
 22888:       //    > cir 00 ....
 22889:       //    8900 810C 8900 8900 
 22890:       //    > cir 14 .
 22891:       //    FF00 
 22892:       //    > cir 10 3fff0000
 22893:       //    > cir 00 ..
 22894:       //    8900 8900 
 22895:       //    > cir 10 80000000
 22896:       //    > cir 00 ..
 22897:       //    8900 8900 
 22898:       //    > cir 10 00000000
 22899:       //    > cir 00 ..
 22900:       //    8900 8900 
 22901:       //    > cir 10 40000000
 22902:       //    > cir 00 ..
 22903:       //    8900 8900 
 22904:       //    > cir 10 80000000
 22905:       //    > cir 00 ..
 22906:       //    8900 8900 
 22907:       //    > cir 10 00000000
 22908:       //    > cir 00 ..
 22909:       //    8900 8900 
 22910:       //    > cir 10 40010000
 22911:       //    > cir 00 ..
 22912:       //    8900 8900 
 22913:       //    > cir 10 80000000
 22914:       //    > cir 00 ..
 22915:       //    8900 8900 
 22916:       //    > cir 10 00000000
 22917:       //    > cir 00 ..
 22918:       //    8900 8900 
 22919:       //    > cir 10 40020000
 22920:       //    > cir 00 ..
 22921:       //    8900 8900 
 22922:       //    > cir 10 80000000
 22923:       //    > cir 00 ..
 22924:       //    8900 8900 
 22925:       //    > cir 10 00000000
 22926:       //    > cir 00 ..
 22927:       //    8900 8900 
 22928:       //    > cir 10 40030000
 22929:       //    > cir 00 ..
 22930:       //    8900 8900 
 22931:       //    > cir 10 80000000
 22932:       //    > cir 00 ..
 22933:       //    8900 8900 
 22934:       //    > cir 10 00000000
 22935:       //    > cir 00 ..
 22936:       //    8900 8900 
 22937:       //    > cir 10 40040000
 22938:       //    > cir 00 ..
 22939:       //    8900 8900 
 22940:       //    > cir 10 80000000
 22941:       //    > cir 00 ..
 22942:       //    8900 8900 
 22943:       //    > cir 10 00000000
 22944:       //    > cir 00 ..
 22945:       //    8900 8900 
 22946:       //    > cir 10 40050000
 22947:       //    > cir 00 ..
 22948:       //    8900 8900 
 22949:       //    > cir 10 80000000
 22950:       //    > cir 00 ..
 22951:       //    8900 8900 
 22952:       //    > cir 10 00000000
 22953:       //    > cir 00 ..
 22954:       //    8900 8900 
 22955:       //    > cir 10 40060000
 22956:       //    > cir 00 ..
 22957:       //    8900 8900 
 22958:       //    > cir 10 80000000
 22959:       //    > cir 00 ..
 22960:       //    8900 8900 
 22961:       //    > cir 10 00000000
 22962:       //    > cir 00 ..
 22963:       //    0802 0802 
 22964:       //    > cir 00 .
 22965:       //    0802 
 22966:       //    > cir 0a 6000
 22967:       //    > cir 00 ....
 22968:       //    8900 B104 0802 0802 
 22969:       //    > cir 10 .
 22970:       //    00000080 
 22971:       //    --------------------------------
 22972:       //    memory to FPCP, pre-decrment, static register list
 22973:       //    > cir 00 .
 22974:       //    0802 
 22975:       //    > cir 0a c001
 22976:       //    > cir 00 ....
 22977:       //    8900 810C 8900 8900 
 22978:       //    > cir 14 .
 22979:       //    0100 
 22980:       //    > cir 00 ....
 22981:       //    8900 8900 8900 8900 
 22982:       //    > cir 10 40020000
 22983:       //    > cir 00 ..
 22984:       //    8900 8900 
 22985:       //    > cir 10 b0000000
 22986:       //    > cir 00 ..
 22987:       //    8900 8900 
 22988:       //    > cir 10 00000000
 22989:       //    > cir 00 ..
 22990:       //    0802 0802 
 22991:       //    > cir 0a 6000
 22992:       //    > cir 00 ....
 22993:       //    8900 B104 0802 0802 
 22994:       //    > cir 10 .
 22995:       //    0000000B 
 22996:       //    > cir 00 ..
 22997:       //    0802 0802 
 22998:       //    --------------------------------
 22999:       //    memory to FPCP, pre-decrment, dynamic register list
 23000:       //    > cir 00 .
 23001:       //    0802 
 23002:       //    > cir 0a c850
 23003:       //    > cir 00 ....
 23004:       //    8C05 8900 8900 8900 
 23005:       //    > cir 10 00000001
 23006:       //    > cir 00 ....
 23007:       //    810C 8900 8900 8900 
 23008:       //    > cir 14 .
 23009:       //    0100 
 23010:       //    > cir 10 40020000
 23011:       //    > cir 00 ..
 23012:       //    8900 8900 
 23013:       //    > cir 10 90000000
 23014:       //    > cir 00 ..
 23015:       //    8900 8900 
 23016:       //    > cir 10 00000000
 23017:       //    > cir 00 ..
 23018:       //    0802 0802 
 23019:       //    > cir 0a 6000
 23020:       //    > cir 00 ....
 23021:       //    8900 B104 0802 0802 
 23022:       //    > cir 10 .
 23023:       //    00000009 
 23024:       //    > cir 00 ..
 23025:       //    0802 0802 
 23026:       //    --------------------------------
 23027:       //    memory to FPCP, post-increment, static register list
 23028:       //    > cir 00 .
 23029:       //    0802 
 23030:       //    > cir 0a d080
 23031:       //    > cir 00 ....
 23032:       //    8900 810C 8900 8900 
 23033:       //    > cir 14 .
 23034:       //    8000 
 23035:       //    > cir 00 ..
 23036:       //    8900 8900 
 23037:       //    > cir 10 40010000
 23038:       //    > cir 00 ..
 23039:       //    8900 8900 
 23040:       //    > cir 10 a0000000
 23041:       //    > cir 00 ..
 23042:       //    8900 8900 
 23043:       //    > cir 10 00000000
 23044:       //    > cir 00 ..
 23045:       //    0802 0802 
 23046:       //    > cir 0a 6000
 23047:       //    > cir 00 ....
 23048:       //    8900 B104 0802 0802 
 23049:       //    > cir 10 .
 23050:       //    00000005 
 23051:       //    > cir 00 ..
 23052:       //    0802 0802 
 23053:       //    --------------------------------
 23054:       //    memory to FPCP, post-increment, dynamic register list
 23055:       //    > cir 00 .
 23056:       //    0802 
 23057:       //    > cir 0a d870
 23058:       //    > cir 00 ....
 23059:       //    8C07 8900 8900 8900 
 23060:       //    > cir 10 00000080
 23061:       //    > cir 00 ...
 23062:       //    810C 8900 8900 
 23063:       //    > cir 14 .
 23064:       //    8000 
 23065:       //    > cir 00 ..
 23066:       //    8900 8900 
 23067:       //    > cir 10 40000000
 23068:       //    > cir 00 ..
 23069:       //    8900 8900 
 23070:       //    > cir 10 c0000000
 23071:       //    > cir 00 ..
 23072:       //    8900 8900 
 23073:       //    > cir 10 00000000
 23074:       //    > cir 00 ..
 23075:       //    0802 0802 
 23076:       //    > cir 0a 6000
 23077:       //    > cir 00 ....
 23078:       //    8900 B104 0802 0802 
 23079:       //    > cir 10 .
 23080:       //    00000003 
 23081:       //    > cir 00 ..
 23082:       //    0802 0802 
 23083:       //    --------------------------------
 23084:       if (cirStage == CIR_IDLE) {  //開始
 23085:         if ((cirCommand & 0x0700) != 0) {
 23086:           cirException (0x1c0b);  //F-line emulator
 23087:           return;
 23088:         }
 23089:         if ((mmm & 2) == 0) {  //静的レジスタリスト
 23090:           cirRegisterList = cirCommand & 255;
 23091:           cirResponse = 0x8900_810c;  //複数レジスタを入力する→come_again
 23092:           cirStage = CIR_REGISTER_SELECT;  //レジスタセレクト転送開始
 23093:         } else {  //動的レジスタリスト
 23094:           cirResponse = 0x8900_8c00 + (cirCommand >> 4 & 7);  //データレジスタを入力する→come-again
 23095:           cirOperandLength = 1;
 23096:           cirOperandIndex = 0;
 23097:           cirStage = CIR_DYNAMIC_REGISTER_LIST;  //動的レジスタリスト転送開始
 23098:         }
 23099:         return;
 23100:       }
 23101:       if (cirStage == CIR_DYNAMIC_REGISTER_LIST) {  //動的レジスタリスト転送終了
 23102:         cirRegisterList = cirOperandBuffer[0] & 255;
 23103:         cirResponse = 0x8900_810c;  //複数レジスタを入力する→come_again
 23104:         cirStage = CIR_REGISTER_SELECT;  //レジスタセレクト転送開始
 23105:         return;
 23106:       }
 23107:       if (cirStage == CIR_REGISTER_SELECT) {  //レジスタセレクト転送終了
 23108:         if (cirRegisterList == 0) {  //転送するレジスタがない
 23109:           //終了
 23110:           cirIdle (0x0802);
 23111:           return;
 23112:         }
 23113:         cirOperandLength = 3 * Integer.bitCount (cirRegisterList);  //転送するレジスタ数*3=転送するロング数
 23114:         cirOperandIndex = 0;
 23115:         cirStage = CIR_SOURCE_OPERAND;  //ソースオペランド転送開始
 23116:         return;
 23117:       }
 23118:       //if (cirStage == CIR_SOURCE_OPERAND)
 23119:       {  //ソースオペランド転送終了
 23120:         int n, p;
 23121:         if ((cirCommand & 0x1000) == 0) {  //プレデクリメント。リストはFP7|…|FP0、転送順序はFP7→FP0、オペランドバッファはFP0,…,FP7
 23122:           n = 7;
 23123:           p = -1;
 23124:         } else {  //ポストインクリメント。リストはFP0|…|FP7、転送順序はFP0→FP7、オペランドバッファはFP7,…,FP0
 23125:           n = 0;
 23126:           p = 1;
 23127:         }
 23128:         int i = 0;
 23129:         for (int list = cirRegisterList << 24; list != 0; n += p, list <<= 1) {
 23130:           if (list < 0) {
 23131:             if (epbIsTriple ()) {  //三倍精度
 23132:               epbFPn[n].sety012 (cirOperandBuffer[i], (long) cirOperandBuffer[i + 1] << 32 | cirOperandBuffer[i + 2] & 0xffffffffL);
 23133:             } else {  //拡張精度
 23134:               epbFPn[n].setx012 (cirOperandBuffer[i], (long) cirOperandBuffer[i + 1] << 32 | cirOperandBuffer[i + 2] & 0xffffffffL);
 23135:             }
 23136:             i += 3;
 23137:           }
 23138:         }
 23139:         //終了
 23140:         cirIdle (0x0802);
 23141:         return;
 23142:       }
 23143:       //break;
 23144: 
 23145: 
 23146:     case 0b111:  //$Exxx-$Fxxx: FMOVEM.X <list>,<ea>
 23147:       //  FMOVEM命令は例外を発生させずFPCR/FPSR/FPIARも(デスティネーションに書かれたもの以外)変化しない
 23148:       //    --------------------------------
 23149:       //    FPCP to memory, pre-decrement, static register list
 23150:       //    > cir 00 .
 23151:       //    0802 
 23152:       //    > cir 0a 4000
 23153:       //    > cir 00 ....
 23154:       //    9504 8900 8900 8900 
 23155:       //    > cir 10 00000080
 23156:       //    > cir 00 ..
 23157:       //    0802 0802 
 23158:       //    > cir 0a 4080
 23159:       //    > cir 00 ....
 23160:       //    9504 8900 8900 8900 
 23161:       //    > cir 10 00000081
 23162:       //    > cir 00 ..
 23163:       //    0802 0802 
 23164:       //    > cir 0a e003
 23165:       //    > cir 00 ....
 23166:       //    8900 A10C 8900 8900 
 23167:       //    > cir 14 .
 23168:       //    0300 
 23169:       //    > cir 00 ..
 23170:       //    8900 8900 
 23171:       //    > cir 10 .
 23172:       //    40060000 
 23173:       //    > cir 00 ..
 23174:       //    8900 8900 
 23175:       //    > cir 10 .
 23176:       //    81000000 
 23177:       //    > cir 00 ..
 23178:       //    8900 8900 
 23179:       //    > cir 10 .
 23180:       //    00000000 
 23181:       //    > cir 00 ..
 23182:       //    8900 8900 
 23183:       //    > cir 10 .
 23184:       //    40060000 
 23185:       //    > cir 00 ..
 23186:       //    8900 8900 
 23187:       //    > cir 10 .
 23188:       //    80000000 
 23189:       //    > cir 00 ..
 23190:       //    0802 0802 
 23191:       //    --------------------------------
 23192:       //    FPCP to memory, pre-decrement, dynamic register list
 23193:       //    > cir 00 .
 23194:       //    0802 
 23195:       //    > cir 0a 4000
 23196:       //    > cir 00 ....
 23197:       //    9504 8900 8900 8900 
 23198:       //    > cir 10 00000082
 23199:       //    > cir 00 ..
 23200:       //    0802 0802 
 23201:       //    > cir 0a 4080
 23202:       //    > cir 00 ....
 23203:       //    9504 8900 8900 8900 
 23204:       //    > cir 10 00000083
 23205:       //    > cir 00 ..
 23206:       //    0802 0802 
 23207:       //    > cir 0a e870
 23208:       //    > cir 00 ....
 23209:       //    8C07 8900 8900 8900 
 23210:       //    > cir 10 00000003
 23211:       //    > cir 00 ....
 23212:       //    A10C 8900 8900 8900 
 23213:       //    > cir 14 .
 23214:       //    0300 
 23215:       //    > cir 00 ..
 23216:       //    8900 8900 
 23217:       //    > cir 10 ...
 23218:       //    40060000 83000000 00000000 
 23219:       //    > cir 00 ..
 23220:       //    8900 8900 
 23221:       //    > cir 10 ...
 23222:       //    40060000 82000000 00000000 
 23223:       //    > cir 00 ..
 23224:       //    0802 0802 
 23225:       //    --------------------------------
 23226:       //    FPCP to memory, post-increment, static register list
 23227:       //    > cir 00 .
 23228:       //    0802 
 23229:       //    > cir 0a 4000
 23230:       //    > cir 00 ....
 23231:       //    9504 8900 8900 8900 
 23232:       //    > cir 10 00000084
 23233:       //    > cir 00 ..
 23234:       //    0802 0802 
 23235:       //    > cir 0a 4080
 23236:       //    > cir 00 ....
 23237:       //    9504 8900 8900 8900 
 23238:       //    > cir 10 00000085
 23239:       //    > cir 00 ..
 23240:       //    0802 0802 
 23241:       //    > cir 0a f0c0
 23242:       //    > cir 00 ....
 23243:       //    8900 A10C 8900 8900 
 23244:       //    > cir 14 .
 23245:       //    C000 
 23246:       //    > cir 00 ..
 23247:       //    8900 8900 
 23248:       //    > cir 10 ...
 23249:       //    40060000 84000000 00000000 
 23250:       //    > cir 00 ..
 23251:       //    8900 8900 
 23252:       //    > cir 10 ...
 23253:       //    40060000 85000000 00000000 
 23254:       //    > cir 00 ..
 23255:       //    0802 0802 
 23256:       //    --------------------------------
 23257:       //    FPCP to memory, post-increment, dynamic register list
 23258:       //    > cir 00 .
 23259:       //    0802 
 23260:       //    > cir 0a 4000
 23261:       //    > cir 00 ....
 23262:       //    9504 8900 8900 8900 
 23263:       //    > cir 10 00000086
 23264:       //    > cir 00 ..
 23265:       //    0802 0802 
 23266:       //    > cir 0a 4080
 23267:       //    > cir 00 ....
 23268:       //    9504 8900 8900 8900 
 23269:       //    > cir 10 00000087
 23270:       //    > cir 00 ..
 23271:       //    0802 0802 
 23272:       //    > cir 0a f870
 23273:       //    > cir 00 ....
 23274:       //    8C07 8900 8900 8900 
 23275:       //    > cir 10 000000c0
 23276:       //    > cir 00 ....
 23277:       //    A10C 8900 8900 8900 
 23278:       //    > cir 14 .
 23279:       //    C000 
 23280:       //    > cir 00 ..
 23281:       //    8900 8900 
 23282:       //    > cir 10 ...
 23283:       //    40060000 86000000 00000000 
 23284:       //    > cir 00 ..
 23285:       //    8900 8900 
 23286:       //    > cir 10 ...
 23287:       //    40060000 87000000 00000000 
 23288:       //    > cir 00 ..
 23289:       //    0802 0802 
 23290:       //    --------------------------------
 23291:       if (cirStage == CIR_IDLE) {  //開始
 23292:         if ((cirCommand & 0x0700) != 0) {
 23293:           cirException (0x1c0b);  //F-line emulator
 23294:           return;
 23295:         }
 23296:         if ((mmm & 2) == 0) {  //静的レジスタリスト
 23297:           cirRegisterList = cirCommand & 255;
 23298:           cirResponse = 0x8900_a10c;  //複数レジスタを出力する→come_again
 23299:           cirStage = CIR_REGISTER_SELECT;  //レジスタセレクト転送開始
 23300:         } else {  //動的レジスタリスト
 23301:           cirResponse = 0x8900_8c00 + (cirCommand >> 4 & 7);  //データレジスタを入力する→come-again
 23302:           cirOperandLength = 1;
 23303:           cirOperandIndex = 0;
 23304:           cirStage = CIR_DYNAMIC_REGISTER_LIST;  //動的レジスタリスト転送開始
 23305:         }
 23306:         return;
 23307:       }
 23308:       if (cirStage == CIR_DYNAMIC_REGISTER_LIST) {  //動的レジスタリスト転送終了
 23309:         cirRegisterList = cirOperandBuffer[0] & 255;
 23310:         cirResponse = 0x8900_a10c;  //複数レジスタを出力する→come_again
 23311:         cirStage = CIR_REGISTER_SELECT;  //レジスタセレクト転送開始
 23312:         return;
 23313:       }
 23314:       if (cirStage == CIR_REGISTER_SELECT) {  //レジスタセレクト転送終了
 23315:         if (cirRegisterList == 0) {  //転送するレジスタがない
 23316:           //終了
 23317:           cirIdle (0x0802);
 23318:           return;
 23319:         }
 23320:         int n, p;
 23321:         if ((cirCommand & 0x1000) == 0) {  //プレデクリメント。リストはFP7|…|FP0、転送順序はFP7→FP0、オペランドバッファはFP0,…,FP7
 23322:           n = 7;
 23323:           p = -1;
 23324:         } else {  //ポストインクリメント。リストはFP0|…|FP7、転送順序はFP0→FP7、オペランドバッファはFP7,…,FP0
 23325:           n = 0;
 23326:           p = 1;
 23327:         }
 23328:         int i = 0;
 23329:         byte[] b = new byte[12];
 23330:         for (int list = cirRegisterList << 24; list != 0; n += p, list <<= 1) {
 23331:           if (list < 0) {
 23332:             if (epbIsTriple ()) {  //三倍精度
 23333:               epbFPn[n].gety012 (b, 0, epbRoundingMode);
 23334:             } else {  //拡張精度
 23335:               epbFPn[n].getx012 (b, 0, epbRoundingMode);
 23336:             }
 23337:             cirOperandBuffer[i] = b[0] << 24 | (b[1] & 255) << 16 | (char) (b[2] << 8 | b[3] & 255);
 23338:             cirOperandBuffer[i + 1] = b[4] << 24 | (b[5] & 255) << 16 | (char) (b[6] << 8 | b[7] & 255);
 23339:             cirOperandBuffer[i + 2] = b[8] << 24 | (b[9] & 255) << 16 | (char) (b[10] << 8 | b[11] & 255);
 23340:             i += 3;
 23341:           }
 23342:         }
 23343:         cirOperandLength = i;
 23344:         cirOperandIndex = 0;
 23345:         cirStage = CIR_DESTINATION_OPERAND;  //デスティネーションオペランド転送開始
 23346:         return;
 23347:       }
 23348:       //if (cirStage == CIR_DESTINATION_OPERAND)
 23349:       {  //デスティネーションオペランド転送終了
 23350:         //終了
 23351:         cirIdle (0x0802);
 23352:         return;
 23353:       }
 23354:       //break;
 23355: 
 23356: 
 23357:     case 0b001:  //$2xxx-$3xxx: 未定義
 23358:     default:
 23359:       cirException (0x1c0b);  //F-line emulator
 23360:       return;
 23361:     }
 23362: 
 23363:   }  //cirGen()
 23364: 
 23365: 
 23366:   //cirPreInstruction ()
 23367:   //  浮動小数点命令実行前例外
 23368:   //  優先順位はBSUN>SNAN>OPERR>OVFL>UNFL>DZ>INEX2/INEX1
 23369:   //  複数の例外が同時に発生したときは最上位の例外ハンドラだけが呼び出される
 23370:   //  浮動小数点例外ハンドラは自分よりも下位の浮動小数点例外が発生していないか確認しなければならない
 23371:   public boolean cirPreInstruction () {
 23372:     //FPSRのAEXCを更新する
 23373:     epbFpsr |= XEiJ.FPU_FPSR_EXC_TO_AEXC[epbFpsr >> 8 & 255];
 23374:     //浮動小数点命令実行前例外 floating-point pre-instruction exception
 23375:     int mask = epbFpcr & epbFpsr & 0x0000ff00;
 23376:     if (mask == 0) {
 23377:       return false;
 23378:     }
 23379:     if ((short) mask < 0) {  //BSUN。(mask & 0x00008000) != 0
 23380:       cirException (0x5c30);  //分岐または比較不能状態でのセット branch or set on unordered
 23381:     } else if (mask << 17 < 0) {  //SNAN。(mask & 0x00004000) != 0
 23382:       cirException (0x1c36);  //シグナリングNAN signaling nan
 23383:     } else if (mask << 18 < 0) {  //OPERR。(mask & 0x00002000) != 0
 23384:       cirException (0x1c34);  //オペランドエラー operand error
 23385:     } else if (mask << 19 < 0) {  //OVFL。(mask & 0x00001000) != 0
 23386:       cirException (0x1c35);  //オーバーフロー overflow
 23387:     } else if (mask << 20 < 0) {  //UNFL。(mask & 0x00000800) != 0
 23388:       cirException (0x1c33);  //アンダーフロー underflow
 23389:     } else if (mask << 21 < 0) {  //DZ。(mask & 0x00000400) != 0
 23390:       cirException (0x1c32);  //ゼロによる除算 floating-point divide by zero
 23391:     } else {  //INEX1,INEX2。(mask & 0x00000300) != 0
 23392:       cirException (0x1c31);  //不正確な結果 inexact result
 23393:     }
 23394:     return true;
 23395:   }  //cirPreInstruction()
 23396: 
 23397:   //cirMidInstruction ()
 23398:   //  浮動小数点命令実行中例外
 23399:   //  優先順位はBSUN>SNAN>OPERR>OVFL>UNFL>DZ>INEX2/INEX1
 23400:   //  複数の例外が同時に発生したときは最上位の例外ハンドラだけが呼び出される
 23401:   //  浮動小数点例外ハンドラは自分よりも下位の浮動小数点例外が発生していないか確認しなければならない
 23402:   public boolean cirMidInstruction () {
 23403:     //FPSRのAEXCを更新する
 23404:     epbFpsr |= XEiJ.FPU_FPSR_EXC_TO_AEXC[epbFpsr >> 8 & 255];
 23405:     //浮動小数点命令実行中例外 floating-point mid-instruction exception
 23406:     int mask = epbFpcr & epbFpsr & 0x0000ff00;
 23407:     if (mask == 0) {
 23408:       return false;
 23409:     }
 23410:     if ((short) mask < 0) {  //BSUN。(mask & 0x00008000) != 0
 23411:       cirException (0x5d30);  //分岐または比較不能状態でのセット branch or set on unordered
 23412:     } else if (mask << 17 < 0) {  //SNAN。(mask & 0x00004000) != 0
 23413:       cirException (0x1d36);  //シグナリングNAN signaling nan
 23414:     } else if (mask << 18 < 0) {  //OPERR。(mask & 0x00002000) != 0
 23415:       cirException (0x1d34);  //オペランドエラー operand error
 23416:     } else if (mask << 19 < 0) {  //OVFL。(mask & 0x00001000) != 0
 23417:       cirException (0x1d35);  //オーバーフロー overflow
 23418:     } else if (mask << 20 < 0) {  //UNFL。(mask & 0x00000800) != 0
 23419:       cirException (0x1d33);  //アンダーフロー underflow
 23420:     } else if (mask << 21 < 0) {  //DZ。(mask & 0x00000400) != 0
 23421:       cirException (0x1d32);  //ゼロによる除算 floating-point divide by zero
 23422:     } else {  //INEX1,INEX2。(mask & 0x00000300) != 0
 23423:       cirException (0x1d31);  //不正確な結果 inexact result
 23424:     }
 23425:     return true;
 23426:   }  //cirMidInstruction()
 23427: 
 23428: 
 23429: 
 23430: }  //class EPB
 23431: 
 23432: 
 23433: