Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
12/08/18 08:11:48 (6 years ago)
Author:
gkronber
Message:

#2915: merged all changes from branch to trunk

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk

  • trunk/HeuristicLab.Problems.DataAnalysis.Symbolic

  • trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/BatchOperations.cs

    r16293 r16356  
    8989        a[i] = Math.Sqrt(b[i]);
    9090    }
     91
     92    public static void Cube(double[] a, double[] b) {
     93      for (int i = 0; i < BATCHSIZE; ++i)
     94        a[i] = Math.Pow(b[i], 3d);
     95    }
     96
     97    public static void CubeRoot(double[] a, double[] b) {
     98      for (int i = 0; i < BATCHSIZE; ++i)
     99        a[i] = Math.Pow(b[i], 1d / 3d);
     100    }
     101
     102    public static void Absolute(double[] a, double[] b) {
     103      for (int i = 0; i < BATCHSIZE; ++i)
     104        a[i] = Math.Abs(b[i]);
     105    }
     106
     107    public static void AnalyticQuotient(double[] a, double[] b) {
     108      for (int i = 0; i < BATCHSIZE; ++i)
     109        a[i] = a[i] / Math.Sqrt(1d + b[i] * b[i]);
     110    }
    91111  }
    92112}

  • trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs

    r15583 r16356  
    4646    public const byte OR = 14;
    4747    public const byte NOT = 15;
    48     public const byte XOR = 45;
    4948
    5049
    … …  
    8382    public const byte Erf = 43;
    8483    public const byte Bessel = 44;
     84    public const byte XOR = 45;
    8585    public const byte FactorVariable = 46;
    8686    public const byte BinaryFactorVariable = 47;
     87    public const byte Absolute = 48;
     88    public const byte AnalyticalQuotient = 49;
     89    public const byte Cube = 50;
     90    public const byte CubeRoot = 51;
    8791
    8892
    … …  
    113117      { typeof(Power),OpCodes.Power},
    114118      { typeof(Root),OpCodes.Root},
    115       { typeof(TimeLag), OpCodes.TimeLag}, 
     119      { typeof(TimeLag), OpCodes.TimeLag},
    116120      { typeof(Integral), OpCodes.Integral},
    117121      { typeof(Derivative), OpCodes.Derivative},
    … …  
    135139      { typeof(Bessel), OpCodes.Bessel},
    136140      { typeof(FactorVariable), OpCodes.FactorVariable },
    137       { typeof(BinaryFactorVariable), OpCodes.BinaryFactorVariable }
     141      { typeof(BinaryFactorVariable), OpCodes.BinaryFactorVariable },
     142      { typeof(Absolute), OpCodes.Absolute },
     143      { typeof(AnalyticalQuotient), OpCodes.AnalyticalQuotient },
     144      { typeof(Cube), OpCodes.Cube },
     145      { typeof(CubeRoot), OpCodes.CubeRoot }
    138146    };
    139147

  • trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs

    r15583 r16356  
    4141
    4242    #region method info for the commonly called functions
     43    private static readonly MethodInfo Abs = typeof(Math).GetMethod("Abs", new[] { typeof(double) });
    4344    private static readonly MethodInfo Sin = typeof(Math).GetMethod("Sin", new[] { typeof(double) });
    4445    private static readonly MethodInfo Cos = typeof(Math).GetMethod("Cos", new[] { typeof(double) });
    … …  
    207208            return Expression.Divide(result, Expression.Constant((double)node.SubtreeCount));
    208209          }
     210        case OpCodes.Absolute: {
     211            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
     212            return Expression.Call(Abs, arg);
     213          }
    209214        case OpCodes.Cos: {
    210215            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    … …  
    222227            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    223228            return Expression.Power(arg, Expression.Constant(2.0));
     229          }
     230        case OpCodes.Cube: {
     231            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
     232            return Expression.Power(arg, Expression.Constant(3.0));
    224233          }
    225234        case OpCodes.Power: {
    … …  
    231240            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    232241            return Expression.Call(Sqrt, arg);
     242          }
     243        case OpCodes.CubeRoot: {
     244            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
     245            return Expression.Power(arg, Expression.Constant(1.0 / 3.0));
    233246          }
    234247        case OpCodes.Root: {
    … …  
    493506                Expression.Assign(result, Expression.Call(Bessel, arg))),
    494507              result);
     508          }
     509        case OpCodes.AnalyticalQuotient: {
     510            var x1 = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
     511            var x2 = MakeExpr(node.GetSubtree(1), variableIndices, row, columns);
     512            return Expression.Divide(x1,
     513              Expression.Call(Sqrt,
     514              Expression.Add(
     515                Expression.Constant(1.0),
     516                Expression.Multiply(x2, x2))));
    495517          }
    496518        case OpCodes.IfThenElse: {

  • trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs

    r16301 r16356  
    111111
    112112          case OpCodes.Root: {
    113               Root(instr.buf, code[c].buf);
     113              Load(instr.buf, code[c].buf);
     114              Root(instr.buf, code[c + 1].buf);
    114115              break;
    115116            }
    … …  
    120121            }
    121122
     123          case OpCodes.Cube: {
     124              Cube(instr.buf, code[c].buf);
     125              break;
     126            }
     127          case OpCodes.CubeRoot: {
     128              CubeRoot(instr.buf, code[c].buf);
     129              break;
     130            }
     131
    122132          case OpCodes.Power: {
    123               Pow(instr.buf, code[c].buf);
     133              Load(instr.buf, code[c].buf);
     134              Pow(instr.buf, code[c + 1].buf);
    124135              break;
    125136            }
    … …  
    147158          case OpCodes.Tan: {
    148159              Tan(instr.buf, code[c].buf);
     160              break;
     161            }
     162
     163          case OpCodes.Absolute: {
     164              Absolute(instr.buf, code[c].buf);
     165              break;
     166            }
     167
     168          case OpCodes.AnalyticalQuotient: {
     169              Load(instr.buf, code[c].buf);
     170              AnalyticQuotient(instr.buf, code[c + 1].buf);
    149171              break;
    150172            }
    … …  
    172194      var remainingRows = rows.Length % BATCHSIZE;
    173195      var roundedTotal = rows.Length - remainingRows;
     196
     197      // TODO: evaluated solutions are not counted
    174198
    175199      var result = new double[rows.Length];

  • trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs

    r15583 r16356  
    5050    private static MethodInfo round = typeof(Math).GetMethod("Round", new Type[] { typeof(double) });
    5151    private static MethodInfo sqrt = typeof(Math).GetMethod("Sqrt", new Type[] { typeof(double) });
     52    private static MethodInfo abs = typeof(Math).GetMethod("Abs", new Type[] { typeof(double) });
    5253
    5354    private static MethodInfo airyA = thisType.GetMethod("AiryA", new Type[] { typeof(double) });
    … …  
    264265            return;
    265266          }
     267        case OpCodes.Absolute: {
     268            CompileInstructions(il, state, ds);
     269            il.Emit(System.Reflection.Emit.OpCodes.Call, abs);
     270            return;
     271          }
    266272        case OpCodes.Cos: {
    267273            CompileInstructions(il, state, ds);
    … …  
    311317            return;
    312318          }
     319        case OpCodes.Cube: {
     320            CompileInstructions(il, state, ds);
     321            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 3.0);
     322            il.Emit(System.Reflection.Emit.OpCodes.Call, power);
     323            return;
     324          }
    313325        case OpCodes.SquareRoot: {
    314326            CompileInstructions(il, state, ds);
    … …  
    316328            return;
    317329          }
     330        case OpCodes.CubeRoot: {
     331            CompileInstructions(il, state, ds);
     332            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0 / 3.0);
     333            il.Emit(System.Reflection.Emit.OpCodes.Call, power);
     334            return;
     335          }
    318336        case OpCodes.AiryA: {
    319337            CompileInstructions(il, state, ds);
    … …  
    389407            CompileInstructions(il, state, ds);
    390408            il.Emit(System.Reflection.Emit.OpCodes.Call, sinIntegral);
     409            return;
     410          }
     411        case OpCodes.AnalyticalQuotient: {
     412            CompileInstructions(il, state, ds); // x1
     413            CompileInstructions(il, state, ds); // x2
     414
     415            il.Emit(System.Reflection.Emit.OpCodes.Dup);
     416            il.Emit(System.Reflection.Emit.OpCodes.Mul); // x2*x2
     417            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0);
     418            il.Emit(System.Reflection.Emit.OpCodes.Mul); // 1+x2*x2
     419            il.Emit(System.Reflection.Emit.OpCodes.Call, sqrt);
     420            il.Emit(System.Reflection.Emit.OpCodes.Div);
    391421            return;
    392422          }

  • trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs

    r15583 r16356  
    203203            return sum / currentInstr.nArguments;
    204204          }
     205        case OpCodes.Absolute: {
     206            return Math.Abs(Evaluate(dataset, ref row, state));
     207          }
    205208        case OpCodes.Cos: {
    206209            return Math.Cos(Evaluate(dataset, ref row, state));
    … …  
    214217        case OpCodes.Square: {
    215218            return Math.Pow(Evaluate(dataset, ref row, state), 2);
     219          }
     220        case OpCodes.Cube: {
     221            return Math.Pow(Evaluate(dataset, ref row, state), 3);
    216222          }
    217223        case OpCodes.Power: {
    … …  
    223229            return Math.Sqrt(Evaluate(dataset, ref row, state));
    224230          }
     231        case OpCodes.CubeRoot: {
     232            return Math.Pow(Evaluate(dataset, ref row, state), 1.0 / 3.0);
     233          }
    225234        case OpCodes.Root: {
    226235            double x = Evaluate(dataset, ref row, state);
    … …  
    340349            if (double.IsNaN(x)) return double.NaN;
    341350            else return alglib.besseli0(x);
     351          }
     352
     353        case OpCodes.AnalyticalQuotient: {
     354            var x1 = Evaluate(dataset, ref row, state);
     355            var x2 = Evaluate(dataset, ref row, state);
     356            return x1 / Math.Pow(1 + x2 * x2, 0.5);
    342357          }
    343358        case OpCodes.IfThenElse: {

  • trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs

    r15583 r16356  
    215215          if (instr.nArguments == 1) p = 1.0 / p;
    216216          instr.value = p;
     217        } else if (instr.opCode == OpCodes.AnalyticalQuotient) {
     218          var x1 = code[instr.childIndex].value;
     219          var x2 = code[instr.childIndex + 1].value;
     220          instr.value = x1 / Math.Sqrt(1 + x2 * x2);
    217221        } else if (instr.opCode == OpCodes.Average) {
    218222          double s = code[instr.childIndex].value;
    … …  
    221225          }
    222226          instr.value = s / instr.nArguments;
     227        } else if (instr.opCode == OpCodes.Absolute) {
     228          instr.value = Math.Abs(code[instr.childIndex].value);
    223229        } else if (instr.opCode == OpCodes.Cos) {
    224230          instr.value = Math.Cos(code[instr.childIndex].value);
    … …  
    229235        } else if (instr.opCode == OpCodes.Square) {
    230236          instr.value = Math.Pow(code[instr.childIndex].value, 2);
     237        } else if (instr.opCode == OpCodes.Cube) {
     238          instr.value = Math.Pow(code[instr.childIndex].value, 3);
    231239        } else if (instr.opCode == OpCodes.Power) {
    232240          double x = code[instr.childIndex].value;
    … …  
    235243        } else if (instr.opCode == OpCodes.SquareRoot) {
    236244          instr.value = Math.Sqrt(code[instr.childIndex].value);
     245        } else if (instr.opCode == OpCodes.CubeRoot) {
     246          instr.value = Math.Pow(code[instr.childIndex].value, 1.0 / 3.0);
    237247        } else if (instr.opCode == OpCodes.Root) {
    238248          double x = code[instr.childIndex].value;
Note: See TracChangeset for help on using the changeset viewer.