Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
02/01/10 08:52:32 (14 years ago)
Author:
gkronber
Message:

Created a specialized view for function library injectors which allows full configuration of the function library. #748 (FunctionLibraryView is empty)

Location:
trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/FunctionLibraryInjectors
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/FunctionLibraryInjectors/ArithmeticFunctionLibraryInjector.cs

    r2566 r2728  
    3232    public const string MAXTIMEOFFSET = "MaxTimeOffset";
    3333
    34     public const string DIFFERENTIALS_ALLOWED = "Differentials";
    35 
    3634    private int minTimeOffset;
    3735    private int maxTimeOffset;
    … …  
    4543      AddVariableInfo(new VariableInfo(MINTIMEOFFSET, "Minimal time offset for all features", typeof(IntData), VariableKind.In));
    4644      AddVariableInfo(new VariableInfo(MAXTIMEOFFSET, "Maximal time offset for all feature", typeof(IntData), VariableKind.In));
    47 
    48       AddVariable(DIFFERENTIALS_ALLOWED, false);
    49     }
    50 
    51     private void AddVariable(string name, bool allowed) {
    52       AddVariableInfo(new VariableInfo(name, name + " allowed", typeof(BoolData), Core.VariableKind.New));
    53       GetVariableInfo(name).Local = true;
    54       AddVariable(new Core.Variable(name, new BoolData(allowed)));
    5545    }
    5646
    … …  
    7767      Subtraction subtraction = new Subtraction();
    7868
    79       List<IFunction> doubleFunctions = new List<IFunction>();
    80       if (GetVariableValue<BoolData>(DIFFERENTIALS_ALLOWED, null, false).Data)
    81         doubleFunctions.Add(differential);
    82       doubleFunctions.Add(variable);
    83       doubleFunctions.Add(constant);
    84       doubleFunctions.Add(addition);
    85       doubleFunctions.Add(division);
    86       doubleFunctions.Add(multiplication);
    87       doubleFunctions.Add(subtraction);
     69      List<IFunction> doubleFunctions = new List<IFunction>() {
     70      differential, variable, constant, addition, division, multiplication, subtraction
     71      };
    8872
    8973      SetAllowedSubOperators(addition, doubleFunctions);
    … …  
    9276      SetAllowedSubOperators(subtraction, doubleFunctions);
    9377
    94       if (GetVariableValue<BoolData>(DIFFERENTIALS_ALLOWED, null, false).Data)
    95         functionLibrary.AddFunction(differential);
    96       functionLibrary.AddFunction(variable);
    97       functionLibrary.AddFunction(constant);
    98       functionLibrary.AddFunction(addition);
    99       functionLibrary.AddFunction(division);
    100       functionLibrary.AddFunction(multiplication);
    101       functionLibrary.AddFunction(subtraction);
     78      doubleFunctions.ForEach(fun => functionLibrary.AddFunction(fun));
    10279
    10380      variable.SetConstraints(minTimeOffset, maxTimeOffset);

  • trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/FunctionLibraryInjectors/DefaultFunctionLibraryInjector.cs

    r2566 r2728  
    3232    public const string MAXTIMEOFFSET = "MaxTimeOffset";
    3333
    34     public const string DIFFERENTIALS_ALLOWED = "Differentials";
    35     public const string VARIABLES_ALLOWED = "Variables";
    36     public const string CONSTANTS_ALLOWED = "Constants";
    37     public const string ADDITION_ALLOWED = "Addition";
    38     public const string AVERAGE_ALLOWED = "Average";
    39     public const string AND_ALLOWED = "And";
    40     public const string COSINUS_ALLOWED = "Cosinus";
    41     public const string DIVISION_ALLOWED = "Division";
    42     public const string EQUAL_ALLOWED = "Equal";
    43     public const string EXPONENTIAL_ALLOWED = "Exponential";
    44     public const string GREATERTHAN_ALLOWED = "GreaterThan";
    45     public const string IFTHENELSE_ALLOWED = "IfThenElse";
    46     public const string LESSTHAN_ALLOWED = "LessThan";
    47     public const string LOGARTIHM_ALLOWED = "Logarithm";
    48     public const string MULTIPLICATION_ALLOWED = "Multiplication";
    49     public const string NOT_ALLOWED = "Not";
    50     public const string POWER_ALLOWED = "Power";
    51     public const string OR_ALLOWED = "Or";
    52     public const string SIGNUM_ALLOWED = "Signum";
    53     public const string SINUS_ALLOWED = "Sinus";
    54     public const string SQRT_ALLOWED = "SquareRoot";
    55     public const string SUBTRACTION_ALLOWED = "Subtraction";
    56     public const string TANGENS_ALLOWED = "Tangens";
    57     public const string XOR_ALLOWED = "Xor";
    58 
    5934    private int minTimeOffset;
    6035    private int maxTimeOffset;
    6136
    6237    public override string Description {
    63       get { return @"Injects a configurable function library for regression and classification problems."; }
     38      get { return @"Injects a default function library for regression and classification problems."; }
    6439    }
    6540
    … …  
    6843      AddVariableInfo(new VariableInfo(MINTIMEOFFSET, "Minimal time offset for all features", typeof(IntData), VariableKind.In));
    6944      AddVariableInfo(new VariableInfo(MAXTIMEOFFSET, "Maximal time offset for all feature", typeof(IntData), VariableKind.In));
    70 
    71       AddVariable(DIFFERENTIALS_ALLOWED, false);
    72       AddVariable(VARIABLES_ALLOWED, true);
    73       AddVariable(CONSTANTS_ALLOWED, true);
    74       AddVariable(ADDITION_ALLOWED, true);
    75       AddVariable(AVERAGE_ALLOWED, false);
    76       AddVariable(AND_ALLOWED, true);
    77       AddVariable(COSINUS_ALLOWED, true);
    78       AddVariable(DIVISION_ALLOWED, true);
    79       AddVariable(EQUAL_ALLOWED, true);
    80       AddVariable(EXPONENTIAL_ALLOWED, true);
    81       AddVariable(GREATERTHAN_ALLOWED, true);
    82       AddVariable(IFTHENELSE_ALLOWED, true);
    83       AddVariable(LESSTHAN_ALLOWED, true);
    84       AddVariable(LOGARTIHM_ALLOWED, true);
    85       AddVariable(MULTIPLICATION_ALLOWED, true);
    86       AddVariable(NOT_ALLOWED, true);
    87       AddVariable(POWER_ALLOWED, true);
    88       AddVariable(OR_ALLOWED, true);
    89       AddVariable(SIGNUM_ALLOWED, true);
    90       AddVariable(SINUS_ALLOWED, true);
    91       AddVariable(SQRT_ALLOWED, true);
    92       AddVariable(SUBTRACTION_ALLOWED, true);
    93       AddVariable(TANGENS_ALLOWED, true);
    94       AddVariable(XOR_ALLOWED, false);
    95     }
    96 
    97     private void AddVariable(string name, bool allowed) {
    98       AddVariableInfo(new VariableInfo(name, name + " allowed", typeof(BoolData), Core.VariableKind.New));
    99       GetVariableInfo(name).Local = true;
    100       AddVariable(new Core.Variable(name, new BoolData(allowed)));
    10145    }
    10246
    … …  
    14185
    14286
    143       List<IFunction> booleanFunctions = new List<IFunction>();
    144       ConditionalAddFunction(AND_ALLOWED, and, booleanFunctions);
    145       ConditionalAddFunction(EQUAL_ALLOWED, equal, booleanFunctions);
    146       ConditionalAddFunction(GREATERTHAN_ALLOWED, greaterThan, booleanFunctions);
    147       ConditionalAddFunction(LESSTHAN_ALLOWED, lessThan, booleanFunctions);
    148       ConditionalAddFunction(NOT_ALLOWED, not, booleanFunctions);
    149       ConditionalAddFunction(OR_ALLOWED, or, booleanFunctions);
    150       ConditionalAddFunction(XOR_ALLOWED, xor, booleanFunctions);
     87      List<IFunction> booleanFunctions = new List<IFunction>() {
     88        and, equal, greaterThan, lessThan, not, or, xor
     89      };
    15190
    152       List<IFunction> doubleFunctions = new List<IFunction>();
    153       ConditionalAddFunction(DIFFERENTIALS_ALLOWED, differential, doubleFunctions);
    154       ConditionalAddFunction(VARIABLES_ALLOWED, variable, doubleFunctions);
    155       ConditionalAddFunction(CONSTANTS_ALLOWED, constant, doubleFunctions);
    156       ConditionalAddFunction(ADDITION_ALLOWED, addition, doubleFunctions);
    157       ConditionalAddFunction(AVERAGE_ALLOWED, average, doubleFunctions);
    158       ConditionalAddFunction(COSINUS_ALLOWED, cosinus, doubleFunctions);
    159       ConditionalAddFunction(DIVISION_ALLOWED, division, doubleFunctions);
    160       ConditionalAddFunction(EXPONENTIAL_ALLOWED, exponential, doubleFunctions);
    161       ConditionalAddFunction(IFTHENELSE_ALLOWED, ifThenElse, doubleFunctions);
    162       ConditionalAddFunction(LOGARTIHM_ALLOWED, logarithm, doubleFunctions);
    163       ConditionalAddFunction(MULTIPLICATION_ALLOWED, multiplication, doubleFunctions);
    164       ConditionalAddFunction(POWER_ALLOWED, power, doubleFunctions);
    165       ConditionalAddFunction(SIGNUM_ALLOWED, signum, doubleFunctions);
    166       ConditionalAddFunction(SINUS_ALLOWED, sinus, doubleFunctions);
    167       ConditionalAddFunction(SQRT_ALLOWED, sqrt, doubleFunctions);
    168       ConditionalAddFunction(SUBTRACTION_ALLOWED, subtraction, doubleFunctions);
    169       ConditionalAddFunction(TANGENS_ALLOWED, tangens, doubleFunctions);
     91
     92      List<IFunction> doubleFunctions = new List<IFunction>() {
     93        differential, variable, constant, addition, average, cosinus, division, exponential,
     94        ifThenElse, logarithm, multiplication, power, signum, sinus, sqrt, subtraction, tangens};
    17095
    17196      SetAllowedSubOperators(and, booleanFunctions);
    … …  
    193118      SetAllowedSubOperators(tangens, doubleFunctions);
    194119
    195       ConditionalAddOperator(DIFFERENTIALS_ALLOWED, functionLibrary, differential);
    196       ConditionalAddOperator(VARIABLES_ALLOWED, functionLibrary, variable);
    197       ConditionalAddOperator(CONSTANTS_ALLOWED, functionLibrary, constant);
    198       ConditionalAddOperator(ADDITION_ALLOWED, functionLibrary, addition);
    199       ConditionalAddOperator(AVERAGE_ALLOWED, functionLibrary, average);
    200       ConditionalAddOperator(AND_ALLOWED, functionLibrary, and);
    201       ConditionalAddOperator(COSINUS_ALLOWED, functionLibrary, cosinus);
    202       ConditionalAddOperator(DIVISION_ALLOWED, functionLibrary, division);
    203       ConditionalAddOperator(EQUAL_ALLOWED, functionLibrary, equal);
    204       ConditionalAddOperator(EXPONENTIAL_ALLOWED, functionLibrary, exponential);
    205       ConditionalAddOperator(GREATERTHAN_ALLOWED, functionLibrary, greaterThan);
    206       ConditionalAddOperator(IFTHENELSE_ALLOWED, functionLibrary, ifThenElse);
    207       ConditionalAddOperator(LESSTHAN_ALLOWED, functionLibrary, lessThan);
    208       ConditionalAddOperator(LOGARTIHM_ALLOWED, functionLibrary, logarithm);
    209       ConditionalAddOperator(MULTIPLICATION_ALLOWED, functionLibrary, multiplication);
    210       ConditionalAddOperator(NOT_ALLOWED, functionLibrary, not);
    211       ConditionalAddOperator(POWER_ALLOWED, functionLibrary, power);
    212       ConditionalAddOperator(OR_ALLOWED, functionLibrary, or);
    213       ConditionalAddOperator(SIGNUM_ALLOWED, functionLibrary, signum);
    214       ConditionalAddOperator(SINUS_ALLOWED, functionLibrary, sinus);
    215       ConditionalAddOperator(SQRT_ALLOWED, functionLibrary, sqrt);
    216       ConditionalAddOperator(SUBTRACTION_ALLOWED, functionLibrary, subtraction);
    217       ConditionalAddOperator(TANGENS_ALLOWED, functionLibrary, tangens);
    218       ConditionalAddOperator(XOR_ALLOWED, functionLibrary, xor);
     120      doubleFunctions.ForEach(fun => functionLibrary.AddFunction(fun));
     121      booleanFunctions.ForEach(fun => functionLibrary.AddFunction(fun));
    219122
    220123      variable.SetConstraints(minTimeOffset, maxTimeOffset);

  • trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/FunctionLibraryInjectors/SimpleFunctionLibraryInjector.cs

    r2675 r2728  
    3232    public const string MAXTIMEOFFSET = "MaxTimeOffset";
    3333
    34     public const string DIFFERENTIALS_ALLOWED = "Differentials";
    35 
    3634    private int minTimeOffset;
    3735    private int maxTimeOffset;
    … …  
    4543      AddVariableInfo(new VariableInfo(MINTIMEOFFSET, "Minimal time offset for all features", typeof(IntData), VariableKind.In));
    4644      AddVariableInfo(new VariableInfo(MAXTIMEOFFSET, "Maximal time offset for all feature", typeof(IntData), VariableKind.In));
    47 
    48       AddVariable(DIFFERENTIALS_ALLOWED, false);
    49     }
    50 
    51     private void AddVariable(string name, bool allowed) {
    52       AddVariableInfo(new VariableInfo(name, name + " allowed", typeof(BoolData), Core.VariableKind.New));
    53       GetVariableInfo(name).Local = true;
    54       AddVariable(new Core.Variable(name, new BoolData(allowed)));
    5545    }
    5646
    … …  
    6858    protected override FunctionLibrary CreateFunctionLibrary() {
    6959      return Create(
    70         GetVariableValue<BoolData>(DIFFERENTIALS_ALLOWED, null, false).Data,
    7160        minTimeOffset,
    7261        maxTimeOffset);
    7362    }
    7463
    75     public static FunctionLibrary Create(bool differentialAllowed, int minTimeOffset, int maxTimeOffset) {
     64    public static FunctionLibrary Create(int minTimeOffset, int maxTimeOffset) {
    7665      FunctionLibrary functionLibrary = new FunctionLibrary();
    7766
    … …  
    9180      Tangens tangens = new Tangens();
    9281
    93       List<IFunction> valueNodes = new List<IFunction>();
    94       if (differentialAllowed) valueNodes.Add(differential);
    95       valueNodes.Add(variable);
    96       valueNodes.Add(constant);
     82      List<IFunction> valueNodes = new List<IFunction>() {
     83        differential, variable, constant
     84      };
     85      List<IFunction> arithmeticFunctions = new List<IFunction>() {
     86      addition, division, multiplication, subtraction,
     87      };
    9788
    98       List<IFunction> arithmeticFunctions = new List<IFunction>();
    99       arithmeticFunctions.Add(addition);
    100       arithmeticFunctions.Add(division);
    101       arithmeticFunctions.Add(multiplication);
    102       arithmeticFunctions.Add(subtraction);
    103 
    104       List<IFunction> complexFunctions = new List<IFunction>();
    105       complexFunctions.Add(cosinus);
    106       complexFunctions.Add(exponential);
    107       complexFunctions.Add(logarithm);
    108       complexFunctions.Add(power);
    109       complexFunctions.Add(sinus);
    110       complexFunctions.Add(sqrt);
    111       complexFunctions.Add(tangens);
     89      List<IFunction> complexFunctions = new List<IFunction>() {
     90        cosinus, exponential, logarithm, power, sinus, sqrt, tangens
     91      };
    11292
    11393      List<IFunction> allFunctions = new List<IFunction>();
    … …  
    129109      SetAllowedSubOperators(tangens, valueNodes);
    130110
    131       if (differentialAllowed) functionLibrary.AddFunction(differential);
    132 
    133111      allFunctions.ForEach(x => functionLibrary.AddFunction(x));
    134112

  • trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/FunctionLibraryInjectors/UnconstrainedFunctionLibraryInjector.cs

    r2566 r2728  
    3232    public const string MAXTIMEOFFSET = "MaxTimeOffset";
    3333
    34     public const string DIFFERENTIALS_ALLOWED = "Differentials";
    35     public const string VARIABLES_ALLOWED = "Variables";
    36     public const string CONSTANTS_ALLOWED = "Constants";
    37     public const string ADDITION_ALLOWED = "Addition";
    38     public const string AVERAGE_ALLOWED = "Average";
    39     public const string AND_ALLOWED = "And";
    40     public const string COSINUS_ALLOWED = "Cosinus";
    41     public const string DIVISION_ALLOWED = "Division";
    42     public const string EQUAL_ALLOWED = "Equal";
    43     public const string EXPONENTIAL_ALLOWED = "Exponential";
    44     public const string GREATERTHAN_ALLOWED = "GreaterThan";
    45     public const string IFTHENELSE_ALLOWED = "IfThenElse";
    46     public const string LESSTHAN_ALLOWED = "LessThan";
    47     public const string LOGARTIHM_ALLOWED = "Logarithm";
    48     public const string MULTIPLICATION_ALLOWED = "Multiplication";
    49     public const string NOT_ALLOWED = "Not";
    50     public const string POWER_ALLOWED = "Power";
    51     public const string OR_ALLOWED = "Or";
    52     public const string SIGNUM_ALLOWED = "Signum";
    53     public const string SINUS_ALLOWED = "Sinus";
    54     public const string SQRT_ALLOWED = "SquareRoot";
    55     public const string SUBTRACTION_ALLOWED = "Subtraction";
    56     public const string TANGENS_ALLOWED = "Tangens";
    57     public const string XOR_ALLOWED = "Xor"; private int minTimeOffset;
     34    private int minTimeOffset;
    5835    private int maxTimeOffset;
    5936
    … …  
    6643      AddVariableInfo(new VariableInfo(MINTIMEOFFSET, "Minimal time offset for all features", typeof(IntData), VariableKind.In));
    6744      AddVariableInfo(new VariableInfo(MAXTIMEOFFSET, "Maximal time offset for all feature", typeof(IntData), VariableKind.In));
    68 
    69       AddVariable(DIFFERENTIALS_ALLOWED, false);
    70       AddVariable(VARIABLES_ALLOWED, true);
    71       AddVariable(CONSTANTS_ALLOWED, true);
    72       AddVariable(ADDITION_ALLOWED, true);
    73       AddVariable(AVERAGE_ALLOWED, false);
    74       AddVariable(AND_ALLOWED, true);
    75       AddVariable(COSINUS_ALLOWED, true);
    76       AddVariable(DIVISION_ALLOWED, true);
    77       AddVariable(EQUAL_ALLOWED, true);
    78       AddVariable(EXPONENTIAL_ALLOWED, true);
    79       AddVariable(GREATERTHAN_ALLOWED, true);
    80       AddVariable(IFTHENELSE_ALLOWED, true);
    81       AddVariable(LESSTHAN_ALLOWED, true);
    82       AddVariable(LOGARTIHM_ALLOWED, true);
    83       AddVariable(MULTIPLICATION_ALLOWED, true);
    84       AddVariable(NOT_ALLOWED, true);
    85       AddVariable(POWER_ALLOWED, true);
    86       AddVariable(OR_ALLOWED, true);
    87       AddVariable(SIGNUM_ALLOWED, true);
    88       AddVariable(SINUS_ALLOWED, true);
    89       AddVariable(SQRT_ALLOWED, true);
    90       AddVariable(SUBTRACTION_ALLOWED, true);
    91       AddVariable(TANGENS_ALLOWED, true);
    92       AddVariable(XOR_ALLOWED, false);
    93     }
    94 
    95     private void AddVariable(string name, bool allowed) {
    96       AddVariableInfo(new VariableInfo(name, name + " allowed", typeof(BoolData), Core.VariableKind.New));
    97       GetVariableInfo(name).Local = true;
    98       AddVariable(new Core.Variable(name, new BoolData(allowed)));
    9945    }
    10046
    … …  
    13884      Xor xor = new Xor();
    13985
    140       List<IFunction> doubleFunctions = new List<IFunction>();
    141       ConditionalAddFunction(DIFFERENTIALS_ALLOWED, differential, doubleFunctions);
    142       ConditionalAddFunction(VARIABLES_ALLOWED, variable, doubleFunctions);
    143       ConditionalAddFunction(CONSTANTS_ALLOWED, constant, doubleFunctions);
    144       ConditionalAddFunction(ADDITION_ALLOWED, addition, doubleFunctions);
    145       ConditionalAddFunction(AVERAGE_ALLOWED, average, doubleFunctions);
    146       ConditionalAddFunction(COSINUS_ALLOWED, cosinus, doubleFunctions);
    147       ConditionalAddFunction(DIVISION_ALLOWED, division, doubleFunctions);
    148       ConditionalAddFunction(EXPONENTIAL_ALLOWED, exponential, doubleFunctions);
    149       ConditionalAddFunction(IFTHENELSE_ALLOWED, ifThenElse, doubleFunctions);
    150       ConditionalAddFunction(LOGARTIHM_ALLOWED, logarithm, doubleFunctions);
    151       ConditionalAddFunction(MULTIPLICATION_ALLOWED, multiplication, doubleFunctions);
    152       ConditionalAddFunction(POWER_ALLOWED, power, doubleFunctions);
    153       ConditionalAddFunction(SIGNUM_ALLOWED, signum, doubleFunctions);
    154       ConditionalAddFunction(SINUS_ALLOWED, sinus, doubleFunctions);
    155       ConditionalAddFunction(SQRT_ALLOWED, sqrt, doubleFunctions);
    156       ConditionalAddFunction(SUBTRACTION_ALLOWED, subtraction, doubleFunctions);
    157       ConditionalAddFunction(TANGENS_ALLOWED, tangens, doubleFunctions);
    158       ConditionalAddFunction(AND_ALLOWED, and, doubleFunctions);
    159       ConditionalAddFunction(EQUAL_ALLOWED, equal, doubleFunctions);
    160       ConditionalAddFunction(GREATERTHAN_ALLOWED, greaterThan, doubleFunctions);
    161       ConditionalAddFunction(LESSTHAN_ALLOWED, lessThan, doubleFunctions);
    162       ConditionalAddFunction(NOT_ALLOWED, not, doubleFunctions);
    163       ConditionalAddFunction(OR_ALLOWED, or, doubleFunctions);
    164       ConditionalAddFunction(XOR_ALLOWED, xor, doubleFunctions);
    165 
     86      List<IFunction> doubleFunctions = new List<IFunction>() {
     87      differential, variable, constant, addition, average, cosinus, division, exponential, ifThenElse,logarithm, multiplication,
     88      power, signum, sinus, sqrt, subtraction, tangens, and, equal, greaterThan, lessThan, not, or, xor
     89      };
    16690
    16791      SetAllowedSubOperators(and, doubleFunctions);
    … …  
    187111      SetAllowedSubOperators(tangens, doubleFunctions);
    188112
    189       ConditionalAddOperator(DIFFERENTIALS_ALLOWED, functionLibrary, differential);
    190       ConditionalAddOperator(VARIABLES_ALLOWED, functionLibrary, variable);
    191       ConditionalAddOperator(CONSTANTS_ALLOWED, functionLibrary, constant);
    192       ConditionalAddOperator(ADDITION_ALLOWED, functionLibrary, addition);
    193       ConditionalAddOperator(AVERAGE_ALLOWED, functionLibrary, average);
    194       ConditionalAddOperator(AND_ALLOWED, functionLibrary, and);
    195       ConditionalAddOperator(COSINUS_ALLOWED, functionLibrary, cosinus);
    196       ConditionalAddOperator(DIVISION_ALLOWED, functionLibrary, division);
    197       ConditionalAddOperator(EQUAL_ALLOWED, functionLibrary, equal);
    198       ConditionalAddOperator(EXPONENTIAL_ALLOWED, functionLibrary, exponential);
    199       ConditionalAddOperator(GREATERTHAN_ALLOWED, functionLibrary, greaterThan);
    200       ConditionalAddOperator(IFTHENELSE_ALLOWED, functionLibrary, ifThenElse);
    201       ConditionalAddOperator(LESSTHAN_ALLOWED, functionLibrary, lessThan);
    202       ConditionalAddOperator(LOGARTIHM_ALLOWED, functionLibrary, logarithm);
    203       ConditionalAddOperator(MULTIPLICATION_ALLOWED, functionLibrary, multiplication);
    204       ConditionalAddOperator(NOT_ALLOWED, functionLibrary, not);
    205       ConditionalAddOperator(POWER_ALLOWED, functionLibrary, power);
    206       ConditionalAddOperator(OR_ALLOWED, functionLibrary, or);
    207       ConditionalAddOperator(SIGNUM_ALLOWED, functionLibrary, signum);
    208       ConditionalAddOperator(SINUS_ALLOWED, functionLibrary, sinus);
    209       ConditionalAddOperator(SQRT_ALLOWED, functionLibrary, sqrt);
    210       ConditionalAddOperator(SUBTRACTION_ALLOWED, functionLibrary, subtraction);
    211       ConditionalAddOperator(TANGENS_ALLOWED, functionLibrary, tangens);
    212       ConditionalAddOperator(XOR_ALLOWED, functionLibrary, xor);
     113      doubleFunctions.ForEach(fun => functionLibrary.AddFunction(fun));
    213114
    214115      variable.SetConstraints(minTimeOffset, maxTimeOffset);
Note: See TracChangeset for help on using the changeset viewer.