Adding fparser v4.3...

[architektonas] / fparser / fpoptimizer.cc

/***************************************************************************\
|* Function Parser for C++ v4.3                                            *|
|*-------------------------------------------------------------------------*|
|* Function optimizer                                                      *|
|*-------------------------------------------------------------------------*|
|* Copyright: Joel Yliluoma                                                *|
|*                                                                         *|
|* This library is distributed under the terms of the                      *|
|* GNU Lesser General Public License version 3.                            *|
|* (See lgpl.txt and gpl.txt for the license text.)                        *|
\***************************************************************************/

/* NOTE:
 This file contains generated code (from the optimizer sources) and is
 not intended to be modified by hand. If you want to modify the optimizer,
 download the development version of the library.
*/

#include "fpconfig.hh"
#ifdef FP_SUPPORT_OPTIMIZER
#include "fparser.hh"
#include "fptypes.hh"
#define i43 nW1 a),
#define i33 info.yH
#define i23 ,cAtan2
#define i13 =false;
#define i03 cAbsIf
#define tZ3 "Found "
#define tY3 },{{2,
#define tX3 {if(apos
#define tW3 stackpos
#define tV3 "dup(%u) "
#define tU3 GetOpcode
#define tT3 eR{assert
#define tS3 "%d, cost "
#define tR3 "immed "<<
#define tQ3 mFuncParsers
#define tP3 "PUSH ";xE3(
#define tO3 stderr
#define tN3 sep2=" "
#define tM3 FPHASH_CONST
#define tL3 cache_needed[
#define tK3 fprintf
#define tJ3 ::cout<<"Applying "
#define tI3 ||tree.tU3
#define tH3 HANDLE_UNARY_CONST_FUNC
#define tG3 within,
#define tF3 y21){if
#define tE3 c_count
#define tD3 s_count
#define tC3 MaxOp
#define tB3 2)lS 2*
#define tA3 x11.cG3
#define t93 l7 0,2,
#define t83 <eS1(0)
#define t73 );else{
#define t63 (n6)nN3
#define t53 b.Value)
#define t43 b.Opcode
#define t33 .nB synth
#define t23 ].swap(
#define t13 =synth.
#define t03 codes[b
#define eZ3 Value){
#define eY3 whydump
#define eX3 i01 eF2
#define eW3 for(x53
#define eV3 ;for yS{
#define eU3 );synth
#define eT3 info.SaveMatchedParamIndex(
#define eS3 for(;a<
#define eR3 nparams
#define eQ3 first!=
#define eP3 i03,
#define eO3 l3 4,1,
#define eN3 cTan,xJ
#define eM3 cLog,xJ
#define eL3 l3 0,1,
#define eK3 cHypot,
#define eJ3 nR 0,
#define eI3 cAbs nR
#define eH3 std::cO
#define eG3 fp_pow(
#define eF3 ,cM2 lD
#define eE3 .second
#define eD3 ]eE3
#define eC3 ].first
#define eB3 Ne_Mask
#define eA3 Gt_Mask
#define e93 Lt_Mask
#define e83 {nL eS1(
#define e73 131,4,1,
#define e63 tC1 max
#define e53 tU cMul);
#define e43 131,8,1
#define e33 FindPos
#define e23 nN yL
#define e13 public:
#define e03 result xM
#define cZ3 result))lA2
#define cY3 result(
#define cX3 {data->
#define cW3 .eW1 n]
#define cV3 eG cK1);
#define cU3 eG yR1
#define cT3 if(eY1==
#define cS3 ),has_max(
#define cR3 (count
#define cQ3 .empty()
#define cP3 .iH1 a);
#define cO3 GetParamCount(nQ
#define cN3 GetParamCount();
#define cM3 ;}case
#define cL3 pclone
#define cK3 sim.x3
#define cJ3 fpdata
#define cI3 cCosh nR
#define cH3 cCosh,
#define cG3 Immeds
#define cF3 l6 1,
#define cE3 x8(tB2
#define cD3 newpow
#define cC3 change
#define cB3 133,2,
#define cA3 i01 x2
#define c93 Params
#define c83 Needs
#define c73 byteCode
#define c63 eT1&occ=
#define c53 child)
#define c43 AddFrom(
#define c33 lT1 nE==
#define c23 ;for xK2
#define c13 tC1 lY1
#define c03 factor_t
#define yZ3 tree.xJ1
#define yY3 yA tmp2)
#define yX3 value1
#define yW3 model.
#define yV3 true;n31
#define yU3 &&p0.max
#define yT3 p2 eT ifp2
#define yS3 yJ p2;p2
#define yR3 cAbsNot
#define yQ3 switch(tX
#define yP3 tZ case
#define yO3 IsNever
#define yN3 }switch
#define yM3 stackptr
#define yL3 nN[++IP]
#define yK3 const xH
#define yJ3 yE cPow)
#define yI3 default_function_handling
#define yH3 cLog);x9
#define yG3 ;sim.Push(
#define yF3 eS1(0.5)
#define yE3 iJ 1,
#define yD3 [funcno].
#define yC3 :start_at()
#define yB3 Rehash(tT yA
#define yA3 .size()
#define y93 IsLogicalValue nW1
#define y83 (tree))e5
#define y73 stack[stack yA3-
#define y63 stack yL
#define y53 tmp yC 0))
#define y43 ));tmp tU
#define y33 ,(long tG1
#define y23 );tmp2 yC
#define y13 cMul);xK
#define y03 1),eS1(1))
#define xZ3 constvalue
#define xY3 lD 0));
#define xX3 )nG1 xK
#define xW3 nN[IP]==
#define xV3 opcodes
#define xU3 did_muli
#define xT3 switch(lF3.first iY2
#define xS3 ;for iL1
#define xR3 Ge0Lt1
#define xQ3 &&p.max
#define xP3 :tree.
#define xO3 =y6 a));if(
#define xN3 used[b]
#define xM3 e8(),yG<
#define xL3 size_t n
#define xK3 sizeof(
#define xJ3 cNotNot,
#define xI3 cOr yF
#define xH3 359463,
#define xG3 2,7168,
#define xF3 param.
#define xE3 DumpTree
#define xD3 Gt0Le1
#define xC3 y21){eS1
#define xB3 base,eS1
#define xA3 ==cOr)l9
#define x93 cAdd iU1
#define x83 (cM2 lD
#define x73 lD 2));
#define x63 eT cond
#define x53 iX2 0;b<
#define x43 {}range(
#define x33 .n_int_sqrt
#define x23 ,cPow,xJ
#define x13 ,{1,218,
#define x03 lD 1))
#define nZ3 tmp yA tree
#define nY3 eS1(1)))
#define nX3 iterator
#define nW3 begin();
#define nV3 TreeSet
#define nU3 parent
#define nT3 insert(i
#define nS3 newrel
#define nR3 eS1(2)));
#define nQ3 {eS1 tmp
#define nP3 iU.hash1
#define nO3 (tree)!=
#define nN3 )n5 lC
#define nM3 break;}
#define nL3 b_needed
#define nK3 cachepos
#define nJ3 half=
#define nI3 src_pos
#define nH3 reserve(
#define nG3 treeptr
#define nF3 iC2 size()
#define nE3 .resize(
#define nD3 eU1 void
#define nC3 ImmedTag
#define nB3 a,const
#define nA3 RefCount
#define n93 Birth();
#define n83 mulgroup
#define n73 template
#define n63 cost_t
#define n53 n72 nZ
#define n43 middle
#define n33 ))break;eS1
#define n23 };enum
#define n13 if(op==
#define n03 (p1.xJ1
#define lZ3 cLog2by);
#define lY3 sqrt_cost
#define lX3 const int
#define lW3 mul_count
#define lV3 maxValue1
#define lU3 minValue1
#define lT3 maxValue0
#define lS3 minValue0
#define lR3 ValueType
#define lQ3 >(eS1(1),
#define lP3 abs_mul
#define lO3 pos_set
#define lN3 goto e3
#define lM3 nF1);}if(
#define lL3 yE cAdd);
#define lK3 subtree
#define lJ3 invtree
#define lI3 lV1=r.specs;if(r.found){
#define lH3 ,lV1,info
#define lG3 a;if(&t91
#define lF3 parampair
#define lE3 rulenumit
#define lD3 cIf,l6 3,
#define lC3 MakeEqual
#define lB3 nH1,l4::
#define lA3 nH1,{l4::
#define l93 newbase
#define l83 branch1op
#define l73 branch2op
#define l63 overlap
#define l53 truth_a
#define l43 ),Value(
#define l33 );nW l4::
#define l23 if nW1 0)
#define l13 found_dup
#define l03 &1)?(poly^(
#define iZ2 (xF3
#define iY2 ){case
#define iX2 size_t b=
#define iW2 i0 xQ3
#define iV2 has_min
#define iU2 Plan_Has(
#define iT2 ;if(half
#define iS2 ;}void
#define iR2 )iS2
#define iQ2 const nI2
#define iP2 yV1 class
#define iO2 namespace
#define iN2 rhs.hash2;}
#define iM2 rhs.hash1
#define iL2 ::res,b8<
#define iK2 inverted
#define iJ2 has_max=
#define iI2 has_max)
#define iH2 iftree
#define iG2 depcodes
#define iF2 explicit
#define iE2 VarBegin
#define iD2 cM3 lZ2
#define iC2 c93.
#define iB2 ].data);
#define iA2 y4)));nW
#define i92 .what eX
#define i82 ;if(fp_equal(
#define i72 x02 yJ
#define i62 begin(),
#define i52 cond_add
#define i42 cond_mul
#define i32 cond_and
#define i22 yG n91
#define i12 bool e31
#define i02 unsigned
#define tZ2 costree
#define tY2 sintree
#define tX2 leaf_count
#define tW2 =GetParam(
#define tV2 sub_params
#define tU2 printf(
#define tT2 cbrt_count
#define tS2 sqrt_count
#define tR2 Finite
#define tQ2 p1 eT ifp1
#define tP2 pcall_tree
#define tO2 after_powi
#define tN2 grammar
#define tM2 lE 0,1,
#define tL2 cCos,xJ
#define tK2 cEqual,
#define tJ2 ,eO3 507 tS
#define tI2 ,t71 l7 2,2,
#define tH2 cLog nR
#define tG2 l0 2,
#define tF2 cPow,nU
#define tE2 cAdd,xZ 2,
#define tD2 cInv,xZ 1,
#define tC2 cNeg,xZ 1,
#define tB2 ),0},{
#define tA2 x11.SubTrees
#define t92 x11.Others
#define t82 param=*i01
#define t72 std::move(
#define t62 nM3 switch(
#define t52 constraints=
#define t42 .constraints
#define t32 data;data.
#define t22 MakeNEqual
#define t12 for yS eC1
#define t02 yA mul)
#define eZ2 Dump(std::
#define eY2 isInteger(
#define eX2 (cond.cI cA2
#define eW2 yA3;++
#define eV2 nG1 r;r tU
#define eU2 Comparison
#define eT2 needs_flip
#define eS2 {data xB lM
#define eR2 ,eQ,synth);
#define eQ2 (half&63)-1;
#define eP2 value]
#define eO2 ));TriTruthValue
#define eN2 );range.nN2
#define eM2 ,2,1,4,1,2,
#define eL2 >StackMax)
#define eK2 ~size_t(0)
#define eJ2 );t4=!t4;}
#define eI2 ;}yV1 static
#define eH2 info.lQ[b].
#define eG2 const std::eO
#define eF2 Rule&rule,
#define eE2 .GetHash().
#define eD2 (list.first
#define eC2 ;iU.hash2+=
#define eB2 ,xA1);lC
#define eA2 ,const e1&
#define e92 struct
#define e82 cGreater,
#define e72 tree lD 0)
#define e62 const eS1&
#define e52 mul_item
#define e42 innersub
#define e32 cbrt_cost
#define e22 best_cost
#define e12 )))l81 lH
#define e02 result i0
#define cZ2 fp_mod(m.
#define cY2 Compare>
#define cX2 (*x6)[a].info
#define cW2 tree y21 yI
#define cV2 tree nE==
#define cU2 condition
#define cT2 per_item
#define cS2 item_type
#define cR2 first2
#define cQ2 ,l8 0,2,
#define cP2 tS 396676
#define cO2 Decision
#define cN2 not_tree
#define cM2 leaf1
#define cL2 =tree lD
#define cK2 group_by
#define cJ2 ->second
#define cI2 targetpos
#define cH2 eat_count
#define cG2 ParamSpec
#define cF2 Forget()
#define cE2 exponent
#define cD2 ,bool abs){
#define cC2 synth.Find(
#define cB2 params
#define cA2 &&cond eH))
#define c92 source_tree
#define c82 nE==cLog2&&
#define c72 =lT1;bool iQ
#define c62 <t8,n63>
#define c52 p1_evenness
#define c42 c32 i13 if(
#define c32 tC1 iV2
#define c22 isNegative(
#define c12 n73 i5
#define c02 neg_set
#define yZ2 StackTopIs(
#define yY2 cNop,cNop}}
#define yX2 synth.PushImmed(
#define yW2 FPoptimizer_ByteCode yU2
#define yV2 FPoptimizer_ByteCode::
#define yU2 ::ByteCodeSynth x8
#define yT2 cTanh,cNop,
#define yS2 matches
#define yR2 goto fail;}
#define yQ2 cSin,xJ
#define yP2 cTan nR
#define yO2 cCos nR
#define yN2 negated
#define yM2 i7,1,iX+1);
#define yL2 CodeTree
#define yK2 yL2 x8
#define yJ2 ifdata
#define yI2 best_score
#define yH2 mulvalue
#define yG2 pow_item
#define yF2 nE==cPow&&tJ
#define yE2 PowiResult
#define yD2 maxValue
#define yC2 minValue
#define yB2 ;pow tU cPow);pow
#define yA2 result cM3
#define y92 fp_min(xA,
#define y82 set_min_max(
#define y72 div_tree
#define y62 pow_tree
#define y52 preserve
#define y42 PullResult()
#define y32 dup_or_fetch
#define y22 nominator]
#define y12 Rehash(false
#define y02 test_order
#define xZ2 lF3,
#define xY2 .param_count
#define xX2 shift(index)
#define xW2 rulenumber
#define xV2 cTanh nR
#define xU2 (tree nE
#define xT2 GetDepth()
#define xS2 factor_immed
#define xR2 changes
#define xQ2 tU tree nE);
#define xP2 tU cond nE
#define xO2 Become nW1
#define xN2 },0,0x1},{{1,
#define xM2 ,lJ 0x7 tY3
#define xL2 ;n41 eT y9 lD
#define xK2 (size_t a=
#define xJ2 ;}static yN1
#define xI2 tree lD a)
#define xH2 for(typename
#define xG2 exp_diff
#define xF2 ExponentInfo
#define xE2 lower_bound(
#define xD2 factor
#define xC2 is_logical
#define xB2 newrel_and
#define xA2 Suboptimal
#define x92 cW[c tO
#define x82 IsAlways;if(
#define x72 n73 nA1
#define x62 res_stackpos
#define x52 half_pos
#define x42 ;}else{x6=new
#define x32 )lS 3*
#define x22 {e1 start_at;
#define x12 ,(long double)
#define x02 .Rehash()
#define nZ2 )return
#define nY2 );cK3 iJ 2,
#define nX2 return false;}
#define nW2 );nM3
#define nV2 xD1 tA+1);
#define nU2 ;i7.Remember(
#define nT2 .match_tree
#define nS2 l81 true;}
#define nR2 nD OPCODE
#define nQ2 yG x8&immed,
#define nP2 >>1)):(
#define nO2 CodeTreeData
#define nN2 multiply(
#define nM2 i0 i13
#define nL2 .n73
#define nK2 var_trees
#define nJ2 cOr,lP 2,
#define nI2 yL2&
#define nH2 ::Optimize(){
#define nG2 second eE3;
#define nF2 second.first;
#define nE2 log2_exponent
#define nD2 tT.swap(tmp);
#define nC2 Value(Value::
#define nB2 dup_fetch_pos
#define nA2 nN,size_t&l31
#define n92 *)&*start_at;
#define n82 yO3 yI lC
#define n72 ,tree))
#define n62 ContainsOtherCandidates(
#define n52 ,cPow l7 2,2,
#define n42 cSin nR
#define n32 lK 2},0,iR 1,
#define n22 lK 1},0,iR 1,
#define n12 Value_EvenInt
#define n02 Sign_Negative
#define lZ2 SubFunction:{
#define lY2 ParamHolder:{
#define lX2 MakeFalse,{l4
#define lW2 if(xW lD a)iA
#define lV2 ConditionType
#define lU2 SpecialOpcode
#define lT2 synth_it
#define lS2 fp_max(xA);
#define lR2 assimilated
#define lQ2 fraction
#define lP2 0x12},{{
#define lO2 DUP_BOTH();
#define lN2 -1-offset].
#define lM2 tU3()
#define lL2 parent_opcode)
#define lK2 TreeCounts
#define lJ2 bool t4 i13
#define lI2 SetOpcode(
#define lH2 found_log2
#define lG2 div_params
#define lF2 .CopyOnWrite()
#define lE2 immed_sum
#define lD2 OPCODE(opcode)
#define lC2 std::cout<<"POP "
#define lB2 (stack yA3-
#define lA2 break;result*=
#define l92 FactorStack x8
#define l82 IsAlways yI lC
#define l72 l7 2,2,lB1
#define l62 248024 tS
#define l52 cAnd,lP 2,
#define l42 cNot nR
#define l32 cMul,xZ 2,
#define l22 DumpHashesFrom
#define l12 replacing_slot
#define l02 RefParams
#define iZ1 if_always[
#define iY1 WhatDoWhenCase
#define iX1 exponent_immed
#define iW1 new_base_immed
#define iV1 base_immed
#define iU1 ||op1==
#define iT1 (size_t a xX
#define iS1 data[a eD3
#define iR1 AddCollection(
#define iQ1 if(newrel_or==
#define iP1 DUP_ONE(apos);
#define iO1 flipped
#define iN1 .UseGetNeeded(
#define iM1 e9 2,131,
#define iL1 (i02
#define iK1 OptimizedUsing
#define iJ1 Var_or_Funcno
#define iI1 iJ1;
#define iH1 DelParam(
#define iG1 typename nX1::nX3
#define iF1 )nZ2 true
#define iE1 GetParams(
#define iD1 crc32_t
#define iC1 fphash_value_t
#define iB1 signed_chain
#define iA1 IsDefined())
#define i91 MinusInf
#define i81 n_immeds
#define i71 FindClone(xK
#define i61 denominator]
#define i51 needs_rehash
#define i41 AnyWhere_Rec
#define i31 minimum_need
#define i21 ~i02(0)
#define i11 tC1 min
#define i01 (const
#define tZ1 ,i01 void*)&
#define tY1 41,42,43,44,
#define tX1 constraints&
#define tW1 tT.iH1
#define tV1 p1_logical_b
#define tU1 p0_logical_b
#define tT1 p1_logical_a
#define tS1 p0_logical_a
#define tR1 ,PowiCache&i7,
#define tQ1 synth.DoDup(
#define tP1 else if(
#define tO1 cache_needed
#define tN1 e9 2,1,e9 2,
#define tM1 treelist
#define tL1 IsDescendantOf(
#define tK1 has_bad_balance
#define tJ1 (tree,std::cout)
#define tI1 .SetParamsMove(
#define tH1 c03 xD2
#define tG1 double)cE2
#define tF1 {case IsAlways:
#define tE1 e02=false
#define tD1 ;cE2.Rehash(
#define tC1 result.
#define tB1 range x8 result
#define tA1 TopLevel)
#define t91 *start_at){x6=(
#define t81 (rule,tree,info
#define t71 cNEqual
#define t61 ,cEqual l7 2,2,
#define t51 cAdd,AnyParams,
#define t41 lP2 xG3
#define t31 ,cNotNot nR
#define t21 ,cLess l7 2,2,
#define t11 Oneness_NotOne|
#define t01 Value_IsInteger
#define eZ1 iK1(
#define eY1 reltype
#define eX1 SequenceOpcodes
#define eW1 sep_list[
#define eV1 );eG n83);
#define eU1 l02);
#define eT1 TreeCountItem
#define eS1 Value_t
#define eR1 divgroup
#define eQ1 ,eS1(-1)))xF
#define eP1 set_min(fp_floor
#define eO1 pihalf_limits
#define eN1 y41 p0.min>=0.0)
#define eM1 MaxChildDepth
#define eL1 situation_flags&
#define eK1 i02 opcode)
#define eJ1 =yM|i02(nN yA3
#define eI1 std::pair<It,It>
#define eH1 eO3 483 tS
#define eG1 ,l8 0,1,
#define eF1 tG2 7168,
#define eE1 Value_Logical
#define eD1 new_factor_immed
#define eC1 if(remaining[a])
#define eB1 occurance_pos
#define eA1 exponent_hash
#define e91 exponent_list
#define e81 CollectionSet x8
#define e71 CollectMulGroup(
#define e61 source_set
#define e51 cE2,nV3
#define e41 produce_count
#define e31 operator
#define e21 )yJ3;lC
#define e11 back().thenbranch
#define e01 ParamSpec_Extract
#define cZ1 retry_anyparams_3
#define cY1 retry_anyparams_2
#define cX1 needlist_cached_t
#define cW1 grammar_rules[*r]
#define cV1 tF2 0x1 tY3
#define cU1 CodeTreeImmed x8(
#define cT1 GetParamCount()==
#define cS1 by_float_exponent
#define cR1 fp_equal(cE2
#define cQ1 new_exp
#define cP1 end()&&i->first==
#define cO1 yB3 r);}
#define cN1 return BecomeZero;
#define cM1 return BecomeOne;
#define cL1 if(lQ yA3<=n2)
#define cK1 addgroup
#define cJ1 found_log2by
#define cI1 ())yE cMul);lC
#define cH1 >=eS1(0)
#define cG1 nE==yR3)
#define cF1 ParsePowiMuli(
#define cE1 branch1_backup
#define cD1 branch2_backup
#define cC1 exponent_map
#define cB1 plain_set
#define cA1 LightWeight(
#define c91 }nM3 case
#define c81 cN3++b)
#define c71 synth.x5 1
#define c61 ,i7 eR2
#define c51 if(value
#define c41 set_max(fp_ceil cY
#define c31 e62 v,n7
#define c21 {eS1 cE2=
#define c11 should_regenerate=true;
#define c01 should_regenerate,
#define yZ1 Collection
#define yY1 RelationshipResult
#define yX1 Subdivide_Combine(
#define yW1 long value
#define yV1 n73 lT
#define yU1 yV1 cA
#define yT1 yV1 e92
#define yS1 eP nE3 StackMax
#define yR1 subgroup
#define yQ1 best_sep_factor
#define yP1 tP1!result
#define yO1 needlist_cached
#define yN1 inline i02
#define yM1 221646 tS 24803
#define yL1 Constness_Const
#define yK1 opcode,bool pad
#define yJ1 n_occurrences
#define yI1 changed=true;
#define yH1 iH1 a);}
#define yG1 MakesInteger(
#define yF1 e62 value
#define yE1 best_sep_cost
#define yD1 MultiplicationRange
#define yC1 ;p1.yB3 p1
#define yB1 yV1 eS1
#define yA1 n_stacked
#define y91 AnyParams_Rec
#define y81 continue;
#define y71 Become(value lD 0))
#define y61 ,cGreater l7 2,2,
#define y51 yV1 inline TriTruthValue
#define y41 .iV2&&
#define y31 ));n41 y3 op1 tT.DelParams(
#define y21 .IsImmed()
#define y11 =comp.AddItem(atree
#define y01 needs_sincos
#define xZ1 Recheck_RefCount_Div
#define xY1 Recheck_RefCount_Mul
#define xX1 n83.
#define xW1 n83;n83 tU
#define xV1 MultiplyAndMakeLong(
#define xU1 cMul);y53;tmp
#define xT1 covers_plus1
#define xS1 lD2);
#define xR1 if(synth.FindAndDup(
#define xQ1 SynthesizeParam(
#define xP1 public e8,public yG<
#define xO1 grammar_func
#define xN1 221426 tS 237795
#define xM1 t93 165888 tS
#define xL1 Modulo_Radians},
#define xK1 tT.SetParam(
#define xJ1 GetImmed()
#define xI1 PositionType
#define xH1 CollectionResult
#define xG1 yV1 bool
#define xF1 const_offset
#define xE1 stacktop_desired
#define xD1 SetStackTop(
#define xC1 ,cLessOrEq l7 2,2,
#define xB1 yV1 void
#define xA1 cond_type
#define x91 Recheck_RefCount_RDiv
#define x81 static const range x8
#define x71 fPExponentIsTooLarge(
#define x61 CollectMulGroup_Item(
#define x51 pair<eS1,nV3>
#define x41 covers_full_cycle
#define x31 AssembleSequence(
#define x21 x8(rule.repl_param_list,
#define x11 NeedList
#define x01 )lF3 eE3
#define nZ1 <<std::dec<<")";}
#define nY1 &&IsLogicalValue(
#define nX1 TreeCountType x8
#define nW1 (tree lD
#define nV1 <yK2>
#define nU1 std::pair<T1,T2>&
#define nT1 n73<typename
#define nS1 has_good_balance_found
#define nR1 Rehash();tV2 yL
#define nQ1 found_log2_on_exponent
#define nP1 covers_minus1
#define nO1 needs_resynth
#define nN1 immed_product
#define nM1 }},{ProduceNewTree,2,1,
#define nL1 ,2,1)nS if(found[data.
#define nK1 t62 bitmask&
#define nJ1 Sign_Positive
#define nI1 {DataP slot_holder(xY[
#define nH1 ::MakeTrue
#define nG1 {yK2
#define nF1 tree.iH1 a
#define nE1 tree lD 1)y21&&
#define nD1 },{l4::MakeNotP0,l4::
#define nC1 SetParamMove(
#define nB1 CodeTreeImmed(eS1(
#define nA1 <i02 cY2 void
#define n91 <yL2>&
#define n81 yG<i02>&c73,
#define n71 void ByteCodeSynth x8::
#define n61 )const{return
#define n51 rhs n61 hash1
#define n41 changed_if
#define n31 min=eS1(0);
#define n21 opposite=
#define n11 7168 tS 279818,
#define n01 l81 xA2;
#define lZ1 MatchResultType
#define lY1 resulting_exponent
#define lX1 Unknown:default:;}
#define lW1 ,lE 2,1,
#define lV1 (*x6)[a].start_at
#define lU1 ,cAdd,SelectedParams,0},0,
#define lT1 GetParam(a)
#define lS1 inverse_nominator]
#define lR1 void FunctionParserBase
#define lQ1 ,nN,IP,limit,y1,stack);
#define lP1 ByteCodeSynth x8&synth)
#define lO1 xS3 a=0;a<xT;++a)
#define lN1 ;std::cout<<
#define lM1 const yK2
#define lL1 const yG nV1
#define lK1 synth.AddOperation(
#define lJ1 tQ1 found[data.
#define lI1 SetParams(iE1));
#define lH1 o<<"("<<std::hex<<data.
#define lG1 IfBalanceGood(
#define lF1 n_as_tan_param
#define lE1 changed_exponent
#define lD1 retry_positionalparams_2
#define lC1 i02 index
#define lB1 463 tS 273436,
#define lA1 l7 2,2,473304 tS
#define l91 {l4::MakeNotP1,l4::
#define l81 ;return
#define l71 yO3 l81 Unknown;}
#define l61 PlanNtimesCache(
#define l51 AddFunctionOpcode_Float(
#define l41 FPoptimizer_Grammar
#define l31 IP,size_t limit,size_t y1
#define l21 AddOperation(cInv,1,1)nS}
#define l11 e92 ImmedHashGenerator
#define l01 GetPositivityInfo nO3
#define iZ tB2 eS1(
#define iY CopyOnWrite();
#define iX recursioncount
#define iW ParamSpec_SubFunctionData
#define iV inverse_denominator]
#define iU NewHash
#define iT tree.GetParamCount()
#define iS PositionalParams_Rec
#define iR 0x4},{{
#define iQ needs_cow=GetRefCount()>1;
#define iP );nC1 0,cE2);iH1 1);
#define iO DumpTreeWithIndent(*this);
#define iN switch(type iY2 cond_or:
#define iM CalculateResultBoundaries(
#define iL e62 v,eS1(lN
#define iK AddFunctionOpcode_Integer(
#define iJ sim.Eat(
#define iI edited_powgroup
#define iH has_unknown_max
#define iG has_unknown_min
#define iF if(keep_powi
#define iE synthed_tree
#define iD 356668 tS 24852
#define iC +2]=yM|i02(Immed yA3);
#define iB matched_params
#define iA .IsIdenticalTo(
#define i9 by_exponent
#define i8 collections
#define i7 cache
#define i6 }inline
#define i5 lT void range x8::
#define i4 yA comp.cB1[a].value);
#define i3 AnyParams,2},0,0x0},{{
#define i2 cS1.data
#define i1 iF2 nO2(
#define i0 .has_max
#define tZ goto ReplaceTreeWithZero;
#define tY :goto ReplaceTreeWithOne;case
#define tX GetLogicalValue nW1
#define tW lN1 std::endl;DumpHashes(
#define tV ;p2.yB3 p2);tH iH2 nE);e5}
#define tU .lI2
#define tT );tree
#define tS ,{2,
#define tR lZ 0x0},{{
#define tQ yV1 nA
#define tP MakeFalse,l4::
#define tO ].relationship
#define tN <=fp_const_negativezero x8())
#define tM .hash1|=key;iC1 n9
#define tL [n2 eC3=true;lQ[n2 eD3
#define tK l41::Grammar*
#define tJ powgroup lD
#define tI ;pow tU cLog);tH cMul);
#define tH tree tU
#define tG eK2&&found[data.
#define tF },{l4::MakeNotNotP1,l4::
#define tE },{l4::MakeNotNotP0,l4::
#define tD cN3 a-->0;)if(
#define tC nB1(
#define tB has_mulgroups_remaining
#define tA StackTop
#define t9 MatchInfo x8&
#define t8 int_exponent_t
#define t7 RootPowerTable x8::RootPowers[
#define t6 MatchPositionSpec_AnyParams x8
#define t5 iO2 FPoptimizer_ByteCode
#define t4 is_signed
#define t3 iE1));xX1 Rehash();
#define t2 result_positivity
#define t1 biggest_minimum
#define t0 const iW
#define eZ ParamSpec_NumConstant x8
#define eY yK2&tree,std::ostream&o
#define eX !=Unchanged)if(TestCase(
#define eW cond_tree
#define eV else_tree
#define eU then_tree
#define eT .AddParam(
#define eS ;xE3(tree)lN1"\n";
#define eR yK2&tree)
#define eQ sequencing
#define eP StackState
#define eO string FP_GetOpcodeName(
#define eN if_stack
#define eM {return yK2(
#define eL n_as_sin_param
#define eK n_as_cos_param
#define eJ PowiResolver::
#define eI ];};extern"C"{
#define eH .BalanceGood
#define eG AddParamMove(
#define eF valueType
#define eE best_factor
#define eD back().endif_location
#define eC iC1(iJ1)
#define eB iC1 key
#define eA l8 2,1,
#define e9 130,1,
#define e8 MatchPositionSpecBase
#define e7 iF2 yL2(
#define e6 smallest_maximum
#define e5 goto redo;
#define e4 ++IP;y81}if(xW3 xV3.
#define e3 ReplaceTreeWithParam0;
#define e2 factor_needs_rehashing
#define e1 MatchPositionSpecBaseP
#define e0 nL eS1(-y03;
#define cZ 79,112,113,117,118,123,124,127,128,
#define cY )l81 m cM3
#define cX e01 x8(nM.param_list,
#define cW relationships
#define cV 28,29,30,31,32,33,34,35,36,
#define cU cIf,l0 3,
#define cT lK 2},0,0x0},{{
#define cS data.subfunc_opcode
#define cR }if eD2.xJ1==eS1(
#define cQ otherhalf
#define cP :{AdoptChildrenWithSameOpcode(tree);
#define cO map<fphash_t,std::set<std::string> >
#define cN const SequenceOpCode x8
#define cM =fp_cosh(m.min);m.max=fp_cosh(m.max);
#define cL MatchPositionSpec_PositionalParams x8
#define cK eS1(1.5)*fp_const_pi x8()
#define cJ !=Unchanged nZ2 iZ1
#define cI FoundChild
#define cH CalculatePowiFactorCost(
#define cG T1,typename T2>inline i12()(
#define cF yK2 tmp;tmp tU
#define cE has_nonlogical_values
#define cD from_logical_context)
#define cC for xK2 xW.cN3 a-->0;)
#define cB POWI_CACHE_SIZE
#define cA static inline yK2
#define c9 BalanceResultType
#define c8 cIf,eL3
#define c7 nA3(0),Opcode(
#define c6 const{return data->
#define c5 +=fp_const_twopi x8();
#define c4 .AddOperation(lM2,
#define c3 for xK2 0;a<cN3++a){if(
#define c2 static void MakeHash(nD fphash_t&iU,
#define c1 l2 2,
#define c0 MatchPositionSpec_AnyWhere
#define yZ if iZ2 data.match_type==
#define yY }PACKED_GRAMMAR_ATTRIBUTE;
#define yX ,cGreaterOrEq l7 2,2,
#define yW void OutFloatHex(std::ostream&o,
#define yV yV1 x72 range x8::
#define yU b;}};n73<>e92 Comp<
#define yT eT CodeTreeImmed(
#define yS xK2 0;a<iT;++a)
#define yR t93 115824 tS 122999,
#define yQ t93 129136 tS 128123,
#define yP t93 472176 tS 24699,
#define yO ,typename yK2::
#define yN AssembleSequence_Subdivide(
#define yM 0x80000000u
#define yL .push_back(
#define yK !=eK2){lJ1
#define yJ ;yK2
#define yI nZ2 false;
#define yH paramholder_matches
#define yG std::vector
#define yF ,AnyParams,0 l1 0,1,
#define yE ;iJ 2,
#define yD for(lE3 r=range.first;r!=range eE3;++r){
#define yC eT tree lD
#define yB ComparisonSetBase::
#define yA .eG
#define y9 branch2
#define y8 fp_const_twopi x8());if(
#define y7 n73 set_min_max_if<cGreater>(eS1(0),
#define y6 iM tree lD
#define y5 =y6 0));range x8
#define y4 tree lD 1).xJ1
#define y3 x02;tH
#define y2 lX&&tree lD 1)y21
#define y1 factor_stack_base
#define y0 cPow,l6 2,
#define xZ GroupFunction,0},n0{{
#define xY data->c93
#define xX =0;a<nU3.cN3++a)if(
#define xW branch1
#define xV {lK2.erase(i);y81}
#define xU xK2 iT;a-->0;)
#define xT nM xY2
#define xS i02 c;i02 char l[
#define xR 158,167,168,169,178,179,191,195,203,207,215,227,229,232,233,234,235,236,239,240,241,242,245,246,247,248,250,251}};}e92
#define xQ using iO2 FUNCTIONPARSERTYPES;
#define xP const eY=std::cout
#define xO IsIdenticalTo(leaf2 lD
#define xN FPOPT_autoptr
#define xM +=result l81 result;}yV1 inline eS1
#define xL int_exponent
#define xK newnode
#define xJ l3 2,1,
#define xI ParamSpec_SubFunction
#define xH ParamSpec_ParamHolder
#define xG has_highlevel_opcodes
#define xF {if(needs_cow){iY goto
#define xE ;if(fp_nequal(tmp,eS1(0)))lL eS1(1)/tmp)n5}lC
#define xD },{l4::Unchanged,l4::Never},{l4::Unchanged,l4::Never}}
#define xC best_selected_sep
#define xB ->Recalculate_Hash_NoRecursion();}
#define xA fp_sin(min),fp_sin(max))
#define x9 sim.AddConst(
#define x8 <eS1>
#define x7 :nG1 tmp,tmp2;tmp2 tU
#define x6 position
#define x5 GetStackTop()-
#define x4 for yS{range x8
#define x3 SwapLastTwoInStack();
#define x2 FPoptimizer_CodeTree::yK2&tree
#define x1 SetParam(0,iH2 lD 0))yJ p1;p1 tU
#define x0 TestImmedConstraints(param t42,tree)yI
#define nZ {tree.FixIncompleteHashes();}
#define nY {yE3 cInv nW2 x9-1 e21
#define nX paramholder_index
#define nW return true;case
#define nV occurance_counts
#define nU PositionalParams,0},0,
#define nT xQ xD1 tA-1);
#define nS ;synth.yZ2*this)l81;}
#define nR ,l0 1,
#define nQ );a-->0;){lM1&powgroup=lT1;if(powgroup
#define nP ;a<iT;++a)if(ApplyGrammar(tN2,xI2,
#define nO lK 1},0,0x0},{{
#define nN ByteCode
#define nM model_tree
#define nL return range x8(
#define nK yG nV1&l02
#define nJ ConstantFolding_LogicCommon(tree,yB
#define nI eS1>p xO3 p.
#define nH nT1 Ref>inline void xN<Ref>::
#define nG ;tmp2 yC 0 y43 cInv);tmp yY3 l81
#define nF ):data(new nO2 x8(
#define nE .lM2
#define nD FUNCTIONPARSERTYPES::
#define nC iJ1(),c93(),Hash(),Depth(1),eZ1 0){}
#define nB SynthesizeByteCode(synth);
#define nA nO2 x8::nO2(
#define n9 crc=(key>>10)|(key<<(64-10))eC2((~iC1(crc))*3)^1234567;}};
#define n8 GetIntegerInfo nW1 0))==IsAlways)lN3
#define n7 eS1(*const func)(eS1),range x8 model){
#define n6 e72.xJ1
#define n5 ;goto do_return;}
#define n4 while(ApplyGrammar(i01 Grammar&)
#define n3 DumpParams x8 iZ2 data.param_list,xF3 data xY2,o);
#define n2 restholder_index
#define n1 yK2 cE2;cE2 e53 cE2 eT
#define n0 yL1,0x0},
#define lZ t51 1},0,
#define lY ;tree yA n41)nS2
#define lX l23 y21
#define lW eG pow x03;pow.iH1 1);pow.Rehash(tT.nC1 0,pow);goto NowWeAreMulGroup;}
#define lV {cF cPow);y53;tmp yT eS1(
#define lU :if(ParamComparer x8()(c93[1],c93[0])){std::swap(c93[0],c93[1]);Opcode=
#define lT <typename eS1>
#define lS ,eS1(1)/eS1(
#define lR SetParam(0,e72 lD 0)xK1 1,CodeTreeImmed(
#define lQ restholder_matches
#define lP SelectedParams,0},0,0x0},{{
#define lO n41;n41 xQ2 n41 yA e72);n41 eT xW lD
#define lN *const func)(eS1),range x8 model=range x8());
#define lM yV1 yK2::yL2(
#define lL {tree.ReplaceWithImmed(
#define lK cMul,AnyParams,
#define lJ cMul,SelectedParams,0},0,
#define lI cPow,l0 2
#define lH iM tmp)cM3
#define lG :cC3=comp.AddRelationship(atree lD 0),atree lD 1),yB
#define lF typename eS1>i12()i01 eS1&a,e62 b){return a
#define lE t51 0 l1
#define lD .GetParam(
#define lC break;case
#define lB {range x8 m=y6 0));
#define lA xB1 yK2::
#define l9 ?0:1))yJ n41;n41 xQ2 n41 tI1 tree.iE1));n41 y3
#define l8 lK 0 l1
#define l7 ,PositionalParams,0 l1
#define l6 nU iR
#define l5 cAdd,lP 2,
#define l4 RangeComparisonData
#define l3 PositionalParams,0}},{ProduceNewTree,
#define l2 lJ 0x0},{{
#define l1 }},{ReplaceParams,
#define l0 nU 0x0},{{
#ifdef _MSC_VER
typedef
i02
int
iD1;
#else
#include <stdint.h>
typedef
uint_least32_t
iD1;
#endif
iO2
crc32{enum{startvalue=0xFFFFFFFFUL,poly=0xEDB88320UL}
;n73<iD1
crc>e92
b8{enum{b1=(crc
l03
crc
nP2
crc>>1),b2=(b1
l03
b1
nP2
b1>>1),b3=(b2
l03
b2
nP2
b2>>1),b4=(b3
l03
b3
nP2
b3>>1),b5=(b4
l03
b4
nP2
b4>>1),b6=(b5
l03
b5
nP2
b5>>1),b7=(b6
l03
b6
nP2
b6>>1),res=(b7
l03
b7
nP2
b7>>1)}
;}
;inline
iD1
update(iD1
crc,i02
b){
#define B4(n) b8<n>iL2 n+1>iL2 n+2>iL2 n+3>::res
#define R(n) B4(n),B4(n+4),B4(n+8),B4(n+12)
static
const
iD1
table[256]={R(0x00),R(0x10),R(0x20),R(0x30),R(0x40),R(0x50),R(0x60),R(0x70),R(0x80),R(0x90),R(0xA0),R(0xB0),R(0xC0),R(0xD0),R(0xE0),R(0xF0)}
;
#undef R
#undef B4
return((crc>>8))^table[(crc^b)&0xFF];i6
iD1
calc_upd(iD1
c,const
i02
char*buf,size_t
size){iD1
value=c;for(size_t
p=0;p<size;++p)value=update(value,buf[p])l81
value;i6
iD1
calc
i01
i02
char*buf,size_t
size){return
calc_upd(startvalue,buf,size);}
}
#ifndef FPOptimizerAutoPtrHH
#define FPOptimizerAutoPtrHH
nT1
Ref>class
xN{e13
xN():p(0){}
xN(Ref*b):p(b){n93}
xN
i01
xN&b):p(b.p){n93
i6
Ref&e31*(n61*p;i6
Ref*e31->(n61
p;}
xN&e31=(Ref*b){Set(b)l81*this;}
xN&e31=i01
xN&b){Set(b.p)l81*this;}
#ifdef __GXX_EXPERIMENTAL_CXX0X__
xN(xN&&b):p(b.p){b.p=0;}
xN&e31=(xN&&b){if(p!=b.p){cF2;p=b.p;b.p=0;}
return*this;}
#endif
~xN(){cF2
iS2
UnsafeSetP(Ref*newp){p=newp
iS2
swap(xN<Ref>&b){Ref*tmp=p;p=b.p;b.p=tmp;}
private:inline
static
void
Have(Ref*p2);inline
void
cF2;inline
void
n93
inline
void
Set(Ref*p2);private:Ref*p;}
;nH
cF2{if(!p
nZ2;p->nA3-=1;if(!p->nA3)delete
p;}
nH
Have(Ref*p2){if(p2)++(p2->nA3);}
nH
Birth(){Have(p);}
nH
Set(Ref*p2){Have(p2);cF2;p=p2;}
#endif
#include <utility>
e92
Compare2ndRev{nT1
T>inline
i12()i01
T&nB3
T&b
n61
a
eE3>b
eE3;}
}
;e92
Compare1st{nT1
cG
const
nU1
nB3
nU1
b
n61
a.first<b.first;}
nT1
cG
const
nU1
a,T1
b
n61
a.first<b;}
nT1
cG
T1
nB3
nU1
b
n61
a<b.first;}
}
;
#ifndef FPoptimizerHashHH
#define FPoptimizerHashHH
#ifdef _MSC_VER
typedef
i02
long
long
iC1;
#define FPHASH_CONST(x) x##ULL
#else
#include <stdint.h>
typedef
uint_fast64_t
iC1;
#define FPHASH_CONST(x) x##ULL
#endif
iO2
FUNCTIONPARSERTYPES{e92
fphash_t{iC1
hash1,hash2;fphash_t():hash1(0),hash2(0){}
fphash_t
i01
iC1&nB3
iC1&b):hash1(a),hash2(b){}
i12==i01
fphash_t&n51==iM2&&hash2==iN2
i12!=i01
fphash_t&n51!=iM2||hash2!=iN2
i12<i01
fphash_t&n51!=iM2?hash1<iM2:hash2<iN2}
;}
#endif
#ifndef FPOptimizer_CodeTreeHH
#define FPOptimizer_CodeTreeHH
#ifdef FP_SUPPORT_OPTIMIZER
#include <vector>
#include <utility>
iO2
l41{e92
Grammar;}
t5{iP2
ByteCodeSynth;}
iO2
FPoptimizer_CodeTree{iP2
yL2;yT1
nO2;iP2
yL2{typedef
xN<nO2
x8>DataP;DataP
data;e13
yL2();~yL2();e92
OpcodeTag{}
;e7
nR2
o,OpcodeTag);e92
FuncOpcodeTag{}
;e7
nR2
o,i02
f,FuncOpcodeTag);e92
nC3{}
;e7
e62
v,nC3);
#ifdef __GXX_EXPERIMENTAL_CXX0X__
e7
eS1&&v,nC3);
#endif
e92
VarTag{}
;e7
i02
varno,VarTag);e92
CloneTag{}
;e7
iQ2
b,CloneTag);void
GenerateFrom
i01
n81
const
nQ2
const
typename
FunctionParserBase
x8::Data&data,bool
keep_powi=false);void
GenerateFrom
i01
n81
const
nQ2
const
typename
FunctionParserBase
x8::Data&data,const
i22
nK2,bool
keep_powi=false);void
SynthesizeByteCode(n81
nQ2
size_t&stacktop_max);void
SynthesizeByteCode(yW2&synth,bool
MustPopTemps=true)const;size_t
SynthCommonSubExpressions(yV2
lP1
const;void
SetParams
i01
i22
nD3
SetParamsMove(i22
eU1
yL2
GetUniqueRef();
#ifdef __GXX_EXPERIMENTAL_CXX0X__
void
SetParams(yG<yL2>&&eU1
#endif
void
SetParam(size_t
which,iQ2
b);void
nC1
size_t
which,nI2
b);void
AddParam
i01
nI2
param);void
eG
nI2
param);void
AddParams
i01
i22
nD3
AddParamsMove(i22
nD3
AddParamsMove(i22
l02,size_t
l12);void
iH1
size_t
index);void
DelParams();void
Become
i01
nI2
b);inline
size_t
GetParamCount(n61
iE1)yA3;i6
nI2
GetParam(xL3){return
iE1)[n];i6
iQ2
GetParam(xL3
n61
iE1)[n];i6
void
lI2
nR2
o)cX3
Opcode=o;i6
nR2
lM2
c6
Opcode;i6
nD
fphash_t
GetHash()c6
Hash;i6
const
i22
iE1
n61
xY;i6
i22
iE1){return
xY;i6
size_t
xT2
c6
Depth;i6
e62
xJ1
c6
Value;i6
i02
GetVar()c6
iI1
i6
i02
GetFuncNo()c6
iI1
i6
bool
IsDefined(n61
lM2!=nD
cNop;i6
bool
IsImmed(n61
lM2==nD
cImmed;i6
bool
IsVar(n61
lM2==nD
iE2;i6
i02
GetRefCount()c6
nA3
iS2
ReplaceWithImmed
i01
eS1&i);void
Rehash(bool
constantfolding=true);void
Sort();inline
void
Mark_Incompletely_Hashed()cX3
Depth=0;i6
bool
Is_Incompletely_Hashed()c6
Depth==0;i6
const
tK
GetOptimizedUsing()c6
iK1;i6
void
SetOptimizedUsing
i01
tK
g)cX3
iK1=g;}
bool
RecreateInversionsAndNegations(bool
prefer_base2=false);void
FixIncompleteHashes();void
swap(nI2
b){data.swap(b.data);}
bool
IsIdenticalTo
i01
nI2
b)const;void
iY}
;yT1
nO2{int
nA3;nR2
Opcode;eS1
Value;i02
iI1
yG
nV1
c93;nD
fphash_t
Hash;size_t
Depth;const
tK
iK1;nO2();nO2
i01
nO2&b);i1
nR2
o);i1
nR2
o,i02
f);i1
e62
i);
#ifdef __GXX_EXPERIMENTAL_CXX0X__
i1
eS1&&i);nO2(nO2&&b);
#endif
bool
IsIdenticalTo
i01
nO2&b)const;void
Sort();void
Recalculate_Hash_NoRecursion();private:void
e31=i01
nO2&b);}
;yU1
CodeTreeImmed
i01
eS1&i)eM
i
yO
nC3());}
#ifdef __GXX_EXPERIMENTAL_CXX0X__
yU1
CodeTreeImmed(eS1&&i)eM
t72
i)yO
nC3());}
#endif
yU1
CodeTreeOp(nR2
opcode)eM
opcode
yO
OpcodeTag());}
yU1
CodeTreeFuncOp(nR2
opcode,i02
f)eM
opcode,f
yO
FuncOpcodeTag());}
yU1
CodeTreeVar
iL1
varno)eM
varno
yO
VarTag());}
#ifdef FUNCTIONPARSER_SUPPORT_DEBUGGING
xB1
DumpHashes(xP);xB1
xE3(xP);xB1
DumpTreeWithIndent(xP,const
std::string&indent="\\"
);
#endif
}
#endif
#endif
#ifndef FPOPT_NAN_CONST
#include <iostream>
#define FPOPT_NAN_CONST (-1712345.25)
iO2
FPoptimizer_CodeTree{iP2
yL2;}
iO2
l41{enum
ImmedConstraint_Value{ValueMask=0x07,Value_AnyNum=0x0,n12=0x1,Value_OddInt=0x2,t01=0x3,Value_NonInteger=0x4,eE1=0x5
n23
ImmedConstraint_Sign{SignMask=0x18,Sign_AnySign=0x00,nJ1=0x08,n02=0x10,Sign_NoIdea=0x18
n23
ImmedConstraint_Oneness{OnenessMask=0x60,Oneness_Any=0x00,Oneness_One=0x20,Oneness_NotOne=0x40
n23
ImmedConstraint_Constness{ConstnessMask=0x180,Constness_Any=0x00,yL1=0x80,Constness_NotConst=0x100
n23
Modulo_Mode{Modulo_None=0,Modulo_Radians=1
n23
Situation_Flags{LogicalContextOnly=0x01,NotForIntegers=0x02,OnlyForIntegers=0x04
n23
lU2{NumConstant,ParamHolder,SubFunction
n23
ParamMatchingType{PositionalParams,SelectedParams,AnyParams,GroupFunction
n23
RuleType{ProduceNewTree,ReplaceParams}
;
#ifdef __GNUC__
# define PACKED_GRAMMAR_ATTRIBUTE __attribute__((packed))
#else
# define PACKED_GRAMMAR_ATTRIBUTE
#endif
typedef
std::pair<lU2,const
void*>cG2;yV1
cG2
e01
iL1
paramlist,lC1);xG1
ParamSpec_Compare
i01
void*nB3
void*b,lU2
type);i02
ParamSpec_GetDepCode
i01
cG2&b);e92
xH{lC1:8;i02
constraints:9;i02
depcode:15;yY
yT1
ParamSpec_NumConstant{eS1
xZ3;i02
modulo;yY
e92
iW{i02
param_count:2;i02
param_list:30;nR2
subfunc_opcode:8;ParamMatchingType
match_type:3;i02
n2:5;yY
e92
xI{iW
data;i02
constraints:9;i02
depcode:7;yY
e92
Rule{RuleType
ruletype:2;i02
situation_flags:3;i02
repl_param_count:2+11;i02
repl_param_list:30;iW
match_tree;yY
e92
Grammar{i02
rule_count;i02
char
rule_list[999
eI
extern
const
Rule
grammar_rules[];}
xB1
DumpParam
i01
cG2&p,std::ostream&o=std::cout);xB1
DumpParams
iL1
paramlist,i02
count,std::ostream&o=std::cout);}
#endif
#ifndef M_PI
#define M_PI 3.1415926535897932384626433832795
#endif
#define CONSTANT_POS_INF HUGE_VAL
#define CONSTANT_NEG_INF (-HUGE_VAL)
iO2
FUNCTIONPARSERTYPES{yV1
inline
eS1
fp_const_pihalf(){return
fp_const_pi
x8()*yF3;}
yV1
inline
eS1
fp_const_twopi(){eS1
cY3
fp_const_pi
x8());e03
fp_const_twoe(){eS1
cY3
fp_const_e
x8());e03
fp_const_twoeinv(){eS1
cY3
fp_const_einv
x8());e03
fp_const_negativezero(){
#ifdef FP_EPSILON
return-fp_epsilon
x8();
#else
return
eS1(-1e-14);
#endif
}
}
#ifdef FP_SUPPORT_OPTIMIZER
#include <vector>
#include <utility>
#include <iostream>
iO2
FPoptimizer_Optimize{using
iO2
l41;using
iO2
FPoptimizer_CodeTree;xQ
iP2
MatchInfo{e13
yG<std::pair<bool,yG
nV1> >lQ;yG
nV1
yH;yG<i02>iB;e13
MatchInfo():lQ(),yH(),iB(){}
e13
bool
SaveOrTestRestHolder
iL1
n2,lL1&tM1){cL1{lQ
nE3
n2+1);lQ
tL=tM1
nS2
if(lQ[n2
eC3==false){lQ
tL=tM1
nS2
lL1&found=lQ[n2
eD3;if(tM1
yA3!=found
yA3
yI
for
xK2
0;a<tM1
eW2
a)if(!tM1[a]iA
found[a])yI
return
true
iS2
SaveRestHolder
iL1
n2,yG
nV1&tM1){cL1
lQ
nE3
n2+1);lQ
tL.swap(tM1);}
bool
SaveOrTestParamHolder
iL1
nX,lM1&nG3){if(yH
yA3<=nX){yH.nH3
nX+1);yH
nE3
nX);yH
yL
nG3)nS2
if(!yH[nX].iA1{yH[nX]=nG3
nS2
return
nG3
iA
yH[nX]iR2
SaveMatchedParamIndex(lC1){iB
yL
index);}
lM1&GetParamHolderValueIfFound
iL1
nX)const{static
lM1
dummytree;if(yH
yA3<=nX
nZ2
dummytree
l81
yH[nX];}
lM1&GetParamHolderValue
iL1
nX
n61
yH[nX];}
bool
HasRestHolder
iL1
n2
n61
lQ
yA3>n2&&lQ[n2
eC3==true;}
lL1&GetRestHolderValues
iL1
n2)const{static
lL1
empty_result;cL1
return
empty_result
l81
lQ[n2
eD3;}
const
yG<i02>&GetMatchedParamIndexes(n61
iB
iS2
swap(t9
b){lQ.swap(b.lQ);yH.swap(b.yH);iB.swap(b.iB);}
t9
e31=i01
t9
b){lQ=b.lQ;yH=b.yH;iB=b.iB
l81*this;}
}
;class
e8;typedef
xN<e8>e1;class
e8{e13
int
nA3;e13
e8():nA3(0){}
virtual~e8(){}
}
;e92
lZ1{bool
found;e1
specs;lZ1(bool
f):found(f),specs(){}
lZ1(bool
f
eA2
s):found(f),specs(s){}
}
;xB1
SynthesizeRule
eX3
yK2&tree,t9
info);yV1
lZ1
TestParam
i01
cG2&xZ2
lM1&tree
eA2
start_at,t9
info);yV1
lZ1
TestParams(t0&nM,lM1&tree
eA2
start_at,t9
info,bool
tA1;xG1
ApplyGrammar
i01
Grammar&tN2,x2,bool
from_logical_context=false);xB1
ApplyGrammars(x2);xG1
IsLogisticallyPlausibleParamsMatch(t0&cB2,const
eR;}
iO2
l41{xB1
DumpMatch
eX3
const
x2,const
FPoptimizer_Optimize::t9
info,bool
DidMatch,std::ostream&o=std::cout);xB1
DumpMatch
eX3
const
x2,const
FPoptimizer_Optimize::t9
info,const
char*eY3,std::ostream&o=std::cout);}
#endif
#include <string>
eG2
l41::lU2
yK1=false);eG2
nR2
yK1=false);
#include <string>
#include <sstream>
#include <assert.h>
#include <iostream>
using
iO2
l41;xQ
eG2
l41::lU2
yK1){
#if 1
const
char*p=0;switch(opcode
iY2
NumConstant:p="NumConstant"
;lC
ParamHolder:p="ParamHolder"
;lC
SubFunction:p="SubFunction"
;nM3
std::ostringstream
tmp;assert(p);tmp<<p;if(pad)while(tmp.str()yA3<12)tmp<<' 'l81
tmp.str();
#else
std::ostringstream
tmp;tmp<<opcode;if(pad)while(tmp.str()yA3<5)tmp<<' 'l81
tmp.str();
#endif
}
eG2
nR2
yK1){
#if 1
const
char*p=0;switch(opcode
iY2
cAbs:p="cAbs"
;lC
cAcos:p="cAcos"
;lC
cAcosh:p="cAcosh"
;lC
cAsin:p="cAsin"
;lC
cAsinh:p="cAsinh"
;lC
cAtan:p="cAtan"
;lC
cAtan2:p="cAtan2"
;lC
cAtanh:p="cAtanh"
;lC
cCbrt:p="cCbrt"
;lC
cCeil:p="cCeil"
;lC
cCos:p="cCos"
;lC
cCosh:p="cCosh"
;lC
cCot:p="cCot"
;lC
cCsc:p="cCsc"
;lC
cEval:p="cEval"
;lC
cExp:p="cExp"
;lC
cExp2:p="cExp2"
;lC
cFloor:p="cFloor"
;lC
cHypot:p="cHypot"
;lC
cIf:p="cIf"
;lC
cInt:p="cInt"
;lC
cLog:p="cLog"
;lC
cLog2:p="cLog2"
;lC
cLog10:p="cLog10"
;lC
cMax:p="cMax"
;lC
cMin:p="cMin"
;lC
cPow:p="cPow"
;lC
cSec:p="cSec"
;lC
cSin:p="cSin"
;lC
cSinh:p="cSinh"
;lC
cSqrt:p="cSqrt"
;lC
cTan:p="cTan"
;lC
cTanh:p="cTanh"
;lC
cTrunc:p="cTrunc"
;lC
cImmed:p="cImmed"
;lC
cJump:p="cJump"
;lC
cNeg:p="cNeg"
;lC
cAdd:p="cAdd"
;lC
cSub:p="cSub"
;lC
cMul:p="cMul"
;lC
cDiv:p="cDiv"
;lC
cMod:p="cMod"
;lC
cEqual:p="cEqual"
;lC
t71:p="cNEqual"
;lC
cLess:p="cLess"
;lC
cLessOrEq:p="cLessOrEq"
;lC
cGreater:p="cGreater"
;lC
cGreaterOrEq:p="cGreaterOrEq"
;lC
cNot:p="cNot"
;lC
cAnd:p="cAnd"
;lC
cOr:p="cOr"
;lC
cDeg:p="cDeg"
;lC
cRad:p="cRad"
;lC
cFCall:p="cFCall"
;lC
cPCall:p="cPCall"
;break;
#ifdef FP_SUPPORT_OPTIMIZER
case
cFetch:p="cFetch"
;lC
cPopNMov:p="cPopNMov"
;lC
cLog2by:p="cLog2by"
;lC
cNop:p="cNop"
;break;
#endif
case
cSinCos:p="cSinCos"
;lC
yR3:p="cAbsNot"
;lC
cAbsNotNot:p="cAbsNotNot"
;lC
cAbsAnd:p="cAbsAnd"
;lC
cAbsOr:p="cAbsOr"
;lC
i03:p="cAbsIf"
;lC
cDup:p="cDup"
;lC
cInv:p="cInv"
;lC
cSqr:p="cSqr"
;lC
cRDiv:p="cRDiv"
;lC
cRSub:p="cRSub"
;lC
cNotNot:p="cNotNot"
;lC
cRSqrt:p="cRSqrt"
;lC
iE2:p="VarBegin"
;nM3
std::ostringstream
tmp;assert(p);tmp<<p;if(pad)while(tmp.str()yA3<12)tmp<<' 'l81
tmp.str();
#else
std::ostringstream
tmp;tmp<<opcode;if(pad)while(tmp.str()yA3<5)tmp<<' 'l81
tmp.str();
#endif
}
#ifdef FP_SUPPORT_OPTIMIZER
#include <vector>
#include <utility>
#ifndef FP_GENERATING_POWI_TABLE
enum{MAX_POWI_BYTECODE_LENGTH=20}
;
#else
enum{MAX_POWI_BYTECODE_LENGTH=999}
;
#endif
enum{MAX_MULI_BYTECODE_LENGTH=3}
;t5{iP2
ByteCodeSynth{e13
ByteCodeSynth():nN(),Immed(),eP(),tA(0),StackMax(0){nN.nH3
64);Immed.nH3
8);eP.nH3
16
iR2
Pull(yG<i02>&bc,yG
x8&imm,size_t&StackTop_max){for
iL1
a=0;a<nN
eW2
a){nN[a]&=~yM;}
nN.swap(bc);Immed.swap(imm);StackTop_max=StackMax;}
size_t
GetByteCodeSize(n61
nN
yA3;}
size_t
GetStackTop(n61
tA
iS2
PushVar
iL1
varno){e23
varno);nV2}
void
PushImmed(eS1
immed){xQ
e23
cImmed);Immed
yL
immed);nV2}
void
StackTopIs
cA3,int
offset=0){if((int)tA>offset){eP[tA
lN2
first=true;eP[tA
lN2
second=tree;}
}
bool
IsStackTop
cA3,int
offset=0
n61(int)tA>offset&&eP[tA
lN2
first&&eP[tA
lN2
second
iA
tree);i6
void
EatNParams
iL1
cH2){tA-=cH2
iS2
ProducedNParams
iL1
e41){xD1
tA+e41
iR2
AddOperation
iL1
opcode,i02
cH2,i02
e41=1){EatNParams(cH2);xQ
AddFunctionOpcode(opcode);ProducedNParams(e41
iR2
DoPopNMov(size_t
cI2,size_t
srcpos){xQ
e23
cPopNMov);e23
yM|iL1)cI2);e23
yM|iL1)srcpos);xD1
srcpos+1);eP[cI2]=eP[srcpos];xD1
cI2+1
iR2
DoDup(size_t
nI3){xQ
if(nI3==tA-1){e23
cDup);}
else{e23
cFetch);e23
yM|iL1)nI3);}
nV2
eP[tA-1]=eP[nI3];}
size_t
e33
cA3)const{for
xK2
tA;a-->0;)if(eP[a
eC3&&eP[a
eD3
iA
tree)nZ2
a
l81
eK2;}
bool
Find
cA3
n61
e33
nO3
eK2;}
bool
FindAndDup
cA3){size_t
pos=e33(tree);if(pos!=eK2){
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<tZ3"duplicate at ["
<<pos<<"]: "
;xE3(tree)lN1" -- issuing cDup or cFetch\n"
;
#endif
DoDup(pos)nS2
nX2
e92
IfData{size_t
ofs;}
;void
SynthIfStep1(IfData&yJ2,nR2
op){nT
yJ2.ofs=nN
yA3;e23
op);e23
yM);e23
yM
iR2
SynthIfStep2(IfData&yJ2){nT
nN[yJ2.ofs+1]eJ1+2);nN[yJ2.ofs
iC
yJ2.ofs=nN
yA3;e23
cJump);e23
yM);e23
yM
iR2
SynthIfStep3(IfData&yJ2){nT
nN.back()|=yM;nN[yJ2.ofs+1]eJ1-1);nN[yJ2.ofs
iC
nV2
for
xK2
0;a<yJ2.ofs;++a){if(nN[a]==cJump&&nN[a+1]==(yM|(yJ2.ofs-1))){nN[a+1]eJ1-1);nN[a
iC
yN3(nN[a]iY2
i03:case
cIf:case
cJump:case
cPopNMov:a+=2;lC
cFCall:case
cPCall:case
cFetch:a+=1;break;default:nM3}
}
protected:void
xD1
size_t
value){tA=value;if(tA
eL2{StackMax=tA;yS1);}
}
void
l51
eK1;void
iK
eK1;void
AddFunctionOpcode(eK1;private:yG<i02>nN;yG
x8
Immed;yG<std::pair<bool,FPoptimizer_CodeTree::yK2> >eP;size_t
tA;size_t
StackMax;}
;yT1
SequenceOpCode;yT1
eX1{static
cN
AddSequence;static
cN
MulSequence;}
;xB1
x31
long
count,cN&eQ,lP1;}
#endif
#ifdef FP_SUPPORT_OPTIMIZER
xQ
t5{yT1
SequenceOpCode{eS1
basevalue;i02
op_flip;i02
op_normal,op_normal_flip;i02
op_inverse,op_inverse_flip;}
;yV1
cN
eX1
x8::AddSequence={eS1(0),cNeg,cAdd,cAdd,cSub,cRSub}
;yV1
cN
eX1
x8::MulSequence={eS1(1),cInv,cMul,cMul,cDiv,cRDiv}
;yV1
n71
l51
eK1{int
mStackPtr=0;
#define incStackPtr() do{if(tA+2 eL2 yS1=tA+2);}while(0)
#define findName(a,b,c) "var"
#define TryCompilePowi(o) false
#define mData this
#define mByteCode nN
#define mImmed Immed
# define FP_FLOAT_VERSION 1
# include "fp_opcode_add.inc"
# undef FP_FLOAT_VERSION
#undef mImmed
#undef mByteCode
#undef mData
#undef TryCompilePowi
#undef incStackPtr
}
yV1
n71
iK
eK1{int
mStackPtr=0;
#define incStackPtr() do{if(tA+2 eL2 yS1=tA+2);}while(0)
#define findName(a,b,c) "var"
#define TryCompilePowi(o) false
#define mData this
#define mByteCode nN
#define mImmed Immed
# define FP_FLOAT_VERSION 0
# include "fp_opcode_add.inc"
# undef FP_FLOAT_VERSION
#undef mImmed
#undef mByteCode
#undef mData
#undef TryCompilePowi
#undef incStackPtr
}
yV1
n71
AddFunctionOpcode(eK1{if(IsIntType
x8::result)iK
opcode);else
l51
opcode);}
}
using
t5;
#define POWI_TABLE_SIZE 256
#define POWI_WINDOW_SIZE 3
t5{
#ifndef FP_GENERATING_POWI_TABLE
extern
const
i02
char
powi_table[POWI_TABLE_SIZE];const
#endif
i02
char
powi_table[POWI_TABLE_SIZE]={0,1,1,1,2,1
eM2
1,4,1,2,e43
eM2
1,8,cB3
e73
15,1,16,1
eM2
e43,2,1,4,cB3
1,16,1,25,e73
27,5,8,3,2,1,30,1,31,3,32,1
eM2
1,8,1,2,e73
39,1,16,137,2,1,4,cB3
e43,45,135,4,31,2,5,32,1,2,131,50,1,51,1,8,3,2,1,54,1,55,3,16,1,57,133,4,137,2,135,60,1,61,3,62,133,63,1,tN1
131,tN1
139,iM1
e9
30,1,130,137,2,31,iM1
e9
e9
130,cB3
1,e9
e9
2,1,130,133,tN1
61,130,133,62,139,130,137,e9
iM1
e9
e9
tN1
131,e9
e9
130,131,2,133,iM1
130,141,e9
130,cB3
1,e9
5,135,e9
iM1
e9
iM1
130,133,130,141,130,131,e9
e9
2,131}
;}
static
lX3
cB=256;
#define FPO(x)
iO2{class
PowiCache{private:int
i7[cB];int
tO1[cB];e13
PowiCache():i7(),tO1(){i7[1]=1;}
bool
Plan_Add(yW1,int
count){c51>=cB
yI
tO1[eP2+=count
l81
i7[eP2!=0
iS2
iU2
yW1){c51<cB)i7[eP2=1
iS2
Start(size_t
value1_pos){for(int
n=2;n<cB;++n)i7[n]=-1;Remember(1,value1_pos);DumpContents();}
int
Find(yW1)const{c51<cB){if(i7[eP2>=0){FPO(tK3(tO3,"* I found %ld from cache (%u,%d)\n",value,(unsigned)cache[value],tL3 value]))l81
i7[eP2;}
}
return-1
iS2
Remember(yW1,size_t
tW3){c51>=cB
nZ2;FPO(tK3(tO3,"* Remembering that %ld can be found at %u (%d uses remain)\n",value,(unsigned)tW3,tL3 value]));i7[eP2=(int)tW3
iS2
DumpContents()const{FPO(for(int a=1;a<POWI_CACHE_SIZE;++a)if(cache[a]>=0||tL3 a]>0){tK3(tO3,"== cache: sp=%d, val=%d, needs=%d\n",cache[a],a,tL3 a]);})}
int
UseGetNeeded(yW1){c51>=0&&value<cB
nZ2--tO1[eP2
l81
0;}
}
;yV1
size_t
yN
long
count
tR1
cN&eQ,lP1;xB1
yX1
size_t
apos,long
aval,size_t
bpos,long
bval
tR1
i02
cumulation_opcode,i02
cimulation_opcode_flip,lP1;void
l61
yW1
tR1
int
need_count,int
iX=0){c51<1
nZ2;
#ifdef FP_GENERATING_POWI_TABLE
if(iX>32)throw
false;
#endif
if(i7.Plan_Add(value,need_count)nZ2;long
nJ3
1;c51<POWI_TABLE_SIZE){nJ3
powi_table[eP2
iT2&128){half&=127
iT2&64)nJ3-eQ2
FPO(tK3(tO3,"value=%ld, half=%ld, otherhalf=%ld\n",value,half,value/half));l61
half,yM2
i7.iU2
half)l81;}
tP1
half&64){nJ3-eQ2}
}
else
c51&1)nJ3
value&((1<<POWI_WINDOW_SIZE)-1);else
nJ3
value/2;long
cQ=value-half
iT2>cQ||half<0)std::swap(half,cQ);FPO(tK3(tO3,"value=%ld, half=%ld, otherhalf=%ld\n",value,half,otherhalf))iT2==cQ){l61
half,i7,2,iX+1);}
else{l61
half,yM2
l61
cQ>0?cQ:-cQ,yM2}
i7.iU2
value);}
yV1
size_t
yN
yW1
tR1
cN&eQ,lP1{int
nK3=i7.Find(value);if(nK3>=0){return
nK3;}
long
nJ3
1;c51<POWI_TABLE_SIZE){nJ3
powi_table[eP2
iT2&128){half&=127
iT2&64)nJ3-eQ2
FPO(tK3(tO3,"* I want %ld, my plan is %ld * %ld\n",value,half,value/half));size_t
x52=yN
half
c61
if(i7
iN1
half)>0||x52!=c71){tQ1
x52)nU2
half,c71);}
x31
value/half
eR2
size_t
tW3=c71
nU2
value,tW3);i7.DumpContents()l81
tW3;}
tP1
half&64){nJ3-eQ2}
}
else
c51&1)nJ3
value&((1<<POWI_WINDOW_SIZE)-1);else
nJ3
value/2;long
cQ=value-half
iT2>cQ||half<0)std::swap(half,cQ);FPO(tK3(tO3,"* I want %ld, my plan is %ld + %ld\n",value,half,value-half))iT2==cQ){size_t
x52=yN
half
c61
yX1
x52,half,x52,half,i7,eQ.op_normal,eQ.op_normal_flip,synth);}
else{long
part1=half;long
part2=cQ>0?cQ:-cQ;size_t
part1_pos=yN
part1
c61
size_t
part2_pos=yN
part2
c61
FPO(tK3(tO3,"Subdivide(%ld: %ld, %ld)\n",value,half,otherhalf));yX1
part1_pos,part1,part2_pos,part2,i7,cQ>0?eQ.op_normal:eQ.op_inverse,cQ>0?eQ.op_normal_flip:eQ.op_inverse_flip,synth);}
size_t
tW3=c71
nU2
value,tW3);i7.DumpContents()l81
tW3;}
xB1
yX1
size_t
apos,long
aval,size_t
bpos,long
bval
tR1
i02
cumulation_opcode,i02
cumulation_opcode_flip,lP1{int
a_needed=i7
iN1
aval);int
nL3=i7
iN1
bval);bool
iO1
i13
#define DUP_BOTH() do tX3<bpos){size_t tmp=apos;apos=bpos;bpos=tmp;iO1=!iO1;}FPO(tK3(tO3,"-> "tV3 tV3"op\n",(unsigned)apos,(unsigned)bpos));tQ1 apos);tQ1 apos==bpos?c71:bpos);}while(0)
#define DUP_ONE(p) do{FPO(tK3(tO3,"-> "tV3"op\n",(unsigned)p));tQ1 p);}while(0)
if(a_needed>0){if(nL3>0){lO2}
else{if(bpos!=c71)lO2
else{iP1
iO1=!iO1;}
}
}
tP1
nL3>0)tX3!=c71)lO2
else
DUP_ONE(bpos);}
else
tX3==bpos&&apos==c71)iP1
tP1
apos==c71&&bpos==synth.x5
2){FPO(tK3(tO3,"-> op\n"));iO1=!iO1;}
tP1
apos==synth.x5
2&&bpos==c71)FPO(tK3(tO3,"-> op\n"));tP1
apos==c71)DUP_ONE(bpos);tP1
bpos==c71){iP1
iO1=!iO1;}
else
lO2}
lK1
iO1?cumulation_opcode_flip:cumulation_opcode,2);}
xB1
cA1
long
count,cN&eQ,lP1{while
cR3<256){int
nJ3
yV2
powi_table[count]iT2&128){half&=127;cA1
half
eR2
count/=half;}
else
nM3
if
cR3==1
nZ2;if(!cR3&1)){lK1
cSqr,1);cA1
count/2
eR2}
else{tQ1
c71);cA1
count-1
eR2
lK1
cMul,2);}
}
}
t5{xB1
x31
long
count,cN&eQ,lP1{if
cR3==0)yX2
eQ.basevalue
t73
bool
eT2
i13
if
cR3<0){eT2=true;count=-count;}
if(false)cA1
count
eR2
tP1
count>1){PowiCache
i7;l61
count,i7,1);size_t
xE1
t13
GetStackTop();i7.Start(c71);FPO(tK3(tO3,"Calculating result for %ld...\n",count));size_t
x62=yN
count
c61
size_t
n_excess
t13
x5
xE1;if(n_excess>0||x62!=xE1-1){synth.DoPopNMov(xE1-1,x62);}
}
if(eT2)lK1
eQ.op_flip,1);}
}
}
#endif
#ifndef FPOptimizer_RangeEstimationHH
#define FPOptimizer_RangeEstimationHH
iO2
FPoptimizer_CodeTree{enum
TriTruthValue{IsAlways,yO3,Unknown}
;yT1
range{eS1
min,max;bool
iV2,has_max;range():min(),max(),iV2(false
cS3
false)x43
eS1
mi,eS1
ma):min(mi),max(ma),iV2(true
cS3
true)x43
bool,eS1
ma):min(),max(ma),iV2(false
cS3
true)x43
eS1
mi,bool):min(mi),max(),iV2(true
cS3
false){}
void
set_abs();void
set_neg();x72
set_min_max_if(iL
x72
set_min_if(iL
x72
set_max_if(iL
void
set_min(eS1(lN
void
set_max(eS1(lN
void
y82
eS1(lN}
;yV1
inline
bool
IsLogicalTrueValue
i01
range
x8&p
cD2
if(p
y41
p.min>=0.5
nZ2
true;if(!abs&&p
iW2<=-0.5
nZ2
true
l81
false;}
yV1
inline
bool
IsLogicalFalseValue
i01
range
x8&p
cD2
if(abs
nZ2
p
iW2<0.5;else
return
p
y41
p
i0&&p.min>-0.5
xQ3<0.5;}
yV1
range
x8
iM
const
eR;xG1
IsLogicalValue
i01
eR;yV1
TriTruthValue
GetIntegerInfo
i01
eR;y51
GetEvennessInfo
i01
eR{if(!tree
y21
nZ2
Unknown;yF1=yZ3;if(isEvenInteger(value)nZ2
x82
isOddInteger(value)nZ2
l71
y51
GetPositivityInfo
i01
eR{range
x8
p=iM
tree);if(p
y41
p.min
cH1
nZ2
x82
p
iW2
t83
nZ2
l71
y51
GetLogicalValue(lM1&tree
cD2
range
x8
p=iM
tree);if(IsLogicalTrueValue(p,abs)nZ2
x82
IsLogicalFalseValue(p,abs)nZ2
l71}
#endif
#ifndef FPOptimizer_ConstantFoldingHH
#define FPOptimizer_ConstantFoldingHH
iO2
FPoptimizer_CodeTree{xB1
ConstantFolding(eR;}
#endif
iO2{xQ
using
iO2
FPoptimizer_CodeTree;e92
ComparisonSetBase{enum{e93=0x1,Eq_Mask=0x2,Le_Mask=0x3,eA3=0x4,eB3=0x5,Ge_Mask=0x6}
;static
int
Swap_Mask(int
m){return(m&Eq_Mask)|((m&e93)?eA3:0)|((m&eA3)?e93:0);}
enum
yY1{Ok,BecomeZero,BecomeOne,xA2
n23
lV2{cond_or,i32,i42,i52}
;}
;yT1
ComparisonSet:public
ComparisonSetBase{e92
eU2
nG1
a
yJ
b;int
relationship;eU2():a(),b(),relationship(){}
}
;yG<eU2>cW;e92
Item
nG1
value;bool
yN2;Item():value(),yN2(false){}
}
;yG<Item>cB1;int
xF1;ComparisonSet():cW(),cB1(),xF1(0){}
yY1
AddItem(lM1&a,bool
yN2,lV2
type){for(size_t
c=0;c<cB1
eW2
c)if(cB1[c].value
iA
a)){if(yN2!=cB1[c].yN2){iN
cM1
case
i52:cB1.erase(cB1.begin()+c);xF1+=1
n01
case
i32:case
i42:cN1}
}
return
xA2;}
Item
pole;pole.value=a;pole.yN2=yN2;cB1
yL
pole)l81
Ok;}
yY1
AddRelationship(yK2
a,yK2
b,int
eY1,lV2
type){iN
cT3
7)cM1
lC
i52:cT3
7){xF1+=1
n01}
lC
i32:case
i42:cT3
0)cN1
nM3
if(!(a.GetHash()<b.GetHash())){a.swap(b);eY1=Swap_Mask(eY1);}
for(size_t
c=0;c<cW
eW2
c){if(cW[c].a
iA
a)&&cW[c].b
iA
b)){iN{int
nS3=x92|eY1;if(nS3==7)cM1
x92=nS3;nM3
case
i32:case
i42:{int
nS3=x92&eY1;if(nS3==0)cN1
x92=nS3;nM3
case
i52:{int
newrel_or=x92|eY1;int
xB2=x92&eY1;iQ1
5&&xB2==0){x92=eB3
n01}
iQ1
7&&xB2==0){xF1+=1;cW.erase(cW.begin()+c)n01}
iQ1
7&&xB2==Eq_Mask){x92=Eq_Mask;xF1+=1
n01}
y81}
}
return
xA2;}
}
eU2
comp;comp.a=a;comp.b=b;comp.relationship=eY1;cW
yL
comp)l81
Ok;}
}
;nT1
eS1,typename
CondType>bool
ConstantFolding_LogicCommon(yK2&tree,CondType
xA1,bool
xC2){bool
should_regenerate
i13
ComparisonSet
x8
comp
eV3
typename
yB
yY1
cC3=yB
Ok;lM1&atree=xI2;switch(atree
nE
iY2
cEqual
lG
Eq_Mask
eB2
t71
lG
eB3
eB2
cLess
lG
e93
eB2
cLessOrEq
lG
Le_Mask
eB2
cGreater
lG
eA3
eB2
cGreaterOrEq
lG
Ge_Mask
eB2
cNot:cC3
y11
lD
0),true
eB2
cNotNot:cC3
y11
lD
0),false,xA1);break;default:if(xC2||IsLogicalValue(atree))cC3
y11,false,xA1);yN3(cC3){ReplaceTreeWithZero
xP3
ReplaceWithImmed(0)l81
true;ReplaceTreeWithOne
xP3
ReplaceWithImmed(1);nW
yB
Ok:lC
yB
BecomeZero:yP3
yB
BecomeOne
tY
yB
xA2:c11
nM3}
if(should_regenerate){
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"Before ConstantFolding_LogicCommon: "
eS
#endif
if(xC2){tree.DelParams();}
else{for
xU{lM1&atree=xI2;if(IsLogicalValue(atree))nF1);}
}
for
xK2
0;a<comp.cB1
eW2
a){if(comp.cB1[a].yN2)eV2
cNot);r
i4
r.cO1
tP1!xC2)eV2
cNotNot);r
i4
r.cO1
else
tree
i4}
for
xK2
0;a<comp.cW
eW2
a)eV2
cNop);switch(comp.cW[a
tO
iY2
yB
e93:r
tU
cLess);lC
yB
Eq_Mask:r
tU
cEqual);lC
yB
eA3:r
tU
cGreater);lC
yB
Le_Mask:r
tU
cLessOrEq);lC
yB
eB3:r
tU
t71);lC
yB
Ge_Mask:r
tU
cGreaterOrEq
nW2
r
yA
comp.cW[a].a);r
yA
comp.cW[a].b);r.cO1
if(comp.xF1!=0)tree
yT
eS1(comp.xF1)));
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"After ConstantFolding_LogicCommon: "
eS
#endif
return
true;}
nX2
xG1
ConstantFolding_AndLogic(tT3(tree.tU3()==cAnd
tI3()==cAbsAnd)l81
nJ
i32,true);}
xG1
ConstantFolding_OrLogic(tT3(tree.tU3()==cOr
tI3()==cAbsOr)l81
nJ
cond_or,true);}
xG1
ConstantFolding_AddLogicItems(tT3(tree.tU3()==cAdd)l81
nJ
i52,false);}
xG1
ConstantFolding_MulLogicItems(tT3(tree.tU3()==cMul)l81
nJ
i42,false);}
}
#include <vector>
#include <map>
#include <algorithm>
iO2{xQ
using
iO2
FPoptimizer_CodeTree;e92
CollectionSetBase{enum
xH1{Ok,xA2}
;}
;yT1
CollectionSet:public
CollectionSetBase{e92
yZ1
nG1
value
yJ
xD2;bool
e2;yZ1():value(),xD2(),e2(false){}
yZ1(lM1&v,lM1&f):value(v),xD2(f),e2(false){}
}
;std::multimap<fphash_t,yZ1>i8;typedef
typename
std::multimap<fphash_t,yZ1>::nX3
xI1;CollectionSet():i8(){}
xI1
FindIdenticalValueTo(lM1&value){fphash_t
hash=value.GetHash();for(xI1
i=i8.xE2
hash);i!=i8.cP1
hash;++i){c51
iA
i
cJ2.value)nZ2
i;}
return
i8.end();}
bool
Found
i01
xI1&b){return
b!=i8.end();}
xH1
AddCollectionTo(lM1&xD2,const
xI1&into_which){yZ1&c=into_which
cJ2;if(c.e2)c.xD2
eT
xD2);else
nG1
add;add
tU
cAdd);add
yA
c.xD2);add
eT
xD2);c.xD2.swap(add);c.e2=true;}
return
xA2;}
xH1
iR1
lM1&value,lM1&xD2){const
fphash_t
hash=value.GetHash();xI1
i=i8.xE2
hash);for(;i!=i8.cP1
hash;++i){if(i
cJ2.value
iA
value)nZ2
AddCollectionTo(xD2,i);}
i8.nT3,std::make_pair(hash,yZ1(value,xD2)))l81
Ok;}
xH1
iR1
lM1&a){return
iR1
a,nB1
1)));}
}
;yT1
ConstantExponentCollection{typedef
yG
nV1
nV3;typedef
std::x51
xF2;yG<xF2>data;ConstantExponentCollection():data(){}
void
MoveToSet_Unique
i01
eS1&e51&e61){data
yL
std::x51(e51()));data.back()eE3.swap(e61
iR2
MoveToSet_NonUnique
i01
eS1&e51&e61){typename
yG<xF2>::nX3
i=std::xE2
data.i62
data.end(),cE2,Compare1st());if(i!=data.cP1
cE2){i
cJ2.nT3
cJ2.end(),e61.i62
e61.end());}
else{data.nT3,std::x51(cE2,e61));}
}
bool
Optimize(){bool
changed
i13
std::sort(data.i62
data.end(),Compare1st());redo:for
xK2
0;a<data
eW2
a){eS1
exp_a=data[a
eC3
i82
exp_a,nY3
y81
for(iX2
a+1;b<data
eW2
b){eS1
exp_b=data[b
eC3;eS1
xG2=exp_b-exp_a;if(xG2>=fp_abs(exp_a
n33
exp_diff_still_probable_integer=xG2*eS1(16);if(eY2
exp_diff_still_probable_integer)&&!(eY2
exp_b)&&!eY2
xG2))){nV3&a_set=iS1;nV3&b_set=data[b
eD3;
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"Before ConstantExponentCollection iteration:\n"
;eZ2
cout);
#endif
if(isEvenInteger(exp_b)&&!isEvenInteger(xG2+exp_a))nG1
tmp2;tmp2
e53
tmp2
tI1
b_set);tmp2
i72
tmp;tmp
tU
cAbs);tmp
yY3;tmp
x02;b_set
nE3
1);b_set[0
t23
tmp);}
a_set.insert(a_set.end(),b_set.i62
b_set.end());nV3
b_copy=b_set;data.erase(data.begin()+b);MoveToSet_NonUnique(xG2,b_copy);yI1
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"After ConstantExponentCollection iteration:\n"
;eZ2
cout);
#endif
e5}
}
}
return
changed;}
#ifdef DEBUG_SUBSTITUTIONS
void
eZ2
ostream&out){for
xK2
0;a<data
eW2
a){out.precision(12);out<<data[a
eC3<<": "
;eW3
iS1
eW2
b){if(b>0)out<<'*';xE3(iS1[b],out);}
out<<std::endl;}
}
#endif
}
;yV1
static
yK2
x61
yK2&value,bool&xG){switch(value
nE
iY2
cPow:nG1
cE2=value
lD
1);value.y71
l81
cE2
cM3
cRSqrt:value.y71;xG=true
l81
nB1-0.5));case
cInv:value.y71;xG=true
l81
nB1-1));default:nM3
return
nB1
1))eI2
void
e71
e81&mul,lM1&tree,lM1&xD2,bool&c01
bool&xG){for
yS
nG1
value
nW1
a))yJ
cE2(x61
value,xG));if(!xD2
y21||xD2.xJ1!=1.0)nG1
cQ1;cQ1
e53
cQ1
eT
cE2);cQ1
eT
xD2);cQ1
x02;cE2.swap(cQ1);}
#if 0 /* FIXME: This does not work */
c51
nE==cMul){if(1){bool
exponent_is_even=cE2
y21&&isEvenInteger(cE2.xJ1);eW3
value.c81{bool
tmp=false
yJ
val(value
lD
b))yJ
exp(x61
val,tmp));if(exponent_is_even||(exp
y21&&isEvenInteger(exp.xJ1)))nG1
cQ1;cQ1
e53
cQ1
eT
cE2);cQ1
yA
exp);cQ1.ConstantFolding();if(!cQ1
y21||!isEvenInteger(cQ1.xJ1)){goto
cannot_adopt_mul;}
}
}
}
e71
mul,value,cE2,c01
xG);}
else
cannot_adopt_mul:
#endif
{if(mul.iR1
value,cE2)==CollectionSetBase::xA2)c11}
}
}
xG1
ConstantFolding_MulGrouping(eR{bool
xG
i13
bool
should_regenerate
i13
e81
mul;e71
mul,tree,nB1
1)),c01
xG);typedef
std::pair<yK2,yG
nV1>e91;typedef
std::multimap<fphash_t,e91>cC1;cC1
i9;xH2
e81::xI1
j=mul.i8.nW3
j!=mul.i8.end();++j)nG1&value=j
cJ2.value
yJ&cE2=j
cJ2.xD2;if(j
cJ2.e2)cE2
x02;const
fphash_t
eA1=cE2.GetHash();typename
cC1::nX3
i=i9.xE2
eA1);for(;i!=i9.cP1
eA1;++i)if(i
cJ2.first
iA
cE2)){if(!cE2
y21||!cR1.xJ1,nY3
c11
i
cJ2
eE3
yL
value);goto
skip_b;}
i9.nT3,std::make_pair(eA1,std::make_pair(cE2,yG
nV1(size_t(1),value))));skip_b:;}
#ifdef FP_MUL_COMBINE_EXPONENTS
ConstantExponentCollection
x8
cS1;xH2
cC1::nX3
j,i=i9.nW3
i!=i9.end();i=j){j=i;++j;e91&list=i
cJ2;if
eD2
y21)c21
list.first.xJ1;if(!(cE2==eS1(0)))cS1.MoveToSet_Unique(cE2,list
eE3);i9.erase(i);}
}
if(cS1.Optimize())c11
#endif
if(should_regenerate)nG1
before=tree;before.iY
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"Before ConstantFolding_MulGrouping: "
;xE3(before)lN1"\n"
;
#endif
tree.DelParams();xH2
cC1::nX3
i=i9.nW3
i!=i9.end();++i){e91&list=i
cJ2;
#ifndef FP_MUL_COMBINE_EXPONENTS
if
eD2
y21)c21
list.first.xJ1;if(cE2==eS1(0))y81
if(cR1,nY3{tree.AddParamsMove(list
eE3);y81}
}
#endif
yK2
mul;mul
e53
mul
tI1
list
eE3);mul
x02;if(xG&&list.first
tF3
eD2.xJ1==eS1(1)/eS1(3))nG1
cbrt;cbrt
tU
cCbrt);cbrt
t02;cbrt.yB3
cbrt);y81
cR
0.5))nG1
sqrt;sqrt
tU
cSqrt);sqrt
t02;sqrt.yB3
sqrt);y81
cR-0.5))nG1
rsqrt;rsqrt
tU
cRSqrt);rsqrt
t02;rsqrt.yB3
rsqrt);y81
cR-1))nG1
inv;inv
tU
cInv);inv
t02;inv.yB3
inv);y81}
}
yK2
pow
yB2
t02;pow
yA
list.first);pow.yB3
pow);}
#ifdef FP_MUL_COMBINE_EXPONENTS
i9.clear()c23
0;a<i2
eW2
a)c21
i2[a
eC3;if(cR1,nY3{tree.AddParamsMove(i2[a
eD3);y81}
yK2
mul;mul
e53
mul
tI1
i2[a
eD3);mul
i72
pow
yB2
t02;pow
yT
cE2));pow.yB3
pow);}
#endif
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"After ConstantFolding_MulGrouping: "
eS
#endif
return!tree
iA
before);}
nX2
xG1
ConstantFolding_AddGrouping(eR{bool
should_regenerate
i13
e81
add
eV3
if
nW1
a)nE==cMul)y81
if(add.AddCollection
nW1
a))==CollectionSetBase::xA2)c11}
yG<bool>remaining(iT);size_t
tB=0
eV3
lM1&n83=xI2;if(n83
nE==cMul){eW3
xX1
c81{if(n83
lD
b)y21)y81
typename
e81::xI1
c=add.FindIdenticalValueTo(n83
lD
b));if(add.Found(c))nG1
tmp(n83
yO
CloneTag());tmp.iH1
b);tmp
x02;add.AddCollectionTo(tmp,c);c11
goto
done_a;}
}
remaining[a]=true;tB+=1;done_a:;}
}
if(tB>0){if(tB>1){yG<std::pair<yK2,size_t> >nV;std::multimap<fphash_t,size_t>eB1;bool
l13
i13
t12{eW3
xI2.c81{lM1&p=xI2
lD
b);const
fphash_t
p_hash=p.GetHash();for(std::multimap<fphash_t,size_t>::const_iterator
i=eB1.xE2
p_hash);i!=eB1.cP1
p_hash;++i){if(nV[i
cJ2
eC3
iA
p)){nV[i
cJ2
eD3+=1;l13=true;goto
found_mulgroup_item_dup;}
}
nV
yL
std::make_pair(p,size_t(1)));eB1.insert(std::make_pair(p_hash,nV
yA3-1));found_mulgroup_item_dup:;}
}
if(l13)nG1
cK2;{size_t
max=0;for(size_t
p=0;p<nV
eW2
p)if(nV[p
eD3<=1)nV[p
eD3=0;else{nV[p
eD3*=nV[p
eC3.xT2;if(nV[p
eD3>max){cK2=nV[p
eC3;max=nV[p
eD3;}
}
}
yK2
group_add;group_add
tU
cAdd);
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"Duplicate across some trees: "
;xE3(cK2)lN1" in "
eS
#endif
t12
eW3
xI2.c81
if(cK2
iA
xI2
lD
b)))nG1
tmp
nW1
a)yO
CloneTag());tmp.iH1
b);tmp
x02;group_add
yA
tmp);remaining[a]i13
nM3
group_add
i72
group;group
e53
group
yA
cK2);group
yA
group_add);group
x02;add.iR1
group);c11}
}
t12{if(add.AddCollection
nW1
a))==CollectionSetBase::xA2)c11}
}
if(should_regenerate){
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"Before ConstantFolding_AddGrouping: "
eS
#endif
tree.DelParams();xH2
e81::xI1
j=add.i8.nW3
j!=add.i8.end();++j)nG1&value=j
cJ2.value
yJ&coeff=j
cJ2.xD2;if(j
cJ2.e2)coeff
x02;if(coeff
tF3(fp_equal(coeff.xJ1,eS1(0)))y81
if(fp_equal(coeff.xJ1,nY3{tree
yA
value);y81}
}
yK2
mul;mul
e53
mul
yA
value);mul
yA
coeff);mul.Rehash(tT
t02;}
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"After ConstantFolding_AddGrouping: "
eS
#endif
return
true;}
nX2}
iO2{xQ
using
iO2
FPoptimizer_CodeTree;xG1
ConstantFolding_IfOperations(tT3(tree.tU3()==cIf
tI3()==i03);for(;;){l23
nE==cNot){tH
cIf
tT
lD
0).xO2
0)lD
0)tT
lD
1).swap
nW1
2));}
else
l23
cG1{tH
i03
tT
lD
0).xO2
0)lD
0)tT
lD
1).swap
nW1
2));}
else
t62
tX
0),cV2
i03))tF1
tree.xO2
1));nW
yO3
xP3
xO2
2));nW
lX1
l23
nE==cIf||e72
nE==i03)nG1
cond
cL2
0)yJ
l53;l53
xP2==cIf?cNotNot:cAbsNotNot);l53
x63
x03;ConstantFolding(l53)yJ
truth_b;truth_b
xP2==cIf?cNotNot:cAbsNotNot);truth_b
x63
x73
ConstantFolding(truth_b);if(l53
y21||truth_b
y21)nG1
eU;eU
xP2);eU
x63
x03;eU
yC
1));eU
yC
2));eU
i72
eV;eV
xP2);eV
x63
x73
eV
yC
1));eV
yC
2));eV
y3
cond
nE
xK1
0,cond
lD
0)tT.nC1
1,eU
tT.nC1
2,eV)nS2}
if
nW1
1)nE==tree
lD
2)nE&&nW1
1)nE==cIf||tree
lD
1)nE==i03))nG1&cM2
cL2
1)yJ&leaf2
cL2
2);if
x83
0).xO
0))&&x83
1).xO
1))||cM2
lD
2).xO
2))))nG1
eU;eU
xQ2
eU
yC
0));eU
eT
cM2
x03;eU
eT
leaf2
x03;eU
i72
eV;eV
xQ2
eV
yC
0));eV
eT
cM2
x73
eV
eT
leaf2
x73
eV
y3
cM2
nE
xK1
0
eF3
0)tT.nC1
1,eU
tT.nC1
2,eV)nS2
if
x83
1).xO
1))&&cM2
lD
2).xO
2)))nG1
eW;eW
xQ2
eW
yA
e72);eW
eT
cM2
xY3
eW
eT
leaf2
xY3
eW
y3
cM2
nE
tT.nC1
0,eW
xK1
2
eF3
2)xK1
1,cM2
x03
nS2
if
x83
1).xO
2))&&cM2
lD
2).xO
1)))nG1
cN2;cN2
tU
leaf2
nE==cIf?cNot:yR3);cN2
eT
leaf2
xY3
cN2
i72
eW;eW
xQ2
eW
yA
e72);eW
eT
cM2
xY3
eW
yA
cN2);eW
y3
cM2
nE
tT.nC1
0,eW
xK1
2
eF3
2)xK1
1,cM2
x03
nS2}
yK2&xW
cL2
1)yJ&y9
cL2
2);if(xW
iA
y9)){tree.xO2
1))nS2
const
OPCODE
op1=xW
nE;const
OPCODE
op2=y9
nE;if(op1==op2){if(xW.cT1
1)nG1
lO
0))xL2
0
y31)lY
if(xW.cT1
2&&y9.cT1
2){if(xW
lD
0)iA
y9
lD
0)))nG1
param0=xW
lD
0)yJ
lO
1))xL2
1
y31
tT
yA
param0)lY
if(xW
lD
1)iA
y9
x03)nG1
param1=xW
lD
1)yJ
lO
0))xL2
0
y31
tT
yA
n41
tT
yA
param1)nS2}
if(op1==x93
cMul
iU1
cAnd
iU1
cOr
iU1
cAbsAnd
iU1
cAbsOr
iU1
cMin
iU1
cMax){yG
nV1
l63;cC{for(iX2
y9.cN3
b-->0;){lW2
y9
lD
b))){if(l63
cQ3){xW.iY
y9.iY}
l63
yL
xW
lD
a));y9.iH1
b);xW.iH1
a
nW2}
}
if(!l63
cQ3){xW
x02;y9
i72
n41;n41
xQ2
n41
tI1
tree.iE1));n41
y3
op1
tT
tI1
l63)lY}
}
if(op1==x93
cMul||(op1==cAnd
nY1
y9))||(op1==cOr
nY1
y9))){cC
lW2
y9)){xW.iY
xW
cP3
xW
i72
cD1=y9;y9=tC
op1==x93
cOr)l9
op1
tT
yA
cD1)lY}
if((op1==cAnd
iU1
cOr)&&op2==cNotNot)nG1&l73=y9
lD
0);cC
lW2
l73)){xW.iY
xW
cP3
xW
i72
cD1=l73;y9=tC
op1
xA3
op1
tT
yA
cD1)lY}
if(op2==cAdd||op2==cMul||(op2==cAnd
nY1
xW))||(op2==cOr
nY1
xW))){for
xK2
y9.tD
y9
lD
a)iA
xW)){y9.iY
y9
cP3
y9
i72
cE1=xW;xW=tC
op2==cAdd||op2
xA3
op2
tT
yA
cE1)lY}
if((op2==cAnd||op2==cOr)&&op1==cNotNot)nG1&l83=xW
lD
0)c23
y9.tD
y9
lD
a)iA
l83)){y9.iY
y9
cP3
y9
i72
cE1=l83;xW=tC
op2
xA3
op2
tT
yA
cE1)lY}
nX2}
#include <limits>
iO2{xQ
using
iO2
FPoptimizer_CodeTree;yV1
int
maxFPExponent(){return
std::numeric_limits
x8::max_exponent;}
xG1
x71
eS1
xB3
cE2){if(base<eS1(0
iF1
i82
xB3(0))||fp_equal(xB3(1))yI
return
cE2>=eS1(maxFPExponent
x8())/fp_log2(base);}
xG1
ConstantFolding_PowOperations(tT3(tree.tU3()==cPow);y2){eS1
const_value=eG3
n6,y4
tT.ReplaceWithImmed(const_value)l81
false;}
if(nE1
fp_equal(y4,nY3{tree.xO2
0))nS2
lX&&fp_equal(n6,nY3
lL
1)l81
false;}
lX&&tree
lD
1)nE==cMul){bool
xR2
i13
eS1
iV1=n6
yJ
n83
cL2
1)c23
xX1
tD
n83
lD
a)xC3
imm=n83
lD
a).xJ1;{if(x71
iV1,imm
n33
iW1=eG3
iV1,imm)i82
iW1,eS1(0)))break;if(!xR2){xR2=true;xX1
iY}
iV1=iW1;xX1
iH1
a
nW2}
if(xR2){xX1
Rehash();
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"Before pow-mul change: "
eS
#endif
e72.Become(cU1
iV1)tT
lD
1).Become(n83);
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"After pow-mul change: "
eS
#endif
}
}
if(nE1
e72
nE==cMul){eS1
iX1=y4;eS1
xS2=1.0;bool
xR2=false
yJ&n83
cL2
0)c23
xX1
tD
n83
lD
a)xC3
imm=n83
lD
a).xJ1;{if(x71
imm,iX1
n33
eD1=eG3
imm,iX1)i82
eD1,eS1(0)))break;if(!xR2){xR2=true;xX1
iY}
xS2*=eD1;xX1
iH1
a
nW2}
if(xR2){xX1
Rehash()yJ
cD3;cD3
tU
cPow);cD3
tI1
tree.iE1));cD3.y12);tH
cMul
tT
yA
cD3
tT
eT
cU1
xS2))nS2}
l23
nE==cPow&&nE1
e72
lD
1)xC3
a
cL2
0)lD
1).xJ1;eS1
b=y4;eS1
c=a*b;if(isEvenInteger(a)&&!isEvenInteger(c))nG1
l93;l93
tU
cAbs);l93
yC
0)xY3
l93.Rehash(tT.nC1
0,l93);}
else
tree.SetParam(0,e72
lD
0)xK1
1,cU1
c));}
nX2}
iO2{xQ
using
iO2
FPoptimizer_CodeTree;e92
l4{enum
cO2{MakeFalse=0,MakeTrue=1,t22=2,lC3=3,MakeNotNotP0=4,MakeNotNotP1=5,MakeNotP0=6,MakeNotP1=7,Unchanged=8
n23
iY1{Never=0,Eq0=1,Eq1=2,xD3=3,xR3=4}
;cO2
if_identical;cO2
iZ1
4];e92{cO2
what:4;iY1
when:4;}
tS1,tT1,tU1,tV1;yV1
cO2
Analyze(lM1&a,lM1&b)const{if(a
iA
b)nZ2
if_identical;range
x8
p0=iM
a);range
x8
p1=iM
b);if(p0
i0&&p1.iV2){if(p0.max<p1.min&&iZ1
0]cJ
0];if(p0.max<=p1.min&&iZ1
1]cJ
1];}
if(p0
y41
p1
i0){if(p0.min>p1.max&&iZ1
2]cJ
2];if(p0.min>=p1.max&&iZ1
3]cJ
3];}
if(IsLogicalValue(a)){if(tS1
i92
tS1.when,p1)nZ2
tS1.what;if(tU1
i92
tU1.when,p1)nZ2
tU1.what;}
if(IsLogicalValue(b)){if(tT1
i92
tT1.when,p0)nZ2
tT1.what;if(tV1
i92
tV1.when,p0)nZ2
tV1.what;}
return
Unchanged
eI2
bool
TestCase(iY1
when,const
range
x8&p){if(!p.iV2||!p
i0
yI
switch(when
iY2
Eq0:return
p.min==0.0
xQ3==p.min;case
Eq1:return
p.min==1.0
xQ3==p.max;case
xD3:return
p.min>0
xQ3<=1;case
xR3:return
p.min>=0
xQ3<1;default:;}
nX2}
;iO2
RangeComparisonsData{static
const
l4
Data[6]={{l4
lA3
tP
Unchanged,l4::tP
Unchanged
tE
Eq1
tF
Eq1
nD1
Eq0}
,l91
Eq0}
}
,{l4::lX2
lB3
Unchanged,l4
lB3
Unchanged
tE
Eq0
tF
Eq0
nD1
Eq1}
,l91
Eq1}
}
,{l4::lX2
lB3
t22,l4::tP
MakeFalse
nD1
xD3
tF
xR3
xD,{l4
lA3
Unchanged,l4
lB3
tP
lC3
nD1
xR3
tF
xD3
xD,{l4::lX2::tP
tP
MakeTrue,l4::t22
tE
xR3}
,l91
xD3
xD,{l4
lA3
tP
lC3,l4::Unchanged,l4
nH1
tE
xD3}
,l91
xR3
xD}
;}
xG1
ConstantFolding_Comparison(eR{using
iO2
RangeComparisonsData;assert(tree.tU3()>=cEqual&&tree.tU3()<=cGreaterOrEq);switch(Data[tree
nE-cEqual].Analyze
nW1
0),tree
x03
iY2
l4::MakeFalse
xP3
ReplaceWithImmed(0);nW
l4
nH1
xP3
ReplaceWithImmed(1
l33
lC3:tH
cEqual
l33
t22:tH
t71
l33
MakeNotNotP0:tH
cNotNot
tW1
1
l33
MakeNotNotP1:tH
cNotNot
tW1
0
l33
MakeNotP0:tH
cNot
tW1
1
l33
MakeNotP1:tH
cNot
tW1
0
l33
Unchanged:;}
if
nW1
1)y21)switch
nW1
0)nE
iY2
cAsin
xP3
lR
fp_sin(iA2
cAcos
xP3
lR
fp_cos(y4)));tH
cV2
cLess?cGreater:cV2
cLessOrEq?cGreaterOrEq:cV2
cGreater?cLess:cV2
cGreaterOrEq?cLessOrEq:tree
nE);nW
cAtan
xP3
lR
fp_tan(iA2
cLog
xP3
lR
fp_exp(iA2
cSinh
xP3
lR
fp_asinh(iA2
cTanh:if(fp_less(fp_abs(y4),nY3{tree.lR
fp_atanh(y4)))nS2
break;default:nM3
nX2}
#include <list>
#include <algorithm>
#ifdef FP_SUPPORT_OPTIMIZER
xQ
iO2{
#ifdef DEBUG_SUBSTITUTIONS
yW
double
d){union{double
d;uint_least64_t
h;}
t32
d=d;lH1
h
nZ1
#ifdef FP_SUPPORT_FLOAT_TYPE
yW
float
f){union{float
f;uint_least32_t
h;}
t32
f=f;lH1
h
nZ1
#endif
#ifdef FP_SUPPORT_LONG_DOUBLE_TYPE
yW
long
double
ld){union{long
double
ld;e92{uint_least64_t
a;i02
short
b;}
s;}
t32
ld=ld;lH1
s.b<<data.s.a
nZ1
#endif
#ifdef FP_SUPPORT_LONG_INT_TYPE
yW
long
ld){o<<"("
<<std::hex<<ld
nZ1
#endif
#endif
}
iO2
FPoptimizer_CodeTree{lM
nF)){}
lM
e62
i
yO
nC3
nF
i)){data
xB
#ifdef __GXX_EXPERIMENTAL_CXX0X__
lM
eS1&&i
yO
nC3
nF
t72
i))){data
xB
#endif
lM
i02
v
yO
VarTag
nF
iE2,v))eS2
nR2
o
yO
OpcodeTag
nF
o))eS2
nR2
o,i02
f
yO
FuncOpcodeTag
nF
o,f))eS2
lM1&b
yO
CloneTag
nF*b.data)){}
yV1
yK2::~yL2(){}
lA
ReplaceWithImmed
i01
eS1&i){
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"Replacing "
;xE3(*this);if(IsImmed())OutFloatHex(std::cout,xJ1)lN1" with const value "
<<i;OutFloatHex(std::cout,i)lN1"\n"
;
#endif
data=new
nO2
x8(i);}
yT1
ParamComparer{i12()(lM1&a,lM1&b)const{if(a.xT2!=b.xT2
nZ2
a.xT2<b.xT2
l81
a.GetHash()<b.GetHash();}
}
;xB1
nO2
x8::Sort(){switch(Opcode
iY2
cAdd:case
cMul:case
cMin:case
cMax:case
cAnd:case
cAbsAnd:case
cOr:case
cAbsOr:case
cHypot:case
cEqual:case
t71:std::sort(iC2
i62
iC2
end(),ParamComparer
x8());lC
cLess
lU
cGreater;}
lC
cLessOrEq
lU
cGreaterOrEq;}
lC
cGreater
lU
cLess;}
lC
cGreaterOrEq
lU
cLessOrEq;}
break;default:nM3}
lA
AddParam(lM1&param){xY
yL
param);}
lA
eG
yK2&param){xY
yL
yK2());xY.back().swap(param);}
lA
SetParam(size_t
which,lM1&b)nI1
which
iB2
xY[which]=b;}
lA
nC1
size_t
which,yK2&b)nI1
which
iB2
xY[which
t23
b);}
lA
AddParams
i01
nK){xY.insert(xY.end(),l02.i62
l02.end());}
lA
AddParamsMove(nK){size_t
endpos=xY
yA3,added=l02
yA3;xY
nE3
endpos+added,yK2());for(size_t
p=0;p<added;++p)xY[endpos+p
t23
l02[p]);}
lA
AddParamsMove(nK,size_t
l12)nI1
l12
iB2
iH1
l12);AddParamsMove(eU1}
lA
SetParams
i01
nK){yG
nV1
tmp(eU1
xY.swap(tmp);}
lA
SetParamsMove(nK){xY.swap(eU1
l02.clear();}
#ifdef __GXX_EXPERIMENTAL_CXX0X__
lA
SetParams(yG
nV1&&l02){SetParamsMove(eU1}
#endif
lA
iH1
size_t
index){yG
nV1&c93=xY;
#ifdef __GXX_EXPERIMENTAL_CXX0X__
iC2
erase(iC2
begin()+index);
#else
c93[index].data=0;for(size_t
p=index;p+1<c93
eW2
p)c93[p].data.UnsafeSetP(&*c93[p+1
iB2
c93[nF3-1].data.UnsafeSetP(0);iC2
resize(nF3-1);
#endif
}
lA
DelParams(){xY.clear();}
xG1
yK2::IsIdenticalTo(lM1&b)const{if(&*data==&*b.data
nZ2
true
l81
data->IsIdenticalTo(*b.data);}
xG1
nO2
x8::IsIdenticalTo
i01
nO2
x8&b)const{if(Hash!=b.Hash
yI
if(Opcode!=t43
yI
switch(Opcode
iY2
cImmed:return
fp_equal(Value,t53;case
iE2:return
iJ1==b.iI1
case
cFCall:case
cPCall:if(iJ1!=b.iJ1
yI
break;default:nM3
if(nF3!=b.nF3
yI
for
xK2
0;a<c93
eW2
a){if(!c93[a]iA
b.c93[a])yI}
return
true;}
lA
Become(lM1&b){if(&b!=this&&&*data!=&*b.data){DataP
tmp=b.data;iY
data.swap(tmp);}
}
lA
CopyOnWrite(){if(GetRefCount()>1)data=new
nO2
x8(*data);}
yV1
yK2
yK2::GetUniqueRef(){if(GetRefCount()>1
nZ2
yK2(*this,CloneTag())l81*this;}
tQ):c7
cNop
l43),nC
tQ
const
nO2&b):c7
t43
l43
t53,iJ1(b.iJ1),c93(b.c93),Hash(b.Hash),Depth(b.Depth),eZ1
b.iK1){}
tQ
e62
i):c7
cImmed
l43
i),nC
#ifdef __GXX_EXPERIMENTAL_CXX0X__
tQ
nO2
x8&&b):c7
t43
l43
t72
t53),iJ1(b.iJ1),c93(t72
b.c93)),Hash(b.Hash),Depth(b.Depth),eZ1
b.iK1){}
tQ
eS1&&i):c7
cImmed
l43
t72
i)),nC
#endif
tQ
nR2
o):c7
o
l43),nC
tQ
nR2
o,i02
f):c7
o
l43),iJ1(f),c93(),Hash(),Depth(1),eZ1
0){}
}
#endif
#ifdef FP_SUPPORT_OPTIMIZER
#include <sstream>
#include <string>
#include <map>
#include <set>
#include <iostream>
xQ
#ifdef FUNCTIONPARSER_SUPPORT_DEBUGGING
iO2{xB1
l22
cA3,eH3&done,std::ostream&o){for
yS
l22
i43
done,o);std::ostringstream
buf;xE3(tree,buf);done[tree.GetHash()].insert(buf.str());}
}
#endif
iO2
FPoptimizer_CodeTree{
#ifdef FUNCTIONPARSER_SUPPORT_DEBUGGING
xB1
DumpHashes
i01
eY){eH3
done;l22(tree,done,o);for(eH3::const_iterator
i=done.nW3
i!=done.end();++i){const
std::set<std::string>&flist=i
cJ2;if(flist
yA3!=1)o<<"ERROR - HASH COLLISION?\n"
;for(std::set<std::string>::const_iterator
j=flist.nW3
j!=flist.end();++j){o<<'['<<std::hex<<i->first.hash1<<','<<i->first.hash2<<']'<<std::dec;o<<": "
<<*j<<"\n"
;}
}
}
xB1
xE3
i01
eY){const
char*tN3;switch
xU2
iY2
cImmed:o<<yZ3
l81;case
iE2:o<<"Var"
<<(tree.GetVar()-iE2)l81;case
cAdd:tN3"+"
;lC
cMul:tN3"*"
;lC
cAnd:tN3"&"
;lC
cOr:tN3"|"
;lC
cPow:tN3"^"
;break;default:tN3;o<<FP_GetOpcodeName
xU2);if
xU2==cFCall||cV2
cPCall)o<<':'<<tree.GetFuncNo();}
o<<'(';if(iT<=1&&sep2[1])o<<(sep2+1)<<' 'eV3
if(a>0)o<<' ';xE3
i43
o);if(a+1<iT)o<<sep2;}
o<<')';}
xB1
DumpTreeWithIndent
i01
eY,const
std::string&indent){o<<'['<<std::hex<<(void*)(&tree.iE1))<<std::dec<<','<<tree.GetRefCount()<<']';o<<indent<<'_';switch
xU2
iY2
cImmed:o<<"cImmed "
<<yZ3;o<<'\n'l81;case
iE2:o<<"VarBegin "
<<(tree.GetVar()-iE2);o<<'\n'l81;default:o<<FP_GetOpcodeName
xU2);if
xU2==cFCall||cV2
cPCall)o<<':'<<tree.GetFuncNo();o<<'\n';}
for
yS{std::string
ind=indent;for(size_t
p=0;p<ind
yA3;p+=2)if(ind[p]=='\\')ind[p]=' ';ind+=(a+1<iT)?" |"
:" \\"
;DumpTreeWithIndent
i43
o,ind);}
o<<std::flush;}
#endif
}
#endif
using
iO2
l41;xQ
#include <cctype>
iO2
l41{xG1
ParamSpec_Compare
i01
void*aa,const
void*bb,lU2
type){switch(type
iY2
lY2
xH&a=*(xH*)aa;xH&b=*(xH*)bb
l81
a
t42==b
t42&&a.index==b.index&&a.depcode==b.depcode
cM3
NumConstant:{eZ&a=*(eZ*)aa;eZ&b=*(eZ*)bb
l81
fp_equal(a.xZ3,b.xZ3)&&a.modulo==b.modulo
iD2
xI&a=*(xI*)aa;xI&b=*(xI*)bb
l81
a
t42==b
t42&&a.cS==b.cS&&a.data.match_type==b.data.match_type&&a.data
xY2==b.data
xY2&&a.data.param_list==b.data.param_list&&a.data.n2==b.data.n2&&a.depcode==b.depcode;}
}
return
true;}
i02
ParamSpec_GetDepCode
i01
cG2&b){switch(b.first
iY2
lY2
yK3*s=i01
xH*)b
eE3
l81
s->depcode
iD2
const
xI*s=i01
xI*)b
eE3
l81
s->depcode;}
default:nM3
return
0;}
xB1
DumpParam
i01
cG2&xZ2
std::ostream&o){static
const
char
ParamHolderNames[][2]={"%"
,"&"
,"x"
,"y"
,"z"
,"a"
,"b"
,"c"
}
;i02
t52
0;xT3
NumConstant:{const
eZ&t82
eZ*x01;o.precision(12);o<<xF3
xZ3;nM3
case
lY2
yK3&t82
xH*x01;o<<ParamHolderNames[xF3
index];t52
param
t42;break
iD2
const
xI&t82
xI*x01;t52
param
t42;yZ
GroupFunction){if
iZ2
cS==cNeg){o<<"-"
;n3}
tP1
xF3
cS==cInv){o<<"/"
;n3}
else{std::string
opcode=FP_GetOpcodeName((nR2)xF3
cS).substr(1)c23
0;a<opcode
eW2
a)opcode[a]=(char)std::toupper(opcode[a]);o<<opcode<<"( "
;n3
o<<" )"
;}
}
else{o<<'('<<FP_GetOpcodeName((nR2)xF3
cS)<<' ';yZ
PositionalParams)o<<'[';yZ
SelectedParams)o<<'{';n3
if
iZ2
data.n2!=0)o<<" <"
<<xF3
data.n2<<'>';yZ
PositionalParams)o<<"]"
;yZ
SelectedParams)o<<"}"
;o<<')';}
nM3
yN3(ImmedConstraint_Value(tX1
ValueMask)iY2
ValueMask:lC
Value_AnyNum:lC
n12:o<<"@E"
;lC
Value_OddInt:o<<"@O"
;lC
t01:o<<"@I"
;lC
Value_NonInteger:o<<"@F"
;lC
eE1:o<<"@L"
;t62
ImmedConstraint_Sign(tX1
SignMask)iY2
SignMask:lC
Sign_AnySign:lC
nJ1:o<<"@P"
;lC
n02:o<<"@N"
;t62
ImmedConstraint_Oneness(tX1
OnenessMask)iY2
OnenessMask:lC
Oneness_Any:lC
Oneness_One:o<<"@1"
;lC
Oneness_NotOne:o<<"@M"
;t62
ImmedConstraint_Constness(tX1
ConstnessMask)iY2
ConstnessMask:lC
yL1:if(lF3.first==ParamHolder){yK3&t82
xH*x01;if
iZ2
index<2)nM3
o<<"@C"
;lC
Constness_NotConst:o<<"@V"
;lC
Oneness_Any:nM3}
xB1
DumpParams
iL1
paramlist,i02
count,std::ostream&o){for
iL1
a=0;a<count;++a){if(a>0)o<<' ';const
cG2&param=e01
x8(paramlist,a);DumpParam
x8(param,o);i02
depcode=ParamSpec_GetDepCode(param);if(depcode!=0)o<<"@D"
<<depcode;}
}
}
#include <algorithm>
using
iO2
l41;xQ
iO2{yK3
plist_p[36]={{2,0,0x0}
tS
0,0x4}
tS
nJ1,0x0}
tS
n02|Constness_NotConst,0x0}
tS
Sign_NoIdea,0x0}
tS
eE1,0x0}
,{3,Sign_NoIdea,0x0}
,{3,0,0x0}
,{3,eE1,0x0}
,{3,0,0x8}
,{3,Value_OddInt,0x0}
,{3,Value_NonInteger,0x0}
,{3,n12,0x0}
,{3,nJ1,0x0}
,{0,n02|n0{0,n0{0,nJ1|n0{0,n12|n0{0,yL1,0x1}
,{0,t01|nJ1|n0{0,t11
yL1,0x1}
,{0,t11
n0{0,Oneness_One|n0{0,eE1|n0{1,n0{1,n12|n0{1,t11
n0{1,t01|n0{1,nJ1|n0{6,0,0x0}
,{4,0,0x0}
,{4,t01,0x0}
,{4,n0{4,0,0x16}
,{5,0,0x0}
,{5,n0}
;yT1
plist_n_container{static
const
eZ
plist_n[19];}
;yV1
const
eZ
plist_n_container
x8::plist_n[19]={{eS1(-2
iZ-1
iZ-0.5
iZ
0
tB2
fp_const_deg_to_rad
cE3
fp_const_einv
cE3
fp_const_log10inv
x8(iZ
0.5
tB2
fp_const_log2
x8(iZ
1
tB2
fp_const_log2inv
x8(iZ
2
tB2
fp_const_log10
cE3
fp_const_e
cE3
fp_const_rad_to_deg
cE3-fp_const_pihalf
x8(),xL1{eS1(0),xL1{fp_const_pihalf
x8(),xL1{fp_const_pi
x8(),xL1}
;const
xI
plist_s[464]={{{1,15,tC2
15,cNeg,GroupFunction,0}
,yL1,0x1}
,{{1,422,tC2
423,tC2
15,tD2
24,tD2
410,tD2
411,cInv,xZ
2,301330,cAdd,tG2
271397
lU1
0x5
tY3
271397,l5
45
lU1
iR
2,58413,l5
140333,l5
194605
lU1
0x1
tY3
224301,l5
270373,l5
270381,l5
271405,l5
271405
lU1
0x5
tY3
140341,l5
223285,l5
286757,l5
286765,l5
322605,l5
232501,l5
7168,l5
30727,l5
141312,l5
179207,l5
58383,l5
59407,l5
285718
lU1
iR
2,59416,l5
29726,l5
34823,l5
18597,l5
46264,l5
15764,l5
57509,l5
293049,l5
292026,l5
161979,l5
161980,l5
172265,l5
173308,l5
243951,l5
247024,l5
38152,l5
46344,l5
293147,l5
1332,l5
24980,l5
183473,l5
183570,l5
418001,l5
420248,cAdd,lP
0,0,tR
0,0,cAdd,i3
1,43,tR
1,51,tR
1,52,tR
1,53,tR
1,54,tR
1,0,lZ
iR
1,0,t51
2}
,0,iR
1,0,tR
1,21,tR
1,15,tR
1,26,tR
1,24,cAdd,i3
2,56344,cAdd,i3
1,219,tR
1,230,cAdd,i3
1,245,lZ
0x16}
,{{1,329,lZ
0x16}
,{{1,399,lZ
iR
1,401,lZ
iR
0,0,t51
1}
,nJ1,0x0
tY3
46095,tE2
24591,tE2
32783,tE2
37,c1
7205,c1
114725,c1
288805,lJ
0x6
tY3
347173,lJ
0x6
tY3
331813,c1
350245,c1
372773,c1
377893,c1
378917,c1
383013,c1
388133,c1
439333,c1
442405,c1
447525,c1
450597,c1
459813,c1
468005,c1
305201,l2
3,61910016,c1
7168,c1
114688,c1
512000,l2
3,45508608,c1
15,c1
30727,c1
71695,c1
130063,c1
286735,lJ
0x1
tY3
29726,c1
34823,c1
115736,c1
114712,c1
299008,c1
288783
xM2
300032,c1
347151
xM2
357376,l2
3,65425438,c1
420864,c1
280611,c1
358407,c1
301088,c1
55,c1
38143,c1
38143,lJ
iR
2,38145,lJ
iR
2,38152,c1
38171,c1
15631,c1
15711,c1
56671,c1
38262,lJ
iR
2,60820,c1
38325,lJ
iR
3,15777143,c1
37303,c1
48505,l2
3,15777207,c1
347191
xM2
48571,c1
103714,c1
104739,c1
266538,c1
307547,c1
304475,c1
353627,c1
48490,c1
310338,c1
376173,lJ
lP2
3,39173485,lJ
lP2
2,436589,lJ
lP2
2,7578,c1
376232,lJ
lP2
2,436648,lJ
lP2
3,39233901,lJ
lP2
3,39233960,lJ
lP2
2,7651,c1
7675,l2
0,0,nO
0,0,cT
1,37,nO
1,37,cT
1,2,n22
2,n32
3,n22
3,n32
0,nO
1,0,n32
0,cT
1,14,nO
1,16,nO
1,16,lK
1
xN2
21,nO
1,15,nO
1,24,cT
2,24591,nO
1,55,nO
1,55,lK
2
xN2
275,n22
278,n32
284,cT
1,287,nO
1,288,nO
1,289,cT
1,462,cT
2,413757,lK
1
xN2
295,nO
1,329,cT
2,414025,lK
1}
,0,0x16}
,{{1,351,nO
1,404,nO
1,410,nO
2,60459,l32
44047,l32
24591,l32
32783,l32
44056,l32
41,lI,41,y0
49,lI,49,y0
365609,lI,222257,lI,365617,lI,366633,lI,366641,lI,48128,lI,15,lI,15,cV1
16,lI,10240,lI,11264,lI,7170,lI,7168,lI,7168,y0
7183,cV1
17408,lI,19456,lI,16384,lI,15360,lI,27648,lI,30720,lI,30722,lI,24,tF2
0x6
tY3
24,lI,7192,lI,68608,lI,83968,lI,86040,lI,87040,lI,88064,lI,90112,lI,432128,lI,433152,lI,37895,lI,14342,lI,25607,lI,7183,lI,56327,lI,114703,lI,114718,lI,257024,lI,419840,lI,260103,lI,37953,tF2
0x5
tY3
37956,y0
37961,tF2
0x5
tY3
38105,lI,38114,y0
38984,y0
44103,y0
44104,y0
38991,lI,44111,lI,44135,lI,44124,y0
44136,lI,48240,lI,60693,lI,38253,y0
38253,lI,38259,tF2
0x5
tY3
38260,cV1
38262,y0
38262,lI,48493,y0
48493,lI,15734,y0
137590,lI,38264,tF2
0x5
tY3
38292,lI,38294,lI,38300,lI,38301,lI,38312,y0
38325,y0
38332,y0
38332,lI,38341,lI,38341,y0
38343,lI,60,lI,60,tF2
0x6
tY3
48552,y0
48552,lI,257198,lI,260274,lI,24792,lI,7172,cPow,PositionalParams,0}
,nJ1,0x0
tY3
24591,cPow,xZ
2,60440,cPow,xZ
2,60451,cPow,xZ
2,61472,cPow,xZ
1,0,eI3
7,eI3
157,eI3
0,cAcos
eJ3
cAcosh
eJ3
cAsin
eJ3
cAsinh
nR
112,cAsinh
eJ3
cAtan,eF1
cAtan2,tG2
303104
i23
eJ3
cAtanh
eJ3
cCeil,cF3
216,cCeil
eJ3
yO2
0,cCos,cF3
7,yO2
81,yO2
83,yO2
112,yO2
180,yO2
234,yO2
0,cH3
cF3
0,cI3
176,cI3
180,cI3
409,cI3
0,cFloor,cF3
216,cFloor,tG2
308523,eK3
tG2
352555,eK3
tG2
352599,eK3
l0
3,31464448,cU
507534336,cU
508566528,cU
33579008,cU
30443520,lD3
31464448,lD3
7836672,cU
24612864,cU
93415424,cU
142744576,cU
174234624,cU
265547776,cU
435585024,cU
439783424,cU
519553024,cU
526900224,cU
58739160,cU
58739160,lD3
58739166,cU
58739166,cIf,cF3
112,cInt
eJ3
tH2
7,tH2
30,tH2
157,tH2
216,tH2
282,tH2
15,cLog,xZ
1,24,cLog,xZ
1,0,cLog10
eJ3
cLog2,eF1
cMax,tG2
29726,cMax,tG2
34823,cMax
eJ3
cMax,AnyParams,1}
,0,iR
xG3
cMin,tG2
29726,cMin,tG2
34823,cMin
eJ3
cMin,AnyParams,1}
,0,iR
2,46095,cMin,xZ
2,24591,cMin,xZ
1,0,n42
0,cSin,cF3
7,n42
81,n42
83,n42
112,n42
139,n42
161,cSin,nU
0x5}
,{{1,216,n42
227,n42
231,cSin,nU
0x1}
,{{1,234,n42
0,cSinh,cF3
0,cSinh
nR
161,cSinh,nU
0x5}
,{{1,176,cSinh
nR
216,cSinh
nR
227,cSinh
nR
234,cSinh
nR
409,cSinh
eJ3
yP2
0,cTan,cF3
75,cTan,cF3
76,yP2
161,yP2
216,yP2
231,yP2
227,yP2
234,yP2
0,xV2
0,cTanh,cF3
160,xV2
161,xV2
216,xV2
227,xV2
234,xV2
0,cTrunc,tG2
15384,cSub,xZ
2,15384,cDiv,xZ
2,420251,cDiv,xZ
xG3
tK2
nU
t41
tK2
tG2
30720,tK2
nU
0x20
tY3
30727,tK2
nU
0x24
tY3
30727,tK2
tG2
114743,tK2
tG2
114743,t71,tG2
39936,cLess,l6
2,39936,cLess,tG2
7,cLess,eF1
cLess,nU
t41
cLessOrEq,tG2
256216,cLessOrEq,tG2
39936,e82
l6
2,39936,e82
tG2
7,e82
eF1
e82
nU
t41
cGreaterOrEq,tG2
256216,cGreaterOrEq
eJ3
l42
7,l42
15,l42
30,l42
156,l42
494,l42
497,l42
498,l42
501,l42
504,l42
505,cNot,eF1
l52
29726,l52
34823,l52
394270,l52
398366,l52
7651,cAnd,lP
0,0,cAnd,AnyParams,1}
,0,0x0}
,{{xG3
nJ2
29726,nJ2
34823,nJ2
394270,nJ2
398366,nJ2
7651,cOr,lP
1,0
t31
81
t31
121
t31
156
t31
159
t31
216,cDeg
nR
216,cRad,eF1
cAbsAnd,lP
xG3
cAbsOr,lP
1,0,yR3
eJ3
cAbsNotNot,l0
3,31464448,eP3
nU
0x0}
,}
;}
iO2
l41{const
Rule
grammar_rules[253]={{ProduceNewTree,1,1,0,{1,0,cAbs,xJ
361,{1,172,cAtan,xJ
354
tS
1337
i23,xJ
356
tS
320513
i23
l7
2,2,222424
tS
226524
i23
l7
2,2,224474
tS
228574
i23,xJ
148
x13
cCeil,xJ
435,{1,80,tL2
429,{1,115,tL2
430,{1,117,tL2
146,{1,118,tL2
370,{1,116,tL2
0,{1,354,cCos
l7
2,1,0,{1,351,cCos
l7
2,1,216
x13
tL2
314,{1,357,cCosh
l7
2,1,0,{1,351,cCosh
l7
2,1,216
x13
cH3
xJ
144
x13
cFloor,xJ
403,{1,114,cFloor,eL3
214,{3,7379968,c8
518,{3,31464450,c8
499,{3,8428544,c8
501,{3,8434688,c8
215,{3,40901632,c8
494,{3,40902656,c8
507,{3,40940544,c8
506,{3,47194112,c8
483,{3,47225856,c8
414,{3,1058266,c8
418,{3,1058272,c8
418,{3,9438682,c8
414,{3,9438688,c8
460,{3,396733911,c8
460,{3,381020637,cIf
l7
0,3,31492569,{3,35682779,cIf
l7
0,3,31492575,{3,35682785,cIf,xJ
111,{1,228,eM3
110,{1,244,eM3
355,{1,106,eM3
204,{1,205,cLog
l7
0,1,395
cP2,cMax
yF
0
tS
431105,cMax
yF
396
cP2,cMin
yF
0
tS
427009,cMin,AnyParams,0}
}
,{ProduceNewTree,0,1,203
tS
24804,cPow,eL3
203
tS
25827,cPow,eL3
202
tS
126991,cPow
xM1
30988,cPow
xM1
30989,cPow
xM1
30990,cPow
t93
166239
tS
31066,cPow
xM1
32015,cPow
t93
7168
tS
12639,cPow
t93
7392
tS
12535
x23
380
tS
44095
x23
381
tS
44141
x23
382
tS
44140
x23
201
tS
109583
x23
200
tS
132129
x23
155
tS
133153
n52
419840
tS
413711
n52
254976
tS
253967
n52
221184
tS
251937
n52
221184
tS
248850
x23
150
x13
yQ2
372,{1,80,yQ2
146,{1,115,yQ2
370,{1,117,yQ2
149,{1,118,yQ2
429,{1,116,yQ2
0,{1,356,yQ2
152
x13
cSinh,xJ
312,{1,355,cSinh,xJ
153
x13
eN3
0,{1,359,eN3
170,{1,360,eN3
154
x13
cTanh
l7
0,1,392
tS
395279,tM2
391
cP2,tM2
199
tS
242924,tM2
198
tS
230636,tM2
164
tS
240869,tM2
163
tS
240660,t51
0
nM1
263,{1,311,t51
1
nM1
262,{1,310,t51
1
l1
2,1,261
tS
1333
lW1
259
tS
1331
lW1
407
tS
415124
lW1
45
tS
331093
lW1
324
tS
146477
lW1
342
tS
145453
lW1
427
tS
213202
lW1
428
tS
217298
lW1
368
tS
216270
lW1
145
tS
216271
lW1
369
tS
218318
lW1
197
tS
144665
lW1
194
tS
348441
lW1
193
tS
348300
lW1
195
tS
200875
lW1
192
tS
177323
lW1
257
tS
446837
lW1
181
tS
446653
lW1
151
tS
187765
lW1
147
tS
187828
lW1
255
tS
195957
lW1
374
tS
264383
lW1
437
tS
264381
lW1
437
tS
186741
lW1
374
tS
262580
lW1
151
tS
262333,tM2
98
tS
1155
eG1
97
tS
1156
eG1
305
tS
1330
eG1
99
tS
24704
eG1
100
tS
24698
eG1
394
tS
395279
eG1
393
cP2
eG1
353
tS
360799
eG1
96
tS
89360
eG1
105
tS
80155
eG1
95
tS
79131
cQ2
56671
tS
1424
cQ2
15711
tS
1426
cQ2
107535
tS
93467
cQ2
97295
tS
96539,l8
1,1,0,{1,351,l8
1,1,55,{1,14,lK
0
nM1
93
tS
70674,cMul,SelectedParams,0
nM1
512,{1,50,lK
1
nM1
513,{1,40,lK
1
l1
2,1,435
tS
443429,eA
442
tS
451621,eA
336
tS
382285,eA
437
tS
382406,eA
374
tS
446801,eA
365
tS
435534,eA
444
tS
325033,eA
318
tS
340413,eA
335
tS
375116,eA
424
tS
375229,eA
45
tS
456126,eA
450
tS
328114,eA
45
tS
460223,eA
452
tS
461861,eA
453
tS
329140,eA
322
tS
341446,eA
456
tS
335286,eA
448
tS
327087,eA
459
tS
469029,eA
455
tS
311360,eA
338
tS
309322,eA
412
tS
43412,eA
330
tS
49480,eA
413
tS
47508,eA
331
tS
45384,l8
2,2,334277
tS
333236
cQ2
39936
tS
xH3
cEqual
yP
cEqual
yQ
cEqual
yR
cEqual
lA1
24807
t61
iD
t61
l62
237799
t61
n11
cEqual
l72
tK2
eH1
39,tK2
eO3
0
tS
5165,cEqual
t93
39936
tS
xH3
t71
yP
t71
yQ
t71
yR
t71
lA1
24807
tI2
iD
tI2
l62
237799
tI2
n11
t71
l72
t71
tJ2
39,t71,eH1
5165,t71
yP
cLess
yQ
cLess
yR
cLess,xJ
516
tS
44032,cLess
lA1
24804
t21
yM1
t21
iD
t21
l62
237796
t21
xN1
t21
n11
cLess
l72
cLess
tJ2
xH3
cLess
yP
cLessOrEq
yQ
cLessOrEq
yR
cLessOrEq,xJ
510
tS
359439,cLessOrEq
lA1
24804
xC1
yM1
xC1
iD
xC1
l62
237796
xC1
xN1
xC1
n11
cLessOrEq
l72
cLessOrEq
tJ2
359469,cLessOrEq
yP
cGreater
yQ
cGreater
yR
e82
xJ
487
tS
359439,cGreater
lA1
24804
y61
yM1
y61
iD
y61
l62
237796
y61
xN1
y61
n11
cGreater
l72
e82
eH1
359469,cGreater
yP
cGreaterOrEq
yQ
cGreaterOrEq
yR
cGreaterOrEq,xJ
517
tS
44032
yX
473304
tS
24804
yX
yM1
yX
iD
yX
l62
237796
yX
xN1
yX
7168
tS
279818
yX
lB1
cGreaterOrEq,eH1
xH3
cGreaterOrEq,eL3
516,{1,2,cNot,eO3
469,{1,123,cNot,eL3
511,{1,5,cAnd,AnyParams,1
l1
0,1,514
tS
13314,cAnd
yF
397
cP2,cAnd
yF
491
tS
496099,cAnd
yF
492
tS
399846,cAnd
yF
493
tS
393702,cAnd,AnyParams,0
l1
0,2,479697,{3,489115088,cAnd
yF
515
tS
13314,xI3
508
tS
8197,xI3
398
cP2,xI3
488
tS
496099,xI3
489
tS
399846,xI3
490
tS
393702,xI3
509
tS
136197,cOr,AnyParams,0}
}
,{ProduceNewTree,0,1,517,{1,2,xJ3
l3
1,1,0,{1,0,xJ3
eO3
470,{1,123,xJ3
xJ
482,{1,228,cAbsNotNot,AnyParams,0
nM1
476,{1,227,cAbsNotNot,AnyParams,0}
}
,{ProduceNewTree,0,1,383,{3,31464955,eP3
eL3
517,{3,40940544,eP3
eL3
516,{3,47225856,i03
l7
0,3,31492569,{3,35682779,eP3
PositionalParams,0}
}
,}
;e92
grammar_optimize_abslogical_type{xS
9
eI
grammar_optimize_abslogical_type
grammar_optimize_abslogical={9,{21,183,219,228,231,237,244,249,252}
}
;}
e92
grammar_optimize_ignore_if_sideeffects_type{xS
59
eI
grammar_optimize_ignore_if_sideeffects_type
grammar_optimize_ignore_if_sideeffects={59,{0,20,22,23,24,25,26,27,cV
tY1
78,cZ
xR
grammar_optimize_nonshortcut_logical_evaluation_type{xS
56
eI
grammar_optimize_nonshortcut_logical_evaluation_type
grammar_optimize_nonshortcut_logical_evaluation={56,{0,26,cV
tY1
78,cZ
158,167,168,169,178,179,191,195,203,207,215,227,229,230,232,233,234,235,236,238,239,240,241,242,243,245,246,247,248,250,251}
}
;}
e92
grammar_optimize_round1_type{xS
118
eI
grammar_optimize_round1_type
grammar_optimize_round1={118,{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,18,26,cV
37,38,tY1
45,46,47,48,49,50,51,52,53,54,58,59,60,61,62,63,64,65,66,67,68,69,70,71,78,79,80,81,82,83,88,89,90,91,92,93,94,95,96,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,132,xR
grammar_optimize_round2_type{xS
100
eI
grammar_optimize_round2_type
grammar_optimize_round2={100,{0,15,16,17,26,cV
39,40,tY1
45,46,47,48,49,50,51,52,53,54,59,60,72,73,78,79,84,85,86,87,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,117,118,119,120,121,122,123,124,125,126,127,128,133,157,xR
grammar_optimize_round3_type{xS
79
eI
grammar_optimize_round3_type
grammar_optimize_round3={79,{74,75,76,77,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,159,160,161,162,163,164,165,166,170,171,172,173,174,175,176,177,180,181,182,184,185,186,187,188,189,190,192,193,194,196,197,198,199,200,201,202,204,205,206,208,209,210,211,212,213,214,216,217,218,220,221,222,223,224,225,226}
}
;}
e92
grammar_optimize_round4_type{xS
10
eI
grammar_optimize_round4_type
grammar_optimize_round4={10,{19,55,56,57,130,131,153,154,155,156}
}
;}
e92
grammar_optimize_shortcut_logical_evaluation_type{xS
53
eI
grammar_optimize_shortcut_logical_evaluation_type
grammar_optimize_shortcut_logical_evaluation={53,{0,26,cV
tY1
78,cZ
158,167,168,169,178,179,191,195,203,207,215,227,229,232,233,234,235,236,239,240,241,242,245,246,247,248,250,251}
}
;}
}
iO2
l41{yV1
cG2
e01
iL1
paramlist,lC1){index=(paramlist>>(index*10))&1023;if(index>=55
nZ2
cG2(SubFunction
tZ1
plist_s[index-55]);if(index>=36
nZ2
cG2(NumConstant
tZ1
plist_n_container
x8::plist_n[index-36])l81
cG2(ParamHolder
tZ1
plist_p[index]);}
}
#ifdef FP_SUPPORT_OPTIMIZER
#include <stdio.h>
#include <algorithm>
#include <map>
#include <sstream>
xQ
using
iO2
l41;using
iO2
FPoptimizer_CodeTree;using
iO2
FPoptimizer_Optimize;iO2{nT1
It,typename
T,typename
Comp>eI1
MyEqualRange(It
first,It
last,const
T&val,Comp
comp){size_t
len=last-first;while(len>0){size_t
nJ3
len/2;It
n43(first);n43+=half;if(comp(*n43,val)){first=n43;++first;len=len-half-1;}
tP1
comp(val,*n43)){len=half;}
else{It
left(first);{It&cR2=left;It
last2(n43);size_t
len2=last2-cR2;while(len2>0){size_t
half2=len2/2;It
middle2(cR2);middle2+=half2;if(comp(*middle2,val)){cR2=middle2;++cR2;len2=len2-half2-1;}
else
len2=half2;}
}
first+=len;It
right(++n43);{It&cR2=right;It&last2=first;size_t
len2=last2-cR2;while(len2>0){size_t
half2=len2/2;It
middle2(cR2);middle2+=half2;if(comp(val,*middle2))len2=half2;else{cR2=middle2;++cR2;len2=len2-half2-1;}
}
}
return
eI1(left,right);}
}
return
eI1(first,first);}
yT1
OpcodeRuleCompare{i12()(lM1&tree,i02
xW2)const{const
Rule&rule=grammar_rules[xW2]l81
tree
nE<rule
nT2.subfunc_opcode;}
i12()iL1
xW2,const
eR
const{const
Rule&rule=grammar_rules[xW2]l81
rule
nT2.subfunc_opcode<tree
nE;}
}
;xG1
TestRuleAndApplyIfMatch
eX3
yK2&tree,bool
cD{MatchInfo
x8
info;lZ1
found(false,e1());if((rule.eL1
LogicalContextOnly)&&!cD{yR2
if(nD
IsIntType
x8::result){if(rule.eL1
NotForIntegers)yR2
else{if(rule.eL1
OnlyForIntegers)yR2
for(;;){
#ifdef DEBUG_SUBSTITUTIONS
#endif
found=TestParams(rule
nT2,tree,found.specs,info,true);if(found.found)break;if(!&*found.specs){fail:;
#ifdef DEBUG_SUBSTITUTIONS
DumpMatch
t81,false);
#endif
nX2}
#ifdef DEBUG_SUBSTITUTIONS
DumpMatch
t81,true);
#endif
SynthesizeRule
t81)nS2}
iO2
FPoptimizer_Optimize{xG1
ApplyGrammar
i01
Grammar&tN2,yK2&tree,bool
cD{if(tree.GetOptimizedUsing()==&tN2){
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"Already optimized:  "
;xE3(tree)lN1"\n"
<<std::flush;
#endif
nX2
if(true){bool
changed
i13
switch
xU2
iY2
cNot:case
cNotNot:case
cAnd:case
cOr:for
xK2
0
nP
true))yI1
lC
cIf:case
i03:if(ApplyGrammar(tN2,e72,cV2
cIf))yI1
for
xK2
1
nP
cD)yI1
break;default:for
xK2
0
nP
false))yI1}
if(changed){tree.Mark_Incompletely_Hashed()nS2}
typedef
const
i02
char*lE3;std::pair<lE3,lE3>range=MyEqualRange(tN2.rule_list,tN2.rule_list+tN2.rule_count,tree,OpcodeRuleCompare
x8());if(range.eQ3
range
eE3){
#ifdef DEBUG_SUBSTITUTIONS
yG<i02
char>rules;rules.nH3
range
eE3-range.first);yD
if(IsLogisticallyPlausibleParamsMatch(cW1
nT2
n72
rules
yL*r);}
range.first=&rules[0];range
eE3=&rules[rules
yA3-1]+1;if(range.eQ3
range
eE3){std::cout<<"Input ("
<<FP_GetOpcodeName
xU2)<<")["
<<iT<<"]"
;if(cD
std::cout<<"(Logical)"
;i02
first=i21,prev=i21;const
char*sep=", rules "
;yD
if(first==i21)first=prev=*r;tP1*r==prev+1)prev=*r;else{std::cout<<sep<<first;sep=","
;if(prev!=first)std::cout<<'-'<<prev;first=prev=*r;}
}
if(eQ3
i21){std::cout<<sep<<first;if(prev!=first)std::cout<<'-'<<prev;}
std::cout<<": "
;xE3(tree)lN1"\n"
<<std::flush;}
#endif
bool
changed
i13
yD
#ifndef DEBUG_SUBSTITUTIONS
if(!IsLogisticallyPlausibleParamsMatch(cW1
nT2
n72
y81
#endif
if(TestRuleAndApplyIfMatch(cW1,tree,cD){yI1
nM3}
if(changed){
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"Changed."
<<std::endl
lN1"Output: "
;xE3(tree)lN1"\n"
<<std::flush;
#endif
tree.Mark_Incompletely_Hashed()nS2}
tree.SetOptimizedUsing(&tN2)l81
false;}
xB1
ApplyGrammars(x2){
#ifdef DEBUG_SUBSTITUTIONS
std
tJ3"grammar_optimize_round1\n"
;
#endif
n4
grammar_optimize_round1
n53
#ifdef DEBUG_SUBSTITUTIONS
std
tJ3"grammar_optimize_round2\n"
;
#endif
n4
grammar_optimize_round2
n53
#ifdef DEBUG_SUBSTITUTIONS
std
tJ3"grammar_optimize_round3\n"
;
#endif
n4
grammar_optimize_round3
n53
#ifndef FP_ENABLE_SHORTCUT_LOGICAL_EVALUATION
#ifdef DEBUG_SUBSTITUTIONS
std
tJ3"grammar_optimize_nonshortcut_logical_evaluation\n"
;
#endif
n4
grammar_optimize_nonshortcut_logical_evaluation
n53
#endif
#ifdef DEBUG_SUBSTITUTIONS
std
tJ3"grammar_optimize_round4\n"
;
#endif
n4
grammar_optimize_round4
n53
#ifdef FP_ENABLE_SHORTCUT_LOGICAL_EVALUATION
#ifdef DEBUG_SUBSTITUTIONS
std
tJ3"grammar_optimize_shortcut_logical_evaluation\n"
;
#endif
n4
grammar_optimize_shortcut_logical_evaluation
n53
#endif
#ifdef FP_ENABLE_IGNORE_IF_SIDEEFFECTS
#ifdef DEBUG_SUBSTITUTIONS
std
tJ3"grammar_optimize_ignore_if_sideeffects\n"
;
#endif
n4
grammar_optimize_ignore_if_sideeffects
n53
#endif
#ifdef DEBUG_SUBSTITUTIONS
std
tJ3"grammar_optimize_abslogical\n"
;
#endif
n4
grammar_optimize_abslogical
n53
#undef C
}
}
#endif
#ifdef FP_SUPPORT_OPTIMIZER
#include <algorithm>
#include <assert.h>
#include <cstring>
#include <cmath>
#include <memory> /* for auto_ptr */
xQ
using
iO2
l41;using
iO2
FPoptimizer_CodeTree;using
iO2
FPoptimizer_Optimize;iO2{xG1
TestImmedConstraints
iL1
bitmask,const
eR{switch(bitmask&ValueMask
iY2
Value_AnyNum:case
ValueMask:lC
n12:if(GetEvennessInfo
nO3
l82
Value_OddInt:if(GetEvennessInfo
nO3
n82
t01:if(GetIntegerInfo
nO3
l82
Value_NonInteger:if(GetIntegerInfo
nO3
n82
eE1:if(!IsLogicalValue(tree)yI
nK1
SignMask
iY2
Sign_AnySign:lC
nJ1:if(l01
l82
n02:if(l01
n82
Sign_NoIdea:if(l01
Unknown
yI
nK1
OnenessMask
iY2
Oneness_Any:case
OnenessMask:lC
Oneness_One:if(!cW2
if(!fp_equal(fp_abs(yZ3),eS1(1))yI
lC
Oneness_NotOne:if(!cW2
if(fp_equal(fp_abs(yZ3),eS1(1))yI
nK1
ConstnessMask
iY2
Constness_Any:lC
yL1:if(!cW2
lC
Constness_NotConst:if(cW2
nM3
return
true;}
n73<i02
extent,i02
nbits,typename
cS2=i02
int>e92
nbitmap{private:static
const
i02
bits_in_char=8;static
const
i02
cT2=(xK3
cS2)*bits_in_char)/nbits;cS2
data[(extent+cT2-1)/cT2];e13
void
inc(lC1,int
by=1){data[pos(index)]+=by*cS2(1<<xX2);i6
void
dec(lC1){inc(index,-1);}
int
get(lC1
n61(data[pos(index)]>>xX2)&mask()xJ2
pos(lC1){return
index/cT2
xJ2
shift(lC1){return
nbits*(index%cT2)xJ2
mask(){return(1<<nbits)-1
xJ2
mask(lC1){return
mask()<<xX2;}
}
;e92
c83{int
SubTrees:8;int
Others:8;int
i31:8;int
cG3:8;nbitmap<iE2,2>SubTreesDetail;c83(){std::memset(this,0,xK3*this));}
c83
i01
c83&b){std::memcpy(this,&b,xK3
b));}
c83&e31=i01
c83&b){std::memcpy(this,&b,xK3
b))l81*this;}
}
;yV1
c83
CreateNeedList_uncached(t0&cB2){c83
x11
xS3
a=0;a<cB2
xY2;++a){const
cG2&lF3=e01
x8(cB2.param_list,a);xT3
lZ2
const
xI&t82
xI*x01;yZ
GroupFunction)++tA3;else{++tA2;assert(param.data.subfunc_opcode<VarBegin);x11.SubTreesDetail.inc
iZ2
cS);}
++x11.i31;nM3
case
NumConstant:case
ParamHolder:++t92;++x11.i31;nM3}
return
x11;}
yV1
c83&CreateNeedList(t0&cB2){typedef
std::map<t0*,c83>cX1;static
cX1
yO1;cX1::nX3
i=yO1.xE2&cB2);if(i!=yO1.cP1&cB2
nZ2
i
cJ2
l81
yO1.nT3,std::make_pair(&cB2,CreateNeedList_uncached
x8(cB2)))cJ2;}
yV1
yK2
CalculateGroupFunction
i01
cG2&xZ2
const
t9
info){xT3
NumConstant:{const
eZ&t82
eZ*x01
l81
CodeTreeImmed
iZ2
xZ3)cM3
lY2
yK3&t82
xH*x01
l81
info.GetParamHolderValueIfFound
iZ2
index)iD2
const
xI&t82
xI*x01
yJ
result;result
tU
xF3
cS);tC1
iE1).reserve
iZ2
data
xY2)xS3
a=0;a<xF3
data
xY2;++a)nG1
tmp(CalculateGroupFunction(e01
x8
iZ2
data.param_list,a),info));result
yA
tmp);}
tC1
Rehash()l81
result;}
}
return
yK2();}
}
iO2
FPoptimizer_Optimize{xG1
IsLogisticallyPlausibleParamsMatch(t0&cB2,const
eR{c83
x11(CreateNeedList
x8(cB2));size_t
eR3=iT;if(eR3<size_t(x11.i31)){nX2
for
xK2
0;a<eR3;++a){i02
opcode=xI2
nE;switch(opcode
iY2
cImmed:if(tA3>0)--tA3;else--t92;lC
iE2:case
cFCall:case
cPCall:--t92;break;default:assert(opcode<VarBegin);if(tA2>0&&x11.SubTreesDetail.get(opcode)>0){--tA2;x11.SubTreesDetail.dec(opcode);}
else--t92;}
}
if(tA3>0||tA2>0||t92>0){nX2
if(cB2.match_type!=AnyParams){if(0||tA2<0||t92<0){nX2}
return
true;}
yV1
lZ1
TestParam
i01
cG2&xZ2
lM1&tree
eA2
start_at,t9
info){xT3
NumConstant:{const
eZ&t82
eZ*x01;if(!cW2
eS1
imm=yZ3;switch
iZ2
modulo
iY2
Modulo_None:lC
Modulo_Radians:imm=fp_mod(imm,y8
imm<0)imm
c5
if(imm>fp_const_pi
x8())imm-=fp_const_twopi
x8(nW2
return
fp_equal(imm,xF3
xZ3)cM3
lY2
yK3&t82
xH*x01;if(!x0
return
info.SaveOrTestParamHolder
iZ2
index,tree)iD2
const
xI&t82
xI*x01;yZ
GroupFunction){if(!x0
yK2
xO1=CalculateGroupFunction(xZ2
info);
#ifdef DEBUG_SUBSTITUTIONS
DumpHashes(xO1)lN1*i01
void**)&xO1.xJ1
lN1"\n"
lN1*i01
void**)&yZ3
lN1"\n"
;DumpHashes(tree)lN1"Comparing "
;xE3(xO1)lN1" and "
;xE3(tree)lN1": "
lN1(xO1
iA
tree)?"true"
:"false"
)lN1"\n"
;
#endif
return
xO1
iA
tree);}
else{if(!&*start_at){if(!x0
if
xU2!=xF3
cS
yI}
return
TestParams
iZ2
data,tree,start_at,info,false);}
}
}
nX2
yT1
iS
x22
MatchInfo
x8
info;iS()yC3,info(){}
}
;iP2
MatchPositionSpec_PositionalParams:xP1
iS
x8>{e13
iF2
MatchPositionSpec_PositionalParams(xL3):xM3
iS
x8>(n){}
}
;e92
i41
x22
i41()yC3{}
}
;class
c0:xP1
i41>{e13
i02
trypos;iF2
c0(xL3):xM3
i41>(n),trypos(0){}
}
;yV1
lZ1
TestParam_AnyWhere
i01
cG2&xZ2
lM1&tree
eA2
start_at,t9
info,yG<bool>&used,bool
tA1{xN<c0>x6;i02
lG3
c0
n92
a=x6->trypos;goto
retry_anywhere_2
x42
c0(iT);a=0;}
eS3
iT;++a){if(used[a])y81
retry_anywhere:{lZ1
r=TestParam(xZ2
xI2
lH3);lI3
used[a]=true;if(tA1
eT3
a);x6->trypos=a
l81
lZ1(true,&*x6);}
}
retry_anywhere_2:if(&*lV1){goto
retry_anywhere;}
}
nX2
yT1
y91
x22
MatchInfo
x8
info;yG<bool>used;iF2
y91(size_t
eR3)yC3,info(),used(eR3){}
}
;iP2
MatchPositionSpec_AnyParams:xP1
y91
x8>{e13
iF2
MatchPositionSpec_AnyParams(xL3,size_t
m):xM3
y91
x8>(n,y91
x8(m)){}
}
;yV1
lZ1
TestParams(t0&nM,lM1&tree
eA2
start_at,t9
info,bool
tA1{if(nM.match_type!=AnyParams){if(xT!=iT
yI}
if(!IsLogisticallyPlausibleParamsMatch(nM
n72{nX2
switch(nM.match_type
iY2
PositionalParams:{xN<cL>x6;i02
lG3
cL
n92
a=xT-1;goto
lD1
x42
cL(xT);a=0;}
eS3
xT;++a){cX2=info;retry_positionalparams:{lZ1
r=TestParam(cX
a),xI2
lH3);lI3
y81}
}
lD1:if(&*lV1){info=cX2;goto
retry_positionalparams;}
if(a>0){--a;goto
lD1;}
info=(*x6)[0].info
l81
false;}
if(tA1
for
iL1
a=0;a<xT;++a)eT3
a)l81
lZ1(true,&*x6)cM3
SelectedParams:case
AnyParams:{xN<t6>x6;yG<bool>used(iT);yG<i02>iG2(xT);yG<i02>y02(xT)lO1{const
cG2
lF3=cX
a);iG2[a]=ParamSpec_GetDepCode(lF3);}
{i02
b=0
lO1
if(iG2[a]!=0)y02[b++]=a
lO1
if(iG2[a]==0)y02[b++]=a;}
i02
lG3
t6
n92
if(xT==0){a=0;goto
retry_anyparams_4;}
a=xT-1;goto
cY1
x42
t6(xT,iT);a=0;if(xT!=0){(*x6)[0].info=info;(*x6)[0].used=used;}
}
eS3
xT;++a){if(a>0){cX2=info;(*x6)[a].used=used;}
retry_anyparams:{lZ1
r=TestParam_AnyWhere
x8(cX
y02[a]),tree
lH3,used,tA1;lI3
y81}
}
cY1:if(&*lV1){info=cX2;used=(*x6)[a].used;goto
retry_anyparams;}
cZ1:if(a>0){--a;goto
cY1;}
info=(*x6)[0].info
l81
false;}
retry_anyparams_4:if(nM.n2!=0){if(!TopLevel||!info.HasRestHolder(nM.n2)){yG
nV1
yS2;yS2.nH3
iT)xS3
b=0;b<iT;++b){if(xN3)y81
yS2
yL
tree
lD
b));xN3=true;if(tA1
eT3
b);}
if(!info.SaveOrTestRestHolder(nM.n2,yS2)){goto
cZ1;}
}
else{lL1&yS2=info.GetRestHolderValues(nM.n2)c23
0;a<yS2
eW2
a){bool
found=false
xS3
b=0;b<iT;++b){if(xN3)y81
if(yS2[a]iA
tree
lD
b))){xN3=true;if(tA1
eT3
b);found=true;nM3}
if(!found){goto
cZ1;}
}
}
}
return
lZ1(true,xT?&*x6:0)cM3
GroupFunction:nM3
nX2}
#endif
#ifdef FP_SUPPORT_OPTIMIZER
#include <algorithm>
#include <assert.h>
using
iO2
FPoptimizer_CodeTree;using
iO2
FPoptimizer_Optimize;iO2{yV1
yK2
xQ1
const
cG2&xZ2
t9
info,bool
inner=true){xT3
NumConstant:{const
eZ&t82
eZ*x01
l81
CodeTreeImmed
iZ2
xZ3)cM3
lY2
yK3&t82
xH*x01
l81
info.GetParamHolderValue
iZ2
index)iD2
const
xI&t82
xI*x01
yJ
tree;tH
xF3
cS)xS3
a=0;a<xF3
data
xY2;++a)nG1
nparam=xQ1
e01
x8
iZ2
data.param_list,a),info,true
tT
yA
nparam);}
if
iZ2
data.n2!=0){yG
nV1
trees(info.GetRestHolderValues
iZ2
data.n2)tT.AddParamsMove(trees);if(iT==1){assert(tree.tU3()==cAdd tI3()==cMul tI3()==cMin tI3()==cMax tI3()==cAnd tI3()==cOr tI3()==cAbsAnd tI3()==cAbsOr);tree.xO2
0));}
tP1
iT==0){switch
xU2
iY2
cAdd:case
cOr:tree=nB1
0));lC
cMul:case
cAnd:tree=nB1
1));default:nM3}
}
if(inner)tree
x02
l81
tree;}
}
return
yK2();}
}
iO2
FPoptimizer_Optimize{xB1
SynthesizeRule
eX3
yK2&tree,t9
info){switch(rule.ruletype
iY2
ProduceNewTree:{tree.Become(xQ1
e01
x21
0),info,false)nW2
case
ReplaceParams:default:{yG<i02>list=info.GetMatchedParamIndexes();std::sort(list.i62
list.end())c23
list
yA3;a-->0;)tree.iH1
list[a])xS3
a=0;a<rule.repl_param_count;++a)nG1
nparam=xQ1
e01
x21
a),info,true
tT
yA
nparam);}
nM3}
}
}
#endif
#ifdef DEBUG_SUBSTITUTIONS
#include <sstream>
#include <cstring>
xQ
using
iO2
l41;using
iO2
FPoptimizer_CodeTree;using
iO2
FPoptimizer_Optimize;iO2
l41{xB1
DumpMatch
eX3
lM1&tree,const
t9
info,bool
DidMatch,std::ostream&o){DumpMatch
t81,DidMatch?tZ3"match"
:tZ3"mismatch"
,o);}
xB1
DumpMatch
eX3
lM1&tree,const
t9
info,const
char*eY3,std::ostream&o){static
const
char
ParamHolderNames[][2]={"%"
,"&"
,"x"
,"y"
,"z"
,"a"
,"b"
,"c"
}
;o<<eY3<<" (rule "
<<(&rule-grammar_rules)<<")"
<<":\n  Pattern    : "
;{cG2
tmp;tmp.first=SubFunction;xI
tmp2;tmp2.data=rule
nT2;tmp
eE3=i01
void*)&tmp2;DumpParam
x8(tmp,o);}
o<<"\n  Replacement: "
;DumpParams
x21
rule.repl_param_count,o);o<<"\n"
;o<<"  Tree       : "
;xE3(tree,o);o<<"\n"
;if(!std::strcmp(eY3,tZ3"match"
))DumpHashes(tree,o)c23
0;a<i33
eW2
a){if(!i33[a].iA1
y81
o<<"           "
<<ParamHolderNames[a]<<" = "
;xE3(i33[a],o);o<<"\n"
;}
eW3
info.lQ
eW2
b){if(!eH2
first)y81
for
xK2
0;a<eH2
second
eW2
a){o<<"         <"
<<b<<"> = "
;xE3(eH2
second[a],o);o<<std::endl;}
}
o<<std::flush;}
}
#endif
#include <list>
#include <algorithm>
#ifdef FP_SUPPORT_OPTIMIZER
xQ
iO2{xG1
MarkIncompletes(x2){if(tree.Is_Incompletely_Hashed(iF1;bool
i51
i13
for
yS
i51|=MarkIncompletes
nW1
a));if(i51)tree.Mark_Incompletely_Hashed()l81
i51;}
xB1
FixIncompletes(x2){if(tree.Is_Incompletely_Hashed()){for
yS
FixIncompletes
nW1
a)tT
x02;}
}
}
iO2
FPoptimizer_CodeTree{lA
Sort()cX3
Sort();}
lA
Rehash(bool
constantfolding){if(constantfolding)ConstantFolding(*this);else
Sort();data
xB
yV1
l11{c2
e62
eZ3
nP3=0;
#if 0
long
double
value=Value;eB=crc32::calc(i01
i02
char*)&value,xK3
value));key^=(key<<24);
#elif 0
union{e92{i02
char
filler1[16];eS1
v;i02
char
filler2[16];}
buf2;e92{i02
char
filler3[xK3
eS1)+16-x
K3
iC1)];eB;}
buf1;}
data;memset(&data,0,xK3
data));data.buf2.v=Value;eB=data.buf1.key;
#else
int
cE2;eS1
lQ2=std::frexp(Value,&cE2);eB=iL1(cE2+0x8000)&0xFFFF);if(lQ2<0){lQ2=-lQ2;key=key^0xFFFF;}
else
key+=0x10000;lQ2-=yF3;key<<=39;key|=iC1((lQ2+lQ2)*eS1(1u<<31))<<8;
#endif
iU
tM
#ifdef FP_SUPPORT_LONG_INT_TYPE
n73<>l11<long>{c2
long
eZ3
eB=Value;iU
tM
#endif
#ifdef FP_SUPPORT_GMP_INT_TYPE
n73<>l11<GmpInt>{c2
const
GmpInt&eZ3
eB=Value.toInt();iU
tM
#endif
xB1
nO2
x8::Recalculate_Hash_NoRecursion(){fphash_t
iU(iC1(Opcode)<<56,Opcode*tM3(0x1131462E270012B));Depth=1;switch(Opcode
iY2
cImmed:{ImmedHashGenerator
x8::MakeHash(iU,Value
nW2
case
iE2:{nP3|=eC<<48
eC2((eC)*11)^tM3(0x3A83A83A83A83A0);nM3
case
cFCall:case
cPCall:{nP3|=eC<<48
eC2((~eC)*7)^3456789;}
default:{size_t
eM1=0
c23
0;a<c93
eW2
a){if(c93[a].xT2>eM1)eM1=c93[a].xT2;nP3+=((c93[a]eE2
hash1*(a+1))>>12)eC2
c93[a]eE2
hash1
eC2(3)*tM3(0x9ABCD801357);iU.hash2*=tM3(0xECADB912345)eC2(~c93[a]eE2
hash2)^4567890;}
Depth+=eM1;}
}
if(Hash!=iU){Hash=iU;iK1=0;}
}
lA
FixIncompleteHashes(){MarkIncompletes(*this);FixIncompletes(*this);}
}
#endif
#include <cmath>
#include <list>
#include <cassert>
#ifdef FP_SUPPORT_OPTIMIZER
xQ
iO2{using
iO2
FPoptimizer_CodeTree;xG1
x31
lM1&tree,long
count,const
yV2
SequenceOpCode
x8&eQ,yW2&synth,size_t
max_bytecode_grow_length);static
const
e92
SinCosTanDataType{OPCODE
whichopcode;OPCODE
inverse_opcode;enum{nominator,denominator,inverse_nominator,inverse_denominator}
;OPCODE
codes[4];}
SinCosTanData[12]={{cTan,cCot,{cSin,cCos,cCsc,cSec}
}
,{cCot,cCot,{cCos,cSin,cSec,cCsc}
}
,{cCos,cSec,{cSin,cTan,cCsc,cCot}
}
,{cSec,cCos,{cTan,cSin,cCot,cCsc}
}
,{cSin,cCsc,{cCos,cCot,cSec,cTan}
}
,{cCsc,cSin,{cCot,cCos,cTan,cSec}
}
,{yT2{cSinh,cH3
yY2,{cSinh,cNop,{yT2
cNop,cCosh}
}
,{cH3
cNop,{cSinh,yT2
cNop}
}
,{cNop,cTanh,{cH3
cSinh,yY2,{cNop,cSinh,{cNop,cTanh,cH3
cNop}
}
,{cNop,cH3{cTanh,cSinh,yY2}
;}
iO2
FPoptimizer_CodeTree{lA
SynthesizeByteCode(yG<i02>&nN,yG
x8&Immed,size_t&stacktop_max){
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"Making bytecode for:\n"
;iO
#endif
while(RecreateInversionsAndNegations()){
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"One change issued, produced:\n"
;iO
#endif
FixIncompleteHashes();}
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"Actually synthesizing, after recreating inv/neg:\n"
;iO
#endif
yW2
synth;SynthesizeByteCode(synth,false
eU3.Pull(nN,Immed,stacktop_max);}
lA
SynthesizeByteCode(yW2&synth,bool
MustPopTemps)const{xR1*this)){return;}
for
xK2
0;a<12;++a){const
SinCosTanDataType&data=SinCosTanData[a];if(data.whichopcode!=cNop){if(lM2!=data.whichopcode)y81
yL2
lJ3;lJ3.lI1
lJ3
tU
data.inverse_opcode);lJ3.y12);xR1
lJ3)){synth.l21
else{if(lM2!=cInv)y81
if(GetParam(0)nE!=data.inverse_opcode)y81
xR1
GetParam(0))){synth.l21
size_t
found[4];eW3
4;++b){yL2
tree;if(data.t03]==cNop){tH
cInv);yL2
lK3;lK3.lI1
lK3
tU
data.t03^2]);lK3.y12
tT
yA
lK3);}
else{tree.lI1
tH
data.t03]);}
tree.y12);found[b]t13
e33(tree);}
if(found[data.y22!=tG
i61
yK
y22);lJ1
i61);lK1
cDiv
nL1
y22!=tG
iV
yK
y22);lJ1
iV);lK1
cMul
nL1
lS1!=tG
iV
yK
lS1);lJ1
iV);lK1
cRDiv
nL1
lS1!=tG
i61
yK
lS1);lJ1
i61);lK1
cMul,2,1
eU3.l21
size_t
n_subexpressions_synthesized=SynthCommonSubExpressions(synth);switch(lM2
iY2
iE2:synth.PushVar(GetVar());lC
cImmed:yX2
xJ1);lC
cAdd:case
cMul:case
cMin:case
cMax:case
cAnd:case
cOr:case
cAbsAnd:case
cAbsOr:{if(lM2==cMul){bool
xU3
i13
c3
lT1
y21&&isLongInteger(lT1.xJ1)){yW1=makeLongInteger(lT1.xJ1);yL2
tmp(*this,typename
yL2::CloneTag());tmp
cP3
tmp
x02;if(x31
tmp,value,yV2
eX1
x8::AddSequence,synth,MAX_MULI_BYTECODE_LENGTH)){xU3=true;nM3}
}
if(xU3)nM3
int
yA1=0;yG<bool>done(GetParamCount(),false);yL2
iE;iE
tU
lM2);for(;;){bool
found
i13
c3
done[a])y81
if(synth.IsStackTop(lT1)){found=true;done[a]=true;lT1.nB
iE
eT
lT1);if(++yA1>1){synth
c4
2);iE.y12
eU3.yZ2
iE);yA1=yA1-2+1;}
}
}
if(!found)nM3
c3
done[a])y81
lT1.nB
iE
eT
lT1);if(++yA1>1){synth
c4
2);iE.y12
eU3.yZ2
iE);yA1=yA1-2+1;}
}
if(yA1==0){switch(lM2
iY2
cAdd:case
cOr:case
cAbsOr:yX2
0);lC
cMul:case
cAnd:case
cAbsAnd:yX2
1);lC
cMin:case
cMax:yX2
0);break;default:nM3++yA1;}
assert(n_stacked==1);nM3
case
cPow:{iQ2
p0
tW2
0);iQ2
p1
tW2
1);if(!p1
y21||!isLongInteger
n03)||!x31
p0,makeLongInteger
n03),yV2
eX1
x8::MulSequence,synth,MAX_POWI_BYTECODE_LENGTH)){p0.nB
p1
t33
c4
2);c91
cIf:case
i03:{typename
yW2::IfData
yJ2;GetParam(0)t33.SynthIfStep1(yJ2,lM2);GetParam(1)t33.SynthIfStep2(yJ2);GetParam(2)t33.SynthIfStep3(yJ2
nW2
case
cFCall:case
cPCall:{for
xK2
0;a<cN3++a)lT1
t33
c4
iL1)GetParamCount());lK1
yM|GetFuncNo(),0,0
nW2
default:{for
xK2
0;a<cN3++a)lT1
t33
c4
iL1)GetParamCount()nW2}
synth.yZ2*this);if(MustPopTemps&&n_subexpressions_synthesized>0){size_t
top
t13
GetStackTop(eU3.DoPopNMov(top-1-n_subexpressions_synthesized,top-1);}
}
}
iO2{xG1
x31
lM1&tree,long
count,const
yV2
SequenceOpCode
x8&eQ,yW2&synth,size_t
max_bytecode_grow_length){if
cR3!=0){yW2
backup=synth;tree.nB
size_t
bytecodesize_backup
t13
GetByteCodeSize();yV2
x31
count
eR2
size_t
bytecode_grow_amount
t13
GetByteCodeSize()-bytecodesize_backup;if(bytecode_grow_amount>max_bytecode_grow_length){synth=backup
l81
false;}
return
true;}
else{yV2
x31
count,eQ,synth)nS2}
}
#endif
#include <cmath>
#include <cassert>
#ifdef FP_SUPPORT_OPTIMIZER
xQ
iO2{using
iO2
FPoptimizer_CodeTree;
#define FactorStack yG
const
e92
PowiMuliType{i02
opcode_square;i02
opcode_cumulate;i02
opcode_invert;i02
opcode_half;i02
opcode_invhalf;}
iseq_powi={cSqr,cMul,cInv,cSqrt,cRSqrt}
,iseq_muli={i21,cAdd,cNeg,i21,i21}
;yB1
cF1
const
PowiMuliType&xV3,const
yG<i02>&nA2,l92&stack){eS1
cY3
1);while(IP<limit){if(xW3
xV3.opcode_square){if(!eY2
cZ3
2;e4
opcode_invert){result=-result;e4
opcode_half){if(result>eS1(0)&&isEvenInteger(cZ3
yF3;e4
opcode_invhalf){if(result>eS1(0)&&isEvenInteger(cZ3
eS1(-0.5);++IP;y81}
size_t
nB2=IP;eS1
lhs(1);if(xW3
cFetch){lC1=yL3;if(index<y1||size_t(index-y1)>=stack
yA3){IP=nB2;nM3
lhs=stack[index-y1];goto
y32;}
if(xW3
cDup){lhs=result;goto
y32;y32:y63
result);++IP;eS1
subexponent=cF1
xV3
lQ1
if(IP>=limit||nN[IP]!=xV3.opcode_cumulate){IP=nB2;nM3++IP;stack.pop_back();result+=lhs*subexponent;y81}
nM3
return
result;}
yB1
ParsePowiSequence
i01
yG<i02>&nA2){l92
stack;y63
eS1(1))l81
cF1
iseq_powi
lQ1}
yB1
ParseMuliSequence
i01
yG<i02>&nA2){l92
stack;y63
eS1(1))l81
cF1
iseq_muli
lQ1}
iP2
CodeTreeParserData{e13
iF2
CodeTreeParserData(bool
k_powi):stack(),clones(),keep_powi(k_powi){}
void
Eat(size_t
eR3,OPCODE
opcode
xX3;xK
tU
opcode);yG
nV1
cB2=Pop(eR3);xK
tI1
cB2);if(!keep_powi)switch(opcode
iY2
cTanh:nG1
sinh,cosh;sinh
tU
cSinh);sinh
eT
xK
xY3
sinh
x02;cosh
tU
cCosh);cosh
yA
xK
xY3
cosh
i72
pow
yB2
yA
cosh);pow
yT
eS1(-1)));pow
x02;xK
tU
y13.nC1
0,sinh);xK
yA
pow
nW2
case
cTan:nG1
sin,cos;sin
tU
cSin);sin
eT
xK
xY3
sin
x02;cos
tU
cCos);cos
yA
xK
xY3
cos
i72
pow
yB2
yA
cos);pow
yT
eS1(-1)));pow
x02;xK
tU
y13.nC1
0,sin);xK
yA
pow
nW2
case
cPow:{lM1&p0=xK
lD
0);lM1&p1=xK
lD
1);if(p1
nE==cAdd){yG
nV1
n83(p1.GetParamCount())c23
0;a<p1.cN3++a)nG1
pow
yB2
eT
p0);pow
eT
p1
lD
a));pow
x02;n83[a
t23
pow);}
xK
tU
y13
tI1
n83);}
nM3
default:nM3
xK.Rehash(!keep_powi);i71,false);
#ifdef DEBUG_SUBSTITUTIONS
lC2<<eR3<<", "
<<FP_GetOpcodeName(opcode)<<"->"
<<FP_GetOpcodeName(xK
nE)<<": "
tP3
xK)tW
xK);
#endif
y63
xK
iR2
EatFunc(size_t
eR3,OPCODE
opcode,i02
funcno
xX3=CodeTreeFuncOp
x8(opcode,funcno);yG
nV1
cB2=Pop(eR3);xK
tI1
cB2);xK.y12);
#ifdef DEBUG_SUBSTITUTIONS
lC2<<eR3<<", "
tP3
xK)tW
xK);
#endif
i71);y63
xK
iR2
AddConst(yF1
xX3=CodeTreeImmed(value);i71);Push(xK
iR2
AddVar
iL1
varno
xX3=CodeTreeVar
x8(varno);i71);Push(xK
iR2
SwapLastTwoInStack(){y73
1
t23
y73
2]iR2
Dup(){Fetch
lB2
1
iR2
Fetch(size_t
which){Push(stack[which]);}
nT1
T>void
Push(T
tree){
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<tP3
tree)tW
tree);
#endif
y63
tree
iR2
PopNMov(size_t
target,size_t
source){stack[target]=stack[source];stack
nE3
target+1);}
yK2
y42{clones.clear()yJ
cY3
stack.back());stack.resize
lB2
1)l81
result;}
yG
nV1
Pop(size_t
n_pop){yG
nV1
cY3
n_pop)xS3
n=0;n<n_pop;++n)result[n
t23
y73
n_pop+n]);
#ifdef DEBUG_SUBSTITUTIONS
for(xL3=n_pop;n-->0;){lC2;xE3(result[n])tW
result[n]);}
#endif
stack.resize
lB2
n_pop)l81
result;}
size_t
GetStackTop(n61
stack
yA3;}
private:void
FindClone(yK2&,bool=true){return;}
private:yG
nV1
stack;std::multimap<fphash_t,yK2>clones;bool
keep_powi;private:CodeTreeParserData
i01
CodeTreeParserData&);CodeTreeParserData&e31=i01
CodeTreeParserData&);}
;yT1
IfInfo
nG1
cU2
yJ
thenbranch;size_t
endif_location;IfInfo():cU2(),thenbranch(),endif_location(){}
}
;}
iO2
FPoptimizer_CodeTree{lA
GenerateFrom
i01
yG<i02>&nN,const
yG
x8&Immed,const
typename
FunctionParserBase
x8::Data&cJ3,bool
keep_powi){yG
nV1
nK2;nK2.nH3
cJ3.mVariablesAmount)xS3
n=0;n<cJ3.mVariablesAmount;++n){nK2
yL
CodeTreeVar
x8(n+iE2));}
GenerateFrom(nN,Immed,cJ3,nK2,keep_powi);}
lA
GenerateFrom
i01
yG<i02>&nN,const
yG
x8&Immed,const
typename
FunctionParserBase
x8::Data&cJ3,const
i22
nK2,bool
keep_powi){
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"ENTERS GenerateFrom()\n"
;
#endif
CodeTreeParserData
x8
sim(keep_powi);yG<IfInfo
x8>eN;for(size_t
IP=0,DP=0;;++IP){tO2:while(!eN
cQ3&&(eN.eD==IP||(IP<nN
yA3&&xW3
cJump&&eN.e11.iA1)){yL2
elsebranch=sim.y42
yG3
eN.back().cU2)yG3
eN.e11)yG3
elsebranch);iJ
3,cIf);eN.pop_back();}
if(IP>=nN
yA3)break;i02
opcode=nN[IP];if((opcode==cSqr||opcode==cDup||(opcode==cInv&&!IsIntType
x8::result)||opcode==cNeg||opcode==cSqrt||opcode==cRSqrt||opcode==cFetch)){size_t
was_ip=IP;eS1
cE2=ParsePowiSequence
x8(nN,IP,eN
cQ3?nN
yA3:eN.eD,sim.x5
1);if(cE2!=1.0){x9
cE2)yJ3;goto
tO2;}
if(opcode==cDup||opcode==cFetch||opcode==cNeg){eS1
xD2=ParseMuliSequence
x8(nN,IP,eN
cQ3?nN
yA3:eN.eD,sim.x5
1);if(xD2!=1.0){x9
xD2)yE
cMul);goto
tO2;}
}
IP=was_ip;}
if(lD2>=iE2){sim.Push(nK2[opcode-iE2]);}
else{switch(lD2
iY2
cIf:case
i03:{eN
nE3
eN
yA3+1);yL2
res(sim.y42);eN.back().cU2.swap(res);eN.eD=nN
yA3;IP+=2;y81}
case
cJump:{yL2
res(sim.y42);eN.e11.swap(res);eN.eD=nN[IP+1]+1;IP+=2;y81}
case
cImmed:x9
Immed[DP++]);lC
cDup:sim.Dup();lC
cNop:lC
cFCall:{i02
funcno=yL3;assert(funcno<fpdata.mFuncPtrs.size());i02
cB2=cJ3.mFuncPtrs
yD3
mParams;sim.EatFunc(cB2,lD2,funcno
nW2
case
cPCall:{i02
funcno=yL3;assert(funcno<fpdata.tQ3.size());const
FunctionParserBase
x8&p=*cJ3.tQ3
yD3
mParserPtr;i02
cB2=cJ3.tQ3
yD3
mParams;yG<yL2>paramlist=sim.Pop(cB2);yL2
tP2;tP2.GenerateFrom(p.mData->mByteCode,p.mData->mImmed,*p.mData,paramlist)yG3
tP2
nW2
case
cInv:x9
1
nY2
cDiv);lC
cNeg:yE3
cNeg);break;x9
0
nY2
cSub);lC
cSqr:x9
2
e21
cSqrt:x9
yF3
e21
cRSqrt:x9
eS1(-0.5)e21
cCbrt:x9
eS1(1)/eS1(3)e21
cDeg:x9
fp_const_rad_to_deg
x8
cI1
cRad:x9
fp_const_deg_to_rad
x8
cI1
cExp:iF)goto
yI3;x9
fp_const_e
x8()nY2
cPow);lC
cExp2:iF)goto
yI3;x9
2.0
nY2
cPow);lC
cCot:yE3
cTan);iF)nY
cCsc:yE3
cSin);iF)nY
cSec:yE3
cCos);iF)nY
cInt:
#ifndef __x86_64
iF){yE3
cInt
nW2
#endif
x9
yF3)lL3
yE3
cFloor);lC
cLog10:yE3
yH3
fp_const_log10inv
x8
cI1
cLog2:yE3
yH3
fp_const_log2inv
x8
cI1
cLog2by:cK3
yE3
yH3
fp_const_log2inv
x8());iJ
3,cMul);lC
cHypot:x9
2)yJ3;cK3
x9
2)yJ3
lL3
x9
yF3
e21
cSinCos:sim.Dup();yE3
cSin);cK3
yE3
cCos);lC
cRSub:cK3
case
cSub:iF){iJ
2,cSub
nW2
x9-1)yE
cMul)lL3
lC
cRDiv:cK3
case
cDiv:iF||IsIntType
x8::result){iJ
2,cDiv
nW2
x9-1)yJ3
yE
cMul);lC
cAdd:case
cMul:case
cMod:case
cPow:case
cEqual:case
cLess:case
cGreater:case
t71:case
cLessOrEq:case
cGreaterOrEq:case
cAnd:case
cOr:case
cAbsAnd:case
cAbsOr:iJ
2,xS1
lC
cNot:case
cNotNot:case
yR3:case
cAbsNotNot:yE3
xS1
lC
cFetch:sim.Fetch(yL3);lC
cPopNMov:{i02
stackOffs_target=yL3;i02
stackOffs_source=yL3;sim.PopNMov(stackOffs_target,stackOffs_source
nW2
#ifndef FP_DISABLE_EVAL
case
cEval:{size_t
paramcount=cJ3.mVariablesAmount;iJ
paramcount,xS1
nM3
#endif
default:yI3:;i02
funcno=opcode-cAbs;assert(funcno<FUNC_AMOUNT);const
FuncDefinition&func=Functions[funcno];iJ
func.cB2,xS1
nM3}
}
Become(sim.y42);
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"Produced tree:\n"
;iO
#endif
}
}
#endif
#include <algorithm>
#ifdef FP_SUPPORT_OPTIMIZER
#include <assert.h>
#define FP_MUL_COMBINE_EXPONENTS
iO2{xQ
using
iO2
FPoptimizer_CodeTree;yV1
static
void
AdoptChildrenWithSameOpcode(eR{
#ifdef DEBUG_SUBSTITUTIONS
bool
lR2
i13
#endif
for
xU
if
nW1
a)nE==tree
nE){
#ifdef DEBUG_SUBSTITUTIONS
if(!lR2){std::cout<<"Before assimilation: "
eS
lR2=true;}
#endif
tree.AddParamsMove
nW1
a).GetUniqueRef().iE1),a);}
#ifdef DEBUG_SUBSTITUTIONS
if(lR2){std::cout<<"After assimilation:   "
eS}
#endif
}
}
iO2
FPoptimizer_CodeTree{xB1
ConstantFolding(eR{tree.Sort();
#ifdef DEBUG_SUBSTITUTIONS
void*yM3=0
lN1"["
<<(&yM3)<<"]Runs ConstantFolding for: "
eS
DumpHashes(tree);
#endif
if(false){redo:;tree.Sort();
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"["
<<(&yM3)<<"]Re-runs ConstantFolding: "
eS
DumpHashes(tree);
#endif
}
if
xU2!=cImmed){range
x8
p=iM
tree);if(p
y41
p
i0&&p.min==p.max)lL
p.min)n5}
if(false){ReplaceTreeWithOne
xP3
ReplaceWithImmed(eS1(1));goto
do_return;ReplaceTreeWithZero
xP3
ReplaceWithImmed(eS1(0));goto
do_return;ReplaceTreeWithParam0:
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"Before replace: "
lN1
std::hex<<'['<<tree
eE2
hash1<<','<<tree
eE2
hash2<<']'<<std::dec
eS
#endif
tree.xO2
0));
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"After replace: "
lN1
std::hex<<'['<<tree
eE2
hash1<<','<<tree
eE2
hash2<<']'<<std::dec
eS
#endif
e5
yN3
xU2
iY2
cImmed:lC
iE2:lC
cAnd:case
cAbsAnd
cP
bool
cE
i13
for
xU{if(!y93
a)))cE=true;yQ3
a),cV2
cAbsAnd)iY2
yO3:yP3
IsAlways:nF1);lC
lX1
yN3(iT
iY2
0
tY
1:tH
cV2
cAnd?cNotNot:cAbsNotNot);e5
default:if
xU2==cAnd||!cE)if(ConstantFolding_AndLogic
y83
c91
cOr:case
cAbsOr
cP
bool
cE
i13
for
xU{if(!y93
a)))cE=true;yQ3
a),cV2
cAbsOr)iY2
IsAlways
tY
yO3:nF1);lC
lX1
yN3(iT
iY2
0:yP3
1:tH
cV2
cOr?cNotNot:cAbsNotNot);e5
default:if
xU2==cOr||!cE)if(ConstantFolding_OrLogic
y83
c91
cNot:case
yR3:{i02
n21
0;switch
nW1
0)nE
iY2
cEqual:n21
t71;lC
t71:n21
cEqual;lC
cLess:n21
cGreaterOrEq;lC
cGreater:n21
cLessOrEq;lC
cLessOrEq:n21
cGreater;lC
cGreaterOrEq:n21
cLess;lC
cNotNot:n21
cNot;lC
cNot:n21
cNotNot;lC
yR3:n21
cAbsNotNot;lC
cAbsNotNot:n21
yR3;break;default:nM3
if(opposite){tH
OPCODE(opposite)tT.SetParamsMove
nW1
0).GetUniqueRef().iE1));e5
yN3(tX
0),tree
cG1)tF1
yP3
yO3
tY
lX1
if
xU2==cNot&&GetPositivityInfo
nW1
0))==IsAlways)tH
yR3);l23
nE==cIf||e72
nE==i03)nG1
iH2
cL2
0);lM1&ifp1=iH2
lD
1);lM1&ifp2=iH2
lD
2);if(ifp1
nE==cNot||ifp1
cG1{tree.x1
ifp1
nE==cNot?cNotNot:cAbsNotNot);tQ2
lD
0))yC1)yS3
xQ2
yT3)tV
if(ifp2
nE==cNot||ifp2
cG1{tree.x1
tree
nE);tQ2)yC1)yS3
tU
ifp2
nE==cNot?cNotNot:cAbsNotNot);yT3
lD
0))tV
c91
cNotNot:case
cAbsNotNot:{if(y93
0)))lN3
yQ3
0),cV2
cAbsNotNot)iY2
yO3:yP3
IsAlways
tY
lX1
if
xU2==cNotNot&&GetPositivityInfo
nW1
0))==IsAlways)tH
cAbsNotNot);l23
nE==cIf||e72
nE==i03)nG1
iH2
cL2
0);lM1&ifp1=iH2
lD
1);lM1&ifp2=iH2
lD
2);if(ifp1
nE==cNot||ifp1
cG1{tree.SetParam(0,iH2
lD
0)tT
eT
ifp1)yS3
xQ2
yT3)tV
if(ifp2
nE==cNot||ifp2
cG1{tree.x1
tree
nE);tQ2)yC1
tT
eT
ifp2);tH
iH2
nE);e5}
c91
cIf:case
i03:{if(ConstantFolding_IfOperations
y83
nM3
case
cMul:{NowWeAreMulGroup:;AdoptChildrenWithSameOpcode(tree);eS1
nN1=eS1(1);size_t
i81=0;bool
nO1=false
eV3
if(!xI2
y21)y81
eS1
immed=xI2.xJ1;if(immed==eS1(0))tZ
nN1*=immed;++i81;}
if(i81>1||(i81==1&&fp_equal(nN1,nY3)nO1=true;if(nO1){
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"cMul: Will add new "
tR3
nN1<<"\n"
;
#endif
for
xU
if
nW1
a)y21){
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<" - For that, deleting "
tR3
xI2.xJ1
lN1"\n"
;
#endif
lM3!fp_equal(nN1,nY3
tree
eT
cU1
nN1));yN3(iT
iY2
0
tY
1:lN3
default:if(ConstantFolding_MulGrouping
y83
if(ConstantFolding_MulLogicItems
y83
c91
cAdd
cP
eS1
lE2=0.0;size_t
i81=0;bool
nO1=false
eV3
if(!xI2
y21)y81
eS1
immed=xI2.xJ1;lE2+=immed;++i81;}
if(i81>1||(i81==1&&lE2==0.0))nO1=true;if(nO1){
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"cAdd: Will add new "
tR3
lE2<<"\n"
lN1"In: "
eS
#endif
for
xU
if
nW1
a)y21){
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<" - For that, deleting "
tR3
xI2.xJ1
lN1"\n"
;
#endif
lM3!(lE2==0.0))tree
eT
cU1
lE2));yN3(iT
iY2
0:yP3
1:lN3
default:if(ConstantFolding_AddGrouping
y83
if(ConstantFolding_AddLogicItems
y83
c91
cMin
cP
size_t
y52=0;range
x8
e6
eV3
while(a+1<iT&&xI2
iA
tree
lD
a+1)))nF1+1);range<nI
has_max&&(!e6
i0||(p.max)<e6.max)){e6.max=p.max;e6
i0=true;y52=a;}
}
if(e6
i0)for
xU{range<nI
iV2&&a!=y52&&p.min>=e6.max)lM3
iT==1){lN3
c91
cMax
cP
size_t
y52=0;range
x8
t1
eV3
while(a+1<iT&&xI2
iA
tree
lD
a+1)))nF1+1);range<nI
iV2&&(!t1.iV2||p.min>t1.min)){t1.min=p.min;t1.iV2=true;y52=a;}
}
if(t1.iV2){for
xU{range<nI
has_max&&a!=y52&&(p.max)<t1.min){nF1);}
}
}
if(iT==1){lN3
c91
cEqual:case
t71:case
cLess:case
cGreater:case
cLessOrEq:case
cGreaterOrEq:if(ConstantFolding_Comparison
y83
lC
cAbs:{range
x8
p0=y6
0));if(p0
eN1
lN3
if(p0
i0
yU3
tN{tH
cMul
tT
yT
nY3;goto
NowWeAreMulGroup;}
l23
nE==cMul){lM1&p
cL2
0);yG
nV1
lO3;yG
nV1
c02
c23
0;a<p.cN3++a){p0=iM
p
lD
a));if(p0
eN1{lO3
yL
p
lD
a));}
if(p0
i0
yU3
tN{c02
yL
p
lD
a));}
}
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"Abs: mul group has "
<<lO3
yA3<<" pos, "
<<c02
yA3<<"neg\n"
;
#endif
if(!lO3
cQ3||!c02
cQ3){
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"AbsReplace-Before: "
;xE3(tree)lN1"\n"
<<std::flush;DumpHashes
tJ1;
#endif
yK2
cL3;cL3
tU
cMul)c23
0;a<p.cN3++a){p0=iM
p
lD
a));if((p0
eN1||(p0
i0
yU3
tN){}
else
cL3
eT
p
lD
a));}
cL3
i72
lP3;lP3
tU
cAbs);lP3
yA
cL3);lP3
i72
xW1
cMul);n83
yA
lP3);xX1
AddParamsMove(lO3);if(!c02
cQ3){if(c02
yA3%2)n83
yT
eS1(-1)));xX1
AddParamsMove(c02);}
tree.Become(n83);
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"AbsReplace-After: "
;xE3
tJ1
lN1"\n"
<<std::flush;DumpHashes
tJ1;
#endif
goto
NowWeAreMulGroup;}
}
nM3
#define HANDLE_UNARY_CONST_FUNC(funcname) lX)lL funcname(n6))n5
case
cLog:tH3(fp_log);l23
nE==cPow)nG1
pow
cL2
0);if(GetPositivityInfo(pow
lD
0))==IsAlways){pow
lF2
tI
tree.lW
if(GetEvennessInfo(pow
x03==IsAlways){pow
lF2
yJ
abs;abs
tU
cAbs);abs
yA
pow
xY3
abs
x02
tI
pow.nC1
0,abs
tT.lW}
else
l23
nE==cAbs)nG1
pow
cL2
0)lD
0);if(pow
nE==cPow){pow
lF2
yJ
abs;abs
tU
cAbs);abs
yA
pow
xY3
abs
x02
tI
pow.nC1
0,abs
tT.lW}
lC
cAcosh:tH3(fp_acosh);lC
cAsinh:tH3(fp_asinh);lC
cAtanh:tH3(fp_atanh);lC
cAcos:tH3(fp_acos);lC
cAsin:tH3(fp_asin);lC
cAtan:tH3(fp_atan);lC
cCosh:tH3(fp_cosh);lC
cSinh:tH3(fp_sinh);lC
cTanh:tH3(fp_tanh);lC
cSin:tH3(fp_sin);lC
cCos:tH3(fp_cos);lC
cTan:tH3(fp_tan);lC
cCeil:if(n8
tH3(fp_ceil);lC
cTrunc:if(n8
tH3(fp_trunc);lC
cFloor:if(n8
tH3(fp_floor);lC
cInt:if(n8
tH3(fp_int);lC
cCbrt:tH3(fp_cbrt);lC
cSqrt:tH3(fp_sqrt);lC
cExp:tH3(fp_exp);lC
cLog2:tH3(fp_log2);lC
cLog10:tH3(fp_log10);lC
cLog2by:y2)lL
fp_log2(n6)*y4
nN3
cMod:y2)lL
fp_mod(n6,y4)nN3
cAtan2:{range
x8
p0
y5
p1=y6
1));lX&&fp_equal(n6,eS1(0))){if(p1
i0&&(p1.max)<0)lL
fp_const_pi
x8())n5
if(p1
y41
p1.min>=0.0)lL
eS1(0))n5}
if(nE1
fp_equal(y4,eS1(0))){if(p0
i0&&(p0.max)<0)lL-fp_const_pihalf
x8())n5
if(p0
y41
p0.min>0)lL
fp_const_pihalf
x8())n5}
y2)lL
fp_atan2(n6,y4))n5
if((p1
y41
p1.min>0.0)||(p1
i0&&(p1.max)<fp_const_negativezero
x8()))nG1
y62;y62
tU
cPow);y62
yA
tree
x03;y62
yT
eS1(-1)));y62
i72
y72;y72
e53
y72
yA
e72);y72
yA
y62);y72
y3
cAtan
tT.nC1
0,y72
tW1
1);c91
cPow:{if(ConstantFolding_PowOperations
y83
nM3
case
cDiv:y2&&y4!=0.0)lL
n6/y4
nN3
cInv:lX&&n6!=0.0)lL
eS1(1)/n6
nN3
cSub:y2)lL
n6-y4
nN3
cNeg:lX)lL-n6
nN3
cRad:lX)lL
RadiansToDegrees
t63
cDeg:lX)lL
DegreesToRadians
t63
cSqr:lX)lL
n6*n6
nN3
cExp2:tH3(fp_exp2);lC
cRSqrt:lX)lL
eS1(1)/fp_sqrt
t63
cCot:lX)nQ3=fp_tan(n6)xE
cSec:lX)nQ3=fp_cos(n6)xE
cCsc:lX)nQ3=fp_sin(n6)xE
cHypot:y2)lL
fp_hypot(n6,y4)nN3
cRDiv:case
cRSub:case
cDup:case
cFetch:case
cPopNMov:case
cSinCos:case
cNop:case
cJump:lC
cPCall:case
cFCall:case
cEval:nM3
do_return:;
#ifdef DEBUG_SUBSTITUTIONS
std::cout<<"["
<<(&yM3)<<"]Done ConstantFolding, result: "
eS
DumpHashes(tree);
#endif
}
}
#endif
#ifdef FP_SUPPORT_OPTIMIZER
xQ
using
iO2
FPoptimizer_CodeTree;iO2{n73<i02
cY2
e92
Comp{}
;n73<>e92
Comp<cLess>{n73<lF<yU
cLessOrEq>{n73<lF<=yU
cGreater>{n73<lF>yU
cGreaterOrEq>{n73<lF>=yU
cEqual>{n73<lF==yU
t71>{n73<lF!=b;}
}
;}
iO2
FPoptimizer_CodeTree{c12
set_abs(){if(!iV2&&!iI2{iV2=yV3}
tP1!iV2&&max
t83){iV2=true;min=-max;iJ2
false;}
tP1!iV2){iV2=yV3
iJ2
false;}
tP1
min
cH1
nZ2;tP1!iI2{iV2=yV3}
tP1
max
t83)nQ3(-max);max=-min;min=tmp;}
tP1-min>=max){max=-min;n31}
else{n31}
}
c12
set_neg(){std::swap(iV2,iI2;std::swap(min,max);min=-min;max=-max;}
yV
set_min_if(c31
if(iV2&&Comp<cY2()(min,v))min=func(min
t73
iV2=yW3
iV2;min=yW3
min;}
}
yV
set_max_if(c31
if(has_max&&Comp<cY2()(max,v))max=func(max
t73
iJ2
model
i0;max=yW3
max;}
}
yV
set_min_max_if(c31
set_min_if<cY2(v,func,model);set_max_if<cY2(v,func,model);}
c12
set_min(n7
if(iV2)min=func(min
t73
iV2=yW3
iV2;min=yW3
min;}
}
c12
set_max(n7
if(iI2
max=func(max
t73
iJ2
model
i0;max=yW3
max;}
}
c12
y82
n7
set_min(func,model);set_max(func,model);}
yV1
range
x8
iM
const
eR
#ifdef DEBUG_SUBSTITUTIONS_extra_verbose
{range
x8
tmp=CalculateResultBoundaries_do(tree)lN1"Estimated boundaries: "
;if(tmp.iV2)std::cout<<tmp.min;else
std::cout<<"-inf"
lN1" .. "
;if(tmp
i0)std::cout<<tmp.max;else
std::cout<<"+inf"
lN1": "
;xE3(tree)lN1
std::endl
l81
tmp;}
yV1
range
x8
yK2::CalculateResultBoundaries_do
i01
eR
#endif
{x81
eO1(-fp_const_pihalf
x8(),fp_const_pihalf
x8());x81
pi_limits(-fp_const_pi
x8(),fp_const_pi
x8());x81
abs_pi_limits(eS1(0),fp_const_pi
x8());using
iO2
std;switch
xU2
iY2
cImmed:nL
yZ3,yZ3);case
cAnd:case
cAbsAnd:case
cOr:case
cAbsOr:case
cNot:case
yR3:case
cNotNot:case
cAbsNotNot:case
cEqual:case
t71:case
cLess:case
cLessOrEq:case
cGreater:case
cGreaterOrEq:e83
0),eS1(1))cM3
cAbs:lB
m.set_abs(cY
cLog:lB
m.y7
fp_log
cY
cLog2:lB
m.y7
fp_log2
cY
cLog10:lB
m.y7
fp_log10
cY
cAcosh:lB
m
nL2
set_min_max_if<cGreaterOrEq
lQ3
fp_acosh
cY
cAsinh:lB
m.y82
fp_asinh
cY
cAtanh:lB
m
nL2
set_min_if<cGreater>(eS1(-1),fp_atanh);m
nL2
set_max_if<cLess
lQ3
fp_atanh
cY
cAcos:lB
nL(m
i0&&(m.max)<eS1(1))?fp_acos(m.max):eS1(0),(m
y41(m.min)>=eS1(-1))?fp_acos(m.min):fp_const_pi
x8())cM3
cAsin:lB
m
nL2
set_min_if<cGreater>(eS1(-1),fp_asin,eO1);m
nL2
set_max_if<cLess
lQ3
fp_asin,eO1
cY
cAtan:lB
m.y82
fp_atan,eO1
cY
cAtan2:{range
x8
p0
y5
p1=y6
1));lX&&fp_equal(n6,eS1(0))){return
abs_pi_limits;}
if(nE1
fp_equal(y4,eS1(0))){return
eO1;}
return
pi_limits
cM3
cSin:lB
bool
x41=!m.iV2||!m
i0||(m.max-m.min)>=(y8
x41)e0
eS1
min=cZ2
min,y8
min
t83)min
c5
eS1
max=cZ2
max,y8
max
t83)max
c5
if(max<min)max
c5
bool
xT1=(min<=fp_const_pihalf
x8()&&max>=fp_const_pihalf
x8());bool
nP1=(min<=cK&&max>=cK);if(xT1&&nP1)e0
if(nP1)nL
eS1(-1),lS2
if(xT1)nL
y92
eS1(1));nL
y92
lS2}
case
cCos:lB
if(m.iV2)m.min+=fp_const_pihalf
x8();if(m
i0)m.max+=fp_const_pihalf
x8();bool
x41=!m.iV2||!m
i0||(m.max-m.min)>=(y8
x41)e0
eS1
min=cZ2
min,y8
min
t83)min
c5
eS1
max=cZ2
max,y8
max
t83)max
c5
if(max<min)max
c5
bool
xT1=(min<=fp_const_pihalf
x8()&&max>=fp_const_pihalf
x8());bool
nP1=(min<=cK&&max>=cK);if(xT1&&nP1)e0
if(nP1)nL
eS1(-1),lS2
if(xT1)nL
y92
eS1(1));nL
y92
lS2}
case
cTan:{nL)cM3
cCeil:lB
m.c41
cFloor:lB
m.eP1
cY
cTrunc:lB
m.eP1);m.c41
cInt:lB
m.eP1);m.c41
cSinh:lB
m.y82
fp_sinh
cY
cTanh:lB
m.y82
fp_tanh,range
x8(eS1(-y03
cY
cCosh:lB
if(m.iV2){if(m
i0){if(m.min
cH1&&m.max
cH1){m.min
cM}
tP1(m.min)t83&&m.max
cH1)nQ3
cM
if(tmp>m.max)m.max=tmp;m.min=eS1(1);}
else{m.min
cM
std::swap(m.min,m.max);}
}
else{if(m.min
cH1){m
nM2
m.min=fp_cosh(m.min);}
else{m
nM2
m.min=eS1(1);}
}
}
else{m.iV2=true;m.min=eS1(1);if(m
i0){m.min=fp_cosh(m.max);m
nM2}
else
m
nM2}
return
m
cM3
cIf:case
i03:{range
x8
res1=y6
1));range
x8
res2=y6
2));if(!res2.iV2)res1.iV2
i13
tP1
res1
y41(res2.min)<res1.min)res1.min=res2.min;if(!res2
i0)res1
nM2
tP1
res1
i0&&(res2.max)>res1.max)res1.max=res2.max
l81
res1
cM3
cMin:{bool
iG
i13
bool
iH
i13
tB1;x4
m
xO3!m.iV2)iG=true;yP1.iV2||(m.min)<i11)i11=m.min;if(!m
i0)iH=true;yP1
i0||(m.max)<e63)e63=m.max;}
if(iG)c42
iH)tE1
l81
yA2
cMax:{bool
iG
i13
bool
iH
i13
tB1;x4
m
xO3!m.iV2)iG=true;yP1.iV2||m.min>i11)i11=m.min;if(!m
i0)iH=true;yP1
i0||m.max>e63)e63=m.max;}
if(iG)c42
iH)tE1
l81
yA2
cAdd:{tB1(eS1(0),eS1(0));x4
item
xO3
item.iV2)i11+=item.min;else
c42
item
i0)e63+=item.max;else
tE1;if(!result
y41!e02)nM3
if(result
y41
e02&&i11>e63)std::swap(i11,e63)l81
yA2
cMul:{e92
Value{enum
lR3{tR2,i91,PlusInf}
;lR3
eF;eS1
value;Value(lR3
t):eF(t),value(0){}
Value(eS1
v):eF(tR2),value(v){}
bool
c22
n61
eF==i91||(eF==tR2&&value
t83
iR2
e31*=i01
Value&rhs){if(eF==tR2&&rhs.eF==tR2)value*=rhs.value;else
eF=(c22)!=rhs.c22)?i91:PlusInf);}
i12<i01
Value&rhs
n61(eF==i91&&rhs.eF!=i91)||(eF==tR2&&(rhs.eF==PlusInf||(rhs.eF==tR2&&value<rhs.value)));}
}
;e92
yD1{Value
yC2,yD2;yD1():yC2(Value::PlusInf),yD2(Value::i91){}
void
nN2
Value
yX3,const
Value&value2){yX3*=value2;if(yX3<yC2)yC2=yX3;if(yD2<yX3)yD2=yX3;}
}
;tB1(eS1(y03;x4
item
xO3!item
y41!item
i0)nL);Value
lS3=c32?Value(i11):nC2
i91);Value
lT3=e02?Value(e63):nC2
PlusInf);Value
lU3=item.iV2?Value(item.min):nC2
i91);Value
lV3=item
i0?Value(item.max):nC2
PlusInf);yD1
range;range.nN2
lS3,lU3
eN2
lS3,lV3
eN2
lT3,lU3
eN2
lT3,lV3);if(range.yC2.eF==Value::tR2)i11=range.yC2.value;else
c42
range.yD2.eF==Value::tR2)e63=range.yD2.value;else
tE1;if(!result
y41!e02)nM3
if(result
y41
e02&&i11>e63)std::swap(i11,e63)l81
yA2
cMod:{range
x8
x
y5
y=y6
1));if(y
i0){if(y.max
cH1){if(!x.iV2||(x.min)<0)nL-y.max,y.max);else
nL
eS1(0),y.max);}
else{if(!x
i0||(x.max)>=0)nL
y.max,-y.max);else
nL
y.max,fp_const_negativezero
x8());}
}
else
nL)cM3
cPow:{if(nE1
y4==eS1(0))e83
y03;}
lX&&n6==eS1(0))e83
0),eS1(0));}
lX&&fp_equal(n6,nY3
e83
y03;}
if(nE1
y4>0&&GetEvennessInfo
nW1
1))==IsAlways)c21
y4;range
x8
tmp
y5
result;c32=true;i11=0;if(tmp
y41
tmp.min>=0)i11=eG3
tmp.min,cE2);tP1
tmp
i0&&tmp.max<=0)i11=eG3
tmp.max,cE2);tE1;if(tmp
y41
tmp
i0){e02=true;e63=std::max(fp_abs(tmp.min),fp_abs(tmp.max));e63=eG3
e63,cE2);}
return
result;}
range
x8
p0
y5
p1=y6
1
eO2
p0_positivity=(p0
y41(p0.min)cH1)?IsAlways:(p0
i0&&(p0.max)t83?yO3:Unknown);TriTruthValue
c52=GetEvennessInfo
nW1
1
eO2
t2=Unknown;switch(p0_positivity)tF1
t2=IsAlways;lC
yO3:{t2=c52;nM3
default:switch(c52)tF1
t2=IsAlways;lC
yO3:lC
Unknown:{if(nE1!eY2
y4)&&y4
cH1){t2=IsAlways;}
nM3}
yN3(t2)tF1{eS1
n31
if(p0
y41
p1.iV2){min=eG3
p0.min,p1.min);if(p0.min
t83&&(!p1
i0||p1.max
cH1)&&min
cH1)n31}
if(p0
y41
p0.min
cH1&&p0
i0&&p1
i0){eS1
max=eG3
p0.max,p1.max);if(min>max)std::swap(min,max);nL
min,max);}
nL
min,false)cM3
yO3:{nL
false,fp_const_negativezero
x8());}
default:{nM3
c91
cNeg:lB
m.set_neg(cY
cSub
x7
cNeg
y23
1
y43
cAdd);y53;tmp
yY3
l81
lH
cInv:lV-1
e12
cDiv
x7
cInv
y23
1
y43
xU1
yY3
l81
lH
cRad:{cF
xU1
yT
fp_const_rad_to_deg
x8(e12
cDeg:{cF
xU1
yT
fp_const_deg_to_rad
x8(e12
cSqr:lV
2
e12
cExp:{cF
cPow);tmp
yT
fp_const_e
x8()));y53
l81
lH
cExp2:{cF
cPow);tmp
yT
nR3
y53
l81
lH
cCbrt:lB
m.y82
fp_cbrt
cY
cSqrt:lB
if(m.iV2)m.min=(m.min)<0?0:fp_sqrt(m.min);if(m
i0)m.max=(m.max)<0?0:fp_sqrt(m.max
cY
cRSqrt:lV-0.5
e12
cHypot:nG1
xsqr,ysqr,add,sqrt;xsqr
yC
0));xsqr
yT
nR3
ysqr
yC
1));ysqr
yT
nR3
xsqr
tU
cPow);ysqr
tU
cPow);add
yA
xsqr);add
yA
ysqr);add
tU
cAdd);sqrt
yA
add);sqrt
tU
cSqrt)l81
iM
sqrt)cM3
cLog2by
x7
cLog2
y23
0
y43
cMul);tmp
yY3;tmp
yC
1))l81
lH
cCot
x7
cTan)nG
lH
cSec
x7
cCos)nG
lH
cCsc
x7
cSin)nG
iM
tmp);}
lC
cRDiv:case
cRSub:case
cDup:case
cFetch:case
cPopNMov:case
cSinCos:case
cNop:case
cJump:case
iE2:lC
cPCall:lC
cFCall:lC
cEval:nM3
nL);}
yV1
TriTruthValue
GetIntegerInfo
i01
eR{switch
xU2
iY2
cImmed:return
eY2
yZ3)?IsAlways:yO3;case
cFloor:case
cCeil:case
cTrunc:case
cInt:return
IsAlways;case
cAnd:case
cOr:case
cNot:case
cNotNot:case
cEqual:case
t71:case
cLess:case
cLessOrEq:case
cGreater:case
cGreaterOrEq:return
IsAlways;case
cIf:{TriTruthValue
a=GetIntegerInfo
nW1
1
eO2
b=GetIntegerInfo
nW1
2));if(a==b
nZ2
a
l81
Unknown
cM3
cAdd:case
cMul:{for
xU
if(GetIntegerInfo
nW1
a))!=IsAlways
nZ2
Unknown
l81
IsAlways;}
default:nM3
return
Unknown;}
xG1
IsLogicalValue
i01
eR{switch
xU2
iY2
cImmed:return
fp_equal(yZ3,eS1(0))||fp_equal(yZ3,eS1(1));case
cAnd:case
cOr:case
cNot:case
cNotNot:case
cAbsAnd:case
cAbsOr:case
yR3:case
cAbsNotNot:case
cEqual:case
t71:case
cLess:case
cLessOrEq:case
cGreater:case
cGreaterOrEq:nW
cMul:{for
xU
if(!y93
a))yI
return
true
cM3
cIf:case
i03:{return
y93
1))&&y93
2));}
default:nM3
nX2}
#endif
#ifdef FP_SUPPORT_OPTIMIZER
xQ
#if defined(__x86_64) || !defined(FP_SUPPORT_CBRT)
# define CBRT_IS_SLOW
#endif
#if defined(DEBUG_POWI) || defined(DEBUG_SUBSTITUTIONS)
#include <cstdio>
#endif
t5{extern
const
i02
char
powi_table[256];}
iO2{using
iO2
FPoptimizer_CodeTree;xG1
IsOptimizableUsingPowi(long
immed,long
penalty=0){yW2
synth;synth.PushVar(iE2);size_t
bytecodesize_backup
t13
GetByteCodeSize();yV2
x31
immed,yV2
eX1
x8::MulSequence,synth);size_t
bytecode_grow_amount
t13
GetByteCodeSize()-bytecodesize_backup
l81
bytecode_grow_amount<size_t(MAX_POWI_BYTECODE_LENGTH-penalty);}
xB1
ChangeIntoRootChain(yK2&tree,bool
iK2,long
tS2,long
tT2){while(tT2>0){cF
cCbrt);nZ3);tmp.Rehash(nD2--tT2;}
while(tS2>0){cF
cSqrt);if(iK2){tmp
tU
cRSqrt);iK2
i13}
nZ3);tmp.Rehash(nD2--tS2;}
if(iK2){cF
cInv);nZ3
nD2}
}
yT1
RootPowerTable{static
const
eS1
RootPowers[(1+4)*(1+3)];}
;yV1
const
eS1
t7(1+4)*(1+3)]={eS1(1)lS
tB3
tB3
2*tB3
2*2*2)lS
3
x32
2
x32
2*2
x32
2*2*2
x32
2*2*2*2
x32
3
x32
3*2
x32
3*2*2
x32
3*2*2*2
x32
3*2*2*2*2
x32
3*3
x32
3*3*2
x32
3*3*2*2
x32
3*3*2*2*2
x32
3*3*2*2*2*2)}
;e92
PowiResolver{static
const
i02
MaxSep=4;static
lX3
tC3=5;typedef
int
c03;typedef
long
n63;typedef
long
t8;e92
yE2{yE2():n_int_sqrt(0),n_int_cbrt(0),sep_list(),lY1(0){}
int
n_int_sqrt;int
n_int_cbrt;int
eW1
MaxSep];t8
lY1;}
;yV1
static
yE2
CreatePowiResult(eS1
cE2){yE2
result;c03
eE=FindIntegerFactor(cE2);if(eE==0){
#ifdef DEBUG_POWI
tU2"no factor found for %Lg\n"
y33);
#endif
return
result;}
c13=xV1
cE2,eE);n63
e22=EvaluateFactorCost(eE,0,0,0)+cH
c13);int
tD3=0;int
tE3=0;int
lW3=0;
#ifdef DEBUG_POWI
tU2"orig = %Lg\n"
y33);tU2"plain factor = "
tS3"%ld\n"
,(int)eE,(long)e22);
#endif
for
iL1
n_s=0;n_s<MaxSep;++n_s){int
xC=0;n63
yE1=e22;c03
yQ1=eE;for(int
s=1;s<tC3*4;++s){
#ifdef CBRT_IS_SLOW
if(s>=tC3)break;
#endif
int
n_sqrt=s%tC3;int
n_cbrt=s/tC3;if(n_sqrt+n_cbrt>4)y81
eS1
lE1=cE2;lE1-=t7
s];tH1=FindIntegerFactor(lE1);if(xD2!=0){t8
xL=xV1
lE1,xD2);n63
cost=EvaluateFactorCost(xD2,tD3+n_sqrt,tE3+n_cbrt,lW3+1)+cH
xL);
#ifdef DEBUG_POWI
tU2"Candidate sep %u (%d*sqrt %d*cbrt)factor = "
tS3"%ld (for %Lg to %ld)\n"
,s,n_sqrt,n_cbrt,xD2,(long)cost
x12
lE1,(long)xL);
#endif
if(cost<yE1){xC=s;yQ1=xD2;yE1=cost;}
}
}
if(!xC)break;
#ifdef DEBUG_POWI
tU2"CHOSEN sep %u (%d*sqrt %d*cbrt)factor = "
tS3"%ld, exponent %Lg->%Lg\n"
,xC,xC%tC3,xC/tC3,yQ1,yE1
x12(cE2)x12(cE2-t7
xC]));
#endif
tC1
eW1
n_s]=xC;cE2-=t7
xC];tD3+=xC%tC3;tE3+=xC/tC3;e22=yE1;eE=yQ1;lW3+=1;}
c13=xV1
cE2,eE);
#ifdef DEBUG_POWI
tU2"resulting exponent is %ld (from exponent=%Lg, best_factor=%Lg)\n"
,c13
y33
x12
eE);
#endif
while(eE%2==0){++tC1
n_int_sqrt;eE/=2;}
while(eE%3==0){++tC1
n_int_cbrt;eE/=3;}
return
result;}
private:static
n63
cH
t8
xL){static
std::map
c62
i7;if(xL<0){n63
cost=22
l81
cost+cH-xL);}
std::map
c62::nX3
i=i7.xE2
xL);if(i!=i7.cP1
xL
nZ2
i
cJ2;std::pair
c62
cY3
xL,0.0);n63&cost=tC1
second;while(xL>1){int
xD2=0;if(xL<256){xD2=yV2
powi_table[xL];if(xD2&128)xD2&=127;else
xD2=0;if(xD2&64)xD2=-(xD2&63)-1;}
if(xD2){cost+=cH
xD2);xL/=xD2;y81}
if(!(xL&1)){xL/=2;cost+=6;}
else{cost+=7;xL-=1;}
}
i7.nT3,result)l81
cost
eI2
t8
xV1
yF1,tH1){return
makeLongInteger(value*eS1(xD2))eI2
bool
yG1
yF1,tH1){eS1
v=value*eS1(xD2)l81
isLongInteger(v)eI2
c03
FindIntegerFactor(yF1){tH1=(2*2*2*2);
#ifdef CBRT_IS_SLOW
#else
xD2*=(3*3*3);
#endif
c03
result=0;if(yG1
value,xD2)){result=xD2;while((xD2%2)==0&&yG1
value,xD2/2))result=xD2/=2;while((xD2%3)==0&&yG1
value,xD2/3))result=xD2/=3;}
#ifdef CBRT_IS_SLOW
if(result==0){if(yG1
value,3)nZ2
3;}
#endif
return
result;}
static
int
EvaluateFactorCost(int
xD2,int
s,int
c,int
nmuls){lX3
lY3=6;
#ifdef CBRT_IS_SLOW
lX3
e32=25;
#else
lX3
e32=8;
#endif
int
result=s*lY3+c*e32;while(xD2%2==0){xD2/=2;result+=lY3;}
while(xD2%3==0){xD2/=3;result+=e32;}
result+=nmuls
l81
result;}
}
;}
iO2
FPoptimizer_CodeTree{xG1
yK2::RecreateInversionsAndNegations(bool
prefer_base2){bool
changed=false
c23
0;a<cN3++a)if(lT1.RecreateInversionsAndNegations(prefer_base2))yI1
if(changed){exit_changed:Mark_Incompletely_Hashed()nS2
switch(lM2
iY2
cMul:{yG
nV1
lG2
yJ
lH2,cJ1;if(true){bool
nQ1
i13
eS1
nE2=0
c23
cO3
yF2
0)c82
tJ
1)y21){nQ1=true;nE2=tJ
1).xJ1;nM3}
if(nQ1){eS1
immeds=1.0
c23
cO3
y21){immeds*=powgroup.xJ1;yH1}
for
xK2
cN3
a-->0;)nG1&powgroup=lT1;if(powgroup
yF2
0)c82
tJ
1)y21)nG1&log2=tJ
0);log2.iY
log2
tU
lZ3
log2
yT
eG3
immeds,eS1(1)/nE2)));log2.Rehash(nW2}
}
}
for
xK2
cO3
yF2
1)y21){lM1&exp_param=tJ
1);eS1
cE2=exp_param.xJ1;if(cR1,eS1(-1))){iY
lG2
yL
lT1
xY3
yH1
tP1
cE2<0&&eY2
cE2))nG1
iI;iI
tU
cPow);iI
eT
tJ
0));iI
yT-cE2));iI
x02;lG2
yL
iI);iY
yH1}
tP1
powgroup
c82!lH2.iA1{lH2=tJ
0);iY
yH1
tP1
powgroup
nE==cLog2by&&!cJ1.iA1{cJ1=powgroup;iY
yH1}
if(!lG2
cQ3){changed=true
yJ
eR1;eR1
e53
eR1
tI1
lG2);eR1
i72
xW1
cMul);xX1
SetParamsMove(t3
if(xX1
IsImmed()&&fp_equal(xX1
xJ1,nY3{lI2
cInv);eG
eR1);}
else{if(xX1
xT2>=eR1.xT2){lI2
cDiv
eV1
eG
eR1);}
else{lI2
cRDiv);eG
eR1
eV1}
}
}
if(lH2.iA1
nG1
xW1
lM2);xX1
SetParamsMove(t3
while(xX1
RecreateInversionsAndNegations(prefer_base2))xX1
FixIncompleteHashes();lI2
lZ3
eG
lH2
eV1
yI1}
if(cJ1.iA1
nG1
xW1
cMul);n83
yA
cJ1
x03;xX1
AddParamsMove(t3
while(xX1
RecreateInversionsAndNegations(prefer_base2))xX1
FixIncompleteHashes();DelParams();lI2
lZ3
eG
cJ1
lD
0)eV1
yI1
c91
cAdd:{yG
nV1
tV2
c23
tD
c33
cMul){lJ2
xY1:yJ&n83
c72
for(iX2
xX1
cN3
b-->0;){if(n83
lD
b)xC3
xD2=n83
lD
b).xJ1
i82
xD2
eQ1
xY1;}
xX1
iY
xX1
iH1
b
eJ2
tP1
fp_equal(xD2,eS1(-2)))xF
xY1;}
xX1
iY
xX1
iH1
b);n83
yT
eS1(2))eJ2}
}
if(t4){xX1
nR1
n83);yH1}
tP1
c33
cDiv&&!IsIntType
x8::result){lJ2
xZ1:yJ&eR1
c72
if(eR1
lD
0)tF3(fp_equal(eR1
lD
0).xJ1
eQ1
xZ1;}
eR1.iY
eR1.iH1
0);eR1
tU
cInv
eJ2}
if(t4)xF
xZ1;}
eR1.nR1
eR1);yH1}
tP1
c33
cRDiv&&!IsIntType
x8::result){lJ2
x91:yJ&eR1
c72
if(eR1
lD
1)tF3(fp_equal(eR1
lD
1).xJ1
eQ1
x91;}
eR1.iY
eR1.iH1
1);eR1
tU
cInv
eJ2}
if(t4)xF
x91;}
eR1.nR1
eR1);yH1}
if(!tV2
cQ3){
#ifdef DEBUG_SUBSTITUTIONS
tU2"Will make a Sub conversion in:\n"
);fflush(stdout);iO
#endif
yK2
yR1;yR1
tU
cAdd);yR1
tI1
tV2);yR1
i72
cK1;cK1
tU
cAdd);cK1
tI1
iE1));cK1
x02;if(cK1
y21&&fp_equal(cK1.xJ1,eS1(0))){lI2
cNeg);cU3);}
else{if(cK1.xT2==1){lI2
cRSub);cU3);cV3}
tP1
yR1
nE==cAdd){lI2
cSub);cV3
cU3
xY3
for
xK2
1;a<yR1.cN3++a)nG1
e42;e42
tU
cSub);e42
tI1
iE1));e42.y12);eG
e42);cU3
lD
a));}
}
else{lI2
cSub);cV3
cU3);}
}
#ifdef DEBUG_SUBSTITUTIONS
tU2"After Sub conversion:\n"
);fflush(stdout);iO
#endif
c91
cPow:{lM1&p0
tW2
0);lM1&p1
tW2
1);if(p1
tF3
n03!=eS1(0)&&!eY2
p1.xJ1)){eJ
yE2
r=eJ
CreatePowiResult(fp_abs
n03));if(r.lY1!=0){bool
iB1
i13
if
n03<0&&r.eW1
0]==0&&r
x33>0){iB1=true;}
#ifdef DEBUG_POWI
tU2"Will resolve powi %Lg as powi(chain(%d,%d),%ld)"
x12
fp_abs
n03),r
x33,r.n_int_cbrt,r.lY1)xS3
n=0;n<eJ
MaxSep;++n){if(r
cW3==0)break;int
n_sqrt=r
cW3%eJ
tC3;int
n_cbrt=r
cW3/eJ
tC3;tU2"*chain(%d,%d)"
,n_sqrt,n_cbrt);}
tU2"\n"
);
#endif
yK2
c92
tW2
0)yJ
yG2=c92;yG2.iY
ChangeIntoRootChain(yG2,iB1,r
x33,r.n_int_cbrt);yG2
i72
pow;if(r.lY1!=1){pow
tU
cPow);pow
yA
yG2);pow
yT
eS1(r.lY1)));}
else
pow.swap(yG2)yJ
mul;mul
e53
mul
yA
pow)xS3
n=0;n<eJ
MaxSep;++n){if(r
cW3==0)break;int
n_sqrt=r
cW3%eJ
tC3;int
n_cbrt=r
cW3/eJ
tC3
yJ
e52=c92;e52.iY
ChangeIntoRootChain(e52,false,n_sqrt,n_cbrt);e52
x02;mul
yA
e52);}
if
n03<0&&!iB1){mul
x02;lI2
cInv);nC1
0,mul);iH1
1);}
else{lI2
cMul);SetParamsMove(mul.iE1));}
#ifdef DEBUG_POWI
iO
#endif
yI1
nM3}
}
if(lM2==cPow&&(!p1
y21||!isLongInteger
n03)||!IsOptimizableUsingPowi
x8(makeLongInteger
n03)))){if(p0
y21&&p0.xJ1>0.0){if(prefer_base2){eS1
yH2=fp_log2(p0.xJ1)i82
yH2,nY3{iH1
0);}
else{n1
cU1
yH2));cE2
eT
p1)tD1
iP}
lI2
cExp2);yI1}
else{eS1
yH2=fp_log(p0.xJ1)i82
yH2,nY3{iH1
0);}
else{n1
cU1
yH2));cE2
eT
p1)tD1
iP}
lI2
cExp);yI1}
}
tP1
GetPositivityInfo(p0)==IsAlways){if(prefer_base2)nG1
log;log
tU
cLog2);log
eT
p0);log
x02;n1
p1);cE2
yA
log)tD1);lI2
cExp2
iP
yI1}
else
nG1
log;log
tU
cLog);log
eT
p0);log
x02;n1
p1);cE2
yA
log)tD1);lI2
cExp
iP
yI1}
}
c91
cDiv:{if(GetParam(0)y21&&fp_equal(GetParam(0).xJ1,nY3{lI2
cInv);iH1
0);}
nM3
default:nM3
if(changed)goto
exit_changed
l81
changed;}
}
#endif
#ifdef FP_SUPPORT_OPTIMIZER
xQ
iO2{using
iO2
FPoptimizer_CodeTree;class
eT1{size_t
yJ1;size_t
eK;size_t
eL;size_t
lF1;e13
eT1():yJ1(0),eK(0),eL(0),lF1(0){}
void
c43
OPCODE
op){yJ1+=1;n13
cCos)++eK;n13
cSin)++eL;n13
cSec)++eK;n13
cCsc)++eL;n13
cTan)++lF1;n13
cCot)++lF1;}
size_t
GetCSEscore()const{size_t
result=yJ1
l81
result;}
int
NeedsSinCos()const{bool
always_sincostan=(yJ1==(eK+eL+lF1));if((lF1&&(eL||eK))||(eL&&eK)){if(always_sincostan
nZ2
1
l81
2;}
return
0;}
size_t
MinimumDepth()const{size_t
n_sincos=std::min(eK,eL);if(n_sincos==0
nZ2
2
l81
1;}
}
;iP2
TreeCountType:public
std::multimap<fphash_t,std::pair<eT1,yK2> >{}
;xB1
FindTreeCounts(nX1&lK2,lM1&tree,OPCODE
lL2{iG1
i=lK2.xE2
tree.GetHash());bool
found
i13
for(;i!=lK2.cP1
tree.GetHash();++i){if(tree
iA
i
cJ2
eE3)){i
cJ2.first.c43
lL2;found=true;nM3}
if(!found){eT1
count;count.c43
lL2;lK2.nT3,std::make_pair(tree.GetHash(),std::make_pair
cR3
n72);}
for
yS
FindTreeCounts(lK2,xI2,tree
nE);}
e92
c9{bool
BalanceGood;bool
cI;}
;yV1
c9
lG1
lM1&root,lM1&c53{if(root
iA
c53){c9
result={true,true}
l81
result;}
c9
result={true,false}
;if(root
nE==cIf||root
nE==i03){c9
cond=lG1
root
lD
0),c53;c9
xW=lG1
root
lD
1),c53;c9
y9=lG1
root
lD
2),c53;if(cond.cI||xW.cI||y9.cI){tC1
cI=true;}
result
eH=((xW.cI==y9.cI)||eX2&&(cond
eH||(xW.cI&&y9.cI))&&(xW
eH||eX2&&(y9
eH||eX2;}
else{bool
tK1
i13
bool
nS1
i13
for(iX2
root.GetParamCount(),a=0;a<b;++a){c9
tmp=lG1
root
lD
a),c53;if(tmp.cI)tC1
cI=true;if(tmp
eH==false)tK1=true;tP1
tmp.cI)nS1=true;}
if(tK1&&!nS1)result
eH
i13}
return
result;}
xG1
n62
lM1&tG3
lM1&tree,const
yW2&synth,const
nX1&lK2){for(iX2
iT,a=0;a<b;++a){lM1&leaf=xI2;iG1
lT2;xH2
nX1::const_iterator
i=lK2.nW3
i!=lK2.end();++i){if(i->eQ3
leaf.GetHash())y81
const
c63
i->nF2
size_t
score=occ.GetCSEscore();lM1&candidate=i->nG2
if(cC2
candidate))y81
if(leaf.xT2<occ.MinimumDepth())y81
if(score<2)y81
if(lG1
tG3
leaf)eH==false)continue
nS2
if(n62
tG3
leaf,synth,lK2
iF1;}
nX2
xG1
tL1
lM1&nU3,lM1&expr){for
iT1
nU3
lD
a)iA
expr
iF1;for
iT1
tL1
nU3
lD
a),expr
iF1
l81
false;}
xG1
GoodMomentForCSE(lM1&nU3,lM1&expr){if(nU3
nE==cIf
nZ2
true;for
iT1
nU3
lD
a)iA
expr
iF1;size_t
tX2=0;for
iT1
tL1
nU3
lD
a),expr))++tX2
l81
tX2!=1;}
}
iO2
FPoptimizer_CodeTree{yV1
size_t
yK2::SynthCommonSubExpressions(yV2
lP1
const{size_t
stacktop_before
t13
GetStackTop();nX1
lK2;FindTreeCounts(lK2,*this,lM2);
#ifdef DEBUG_SUBSTITUTIONS_CSE
DumpHashes(*this);
#endif
for(;;){size_t
yI2=0;iG1
lT2;for(iG1
j,i=lK2.nW3
i!=lK2.end();i=j){j=i;++j;const
c63
i->nF2
size_t
score=occ.GetCSEscore();lM1&tree=i->nG2
#ifdef DEBUG_SUBSTITUTIONS_CSE
std::cout<<"Score "
<<score<<":\n"
;DumpTreeWithIndent(tree);
#endif
if(cC2
tree))xV
if(tree.xT2<occ.MinimumDepth())xV
if(score<2)xV
if(lG1*this,tree)eH==false)xV
if(n62*this,tree,synth,lK2)){y81}
if(!GoodMomentForCSE(*this
n72
xV
score*=tree.xT2;if(score>yI2){yI2=score;lT2=i;}
}
if(yI2<=0)break;const
c63
lT2->nF2
lM1&tree=lT2->nG2
#ifdef DEBUG_SUBSTITUTIONS_CSE
std::cout<<tZ3"Common Subexpression:"
;xE3
x8(tree)lN1"\n"
;
#endif
int
y01=occ.NeedsSinCos()yJ
tY2,tZ2;if(y01){tY2
eT
tree);tY2
tU
cSin);tY2
x02;tZ2
eT
tree);tZ2
tU
cCos);tZ2
x02;if(cC2
tY2)||cC2
tZ2)){if(y01==2){lK2.erase(lT2);y81}
y01=0;}
}
tree.SynthesizeByteCode(synth,false);lK2.erase(lT2);
#ifdef DEBUG_SUBSTITUTIONS_CSE
std::cout<<"Done with Common Subexpression:"
;xE3
x8(tree)lN1"\n"
;
#endif
if(y01){if(y01==2){tQ1
c71);}
lK1
cSinCos,1,2
eU3.yZ2
tY2,1
eU3.yZ2
tZ2,0);}
}
return
synth.x5
stacktop_before;}
}
#endif
#ifdef FP_SUPPORT_OPTIMIZER
yV1
lR1
x8
nH2
using
iO2
FPoptimizer_CodeTree;CopyOnWrite()yJ
tree;tree.GenerateFrom(mData->mByteCode,mData->mImmed,*mData);FPoptimizer_Optimize::ApplyGrammars(tree);yG<i02>c73;yG
x8
immed;size_t
stacktop_max=0;tree.SynthesizeByteCode(c73,immed,stacktop_max);if(mData->mStackSize!=stacktop_max){mData->mStackSize=i02(stacktop_max);
#if !defined(FP_USE_THREAD_SAFE_EVAL) && \
    !defined(FP_USE_THREAD_SAFE_EVAL_WITH_ALLOCA)
mData->mStack
nE3
stacktop_max);
#endif
}
mData->mByteCode.swap(c73);mData->mImmed.swap(immed);}
#ifdef FP_SUPPORT_MPFR_FLOAT_TYPE
n73<>lR1<MpfrFloat>nH2}
#endif
#ifdef FP_SUPPORT_GMP_INT_TYPE
n73<>lR1<GmpInt>nH2}
#endif
FUNCTIONPARSER_INSTANTIATE_TYPES
#endif

#endif