source: branches/HeuristicLab.Problems.GeneticProgramming.BloodGlucosePrediction/Grammar.cs @ 13865

using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Problems.GeneticProgramming.GlucosePrediction {
  [StorableClass]
  [Item("Blood glucose level forecast grammar", "See MedGEC Workshop at GECCO 2016")]
  public class Grammar : SymbolicExpressionGrammar {
    [StorableConstructor]
    protected Grammar(bool deserializing) : base(deserializing) { }
    protected Grammar(Grammar original, Cloner cloner) : base(original, cloner) { }

    public Grammar()
      : base("Blood glucose level forecast grammar", "See MedGEC Workshop at GECCO 2016") {
      Initialize();
    }

    public void Initialize() {
      var func = new SimpleSymbol("Func", "The root for the blood glucose forecasting model.", 3, 3);
      var exprGluc = new SimpleSymbol("ExprGluc", string.Empty, 1, 1);
      var exprIns = new SimpleSymbol("ExprIns", string.Empty, 1, 1);
      var exprCh = new SimpleSymbol("ExprCh", string.Empty, 1, 1);

      var predGlucData = new PredictedGlucoseVariableSymbol();
      var realGlucData = new RealGlucoseVariableSymbol();

      // operators for exprGluc
      var plusGluc = new SimpleSymbol("+", "+", 2, 2);
      var minusGluc = new SimpleSymbol("-", "-", 2, 2);
      var prodGluc = new SimpleSymbol("*", "*", 2, 2);
      var divGluc = new SimpleSymbol("/", "/", 2, 2);
      var expGluc = new SimpleSymbol("Exp", "Exp", 1, 1);
      var sinGluc = new SimpleSymbol("Sin", "Sin", 1, 1);
      var cosGluc = new SimpleSymbol("Cos", "Cos", 1, 1);
      var logGluc = new SimpleSymbol("Log", "Log", 1, 1);
      // var cteGluc = new CteSymbol();

      // operators for exprCh
      var plusCh = new SimpleSymbol("+Ch", "+", 2, 2);
      var minusCh = new SimpleSymbol("-Ch", "-", 2, 2);
      var prodCh = new SimpleSymbol("*Ch", "*", 2, 2);
      var divCh = new SimpleSymbol("/Ch", "/", 2, 2);
      var expCh = new SimpleSymbol("ExpCh", "Exp", 1, 1);
      var sinCh = new SimpleSymbol("SinCh", "Sin", 1, 1);
      var cosCh = new SimpleSymbol("CosCh", "Cos", 1, 1);
      var logCh = new SimpleSymbol("LogCh", "Log", 1, 1);
      var curvedChShape1 = new CurvedChVariableSymbol("CurvedCh1", "", 2, 5);
      var curvedChShape2 = new CurvedChVariableSymbol("CurvedCh2", "", 3, 3);
      var curvedChShape3 = new CurvedChVariableSymbol("CurvedCh3", "", 5, 2);
      // var cteCh = new CteSymbol();

      // operators for exprIns
      var plusIns = new SimpleSymbol("+Ins", "+", 2, 2);
      var minusIns = new SimpleSymbol("-Ins", "-", 2, 2);
      var prodIns = new SimpleSymbol("*Ins", "*", 2, 2);
      var divIns = new SimpleSymbol("/Ins", "/", 2, 2);
      var expIns = new SimpleSymbol("ExpIns", "Exp", 1, 1);
      var sinIns = new SimpleSymbol("SinIns", "Sin", 1, 1);
      var cosIns = new SimpleSymbol("CosIns", "Cos", 1, 1);
      var logIns = new SimpleSymbol("LogIns", "Log", 1, 1);
      var curvedInsShape1 = new CurvedInsVariableSymbol("CurvedIns1", "", 2, 5);
      var curvedInsShape2 = new CurvedInsVariableSymbol("CurvedIns2", "", 3, 3);
      var curvedInsShape3 = new CurvedInsVariableSymbol("CurvedIns3", "", 5, 2);
      var realInsVar = new RealInsulineVariableSymbol();
      // var cteCh = new CteSymbol();

      AddSymbol(func);
      AddSymbol(exprGluc);
      AddSymbol(exprIns);
      AddSymbol(exprCh);
      AddSymbol(predGlucData);
      AddSymbol(realGlucData);
      AddSymbol(plusGluc);
      AddSymbol(minusGluc);
      AddSymbol(prodGluc);
      AddSymbol(divGluc);
      AddSymbol(expGluc);
      AddSymbol(sinGluc);
      AddSymbol(cosGluc);
      AddSymbol(logGluc);

      AddSymbol(curvedChShape1);
      AddSymbol(curvedChShape2);
      AddSymbol(curvedChShape3);
      AddSymbol(plusCh);
      AddSymbol(minusCh);
      AddSymbol(prodCh);
      AddSymbol(divCh);
      AddSymbol(expCh);
      AddSymbol(sinCh);
      AddSymbol(cosCh);
      AddSymbol(logCh);

      AddSymbol(curvedInsShape1);
      AddSymbol(curvedInsShape2);
      AddSymbol(curvedInsShape3);
      AddSymbol(plusIns);
      AddSymbol(minusIns);
      AddSymbol(prodIns);
      AddSymbol(divIns);
      AddSymbol(expIns);
      AddSymbol(sinIns);
      AddSymbol(cosIns);
      AddSymbol(logIns);
      AddSymbol(realInsVar);

      // <func> ::= <exprgluc> + <exprch> - <exprins>
      AddAllowedChildSymbol(func, exprGluc, 0);
      AddAllowedChildSymbol(func, exprCh, 1);
      AddAllowedChildSymbol(func, exprIns, 2);

      /* # Glucose
      <exprgluc> ::= (<exprgluc> <op> <exprgluc>)
                    |<preop> (<exprgluc>)
                    |(<cte> <op> <exprgluc>)
                    |predictedData(k-<idxCurr2h>)
                    |realData(k-<idx2hOrMore>)
      */
      var opGlucSet = new Symbol[] { plusGluc, minusGluc, prodGluc, divGluc, expGluc, sinGluc, cosGluc, logGluc };
      foreach (var opGluc in opGlucSet) {
        AddAllowedChildSymbol(exprGluc, opGluc);
      }

      // <exprgluc> ::= (<exprgluc> <op> <exprgluc>)
      // <exprgluc> ::= (<cte> <op> <exprgluc>)
      foreach (var op in new Symbol[] { plusGluc, minusGluc, prodGluc, divGluc }) {
        AddAllowedChildSymbol(op, exprGluc, 0);
        // AddAllowedChildSymbol(op, cteGluc, 0); // cte is only allowed as first child
        AddAllowedChildSymbol(op, exprGluc, 1);
      }
      // <exprgluc> ::= <preop> (<exprgluc>)
      foreach (var op in new Symbol[] { expGluc, sinGluc, cosGluc, logGluc }) {
        AddAllowedChildSymbol(op, exprGluc, 0);
      }

      AddAllowedChildSymbol(exprGluc, predGlucData); // <exprgluc> ::= predictedData(k-<idxCurr2h>)
      AddAllowedChildSymbol(exprGluc, realGlucData); // <exprgluc> ::= realData(k-<idx2hOrMore>)


      /*
      # CH
      <exprch> ::= (<exprch> <op> <exprch>)
                    |<preop> (<exprch>)
                    |(<cte> <op> <exprch>)  
                    |(getPrevData(1,k,1) * <cte> * <curvedCH>)

      # CH in 2 (0.041,24), 3 (0.027,36) and 4 (0.02,48) hours with 3 shapes of beta:
      <curvedCH> ::= beta(0.041*Math.min(24,getPrevDataDistance(1,k,1)),2,5)
              |beta(0.041*Math.min(24,getPrevDataDistance(1,k,1)),3,3)
              |beta(0.041*Math.min(24,getPrevDataDistance(1,k,1)),5,2)
              |beta(0.027*Math.min(36,getPrevDataDistance(1,k,1)),2,5)
              |beta(0.027*Math.min(36,getPrevDataDistance(1,k,1)),3,3)
              |beta(0.027*Math.min(36,getPrevDataDistance(1,k,1)),5,2)
              |beta(0.02*Math.min(48,getPrevDataDistance(1,k,1)),2,5)
              |beta(0.02*Math.min(48,getPrevDataDistance(1,k,1)),3,3)
              |beta(0.02*Math.min(48,getPrevDataDistance(1,k,1)),5,2) 
      */
      var opChSet = new Symbol[] { plusCh, minusCh, prodCh, divCh, expCh, sinCh, cosCh, logCh };
      foreach (var opCh in opChSet) {
        AddAllowedChildSymbol(exprCh, opCh);
      }

      // <exprch> ::= (<exprch> <op> <exprch>)
      // <exprch> ::= (<cte> <op> <exprch>)
      foreach (var op in new Symbol[] { plusCh, minusCh, prodCh, divCh }) {
        AddAllowedChildSymbol(op, exprCh, 0);
        // AddAllowedChildSymbol(op, cteCh, 0); // cte is only allowed as first child
        AddAllowedChildSymbol(op, exprCh, 1);
      }
      // <exprch> ::= <preop> (<exprch>)
      foreach (var op in new Symbol[] { expCh, sinCh, cosCh, logCh }) {
        AddAllowedChildSymbol(op, exprCh, 0);
      }
      // <exprch> ::= (getPrevData(1,k,1) * <cte> * <curvedCH>)
      AddAllowedChildSymbol(exprCh, curvedChShape1);
      AddAllowedChildSymbol(exprCh, curvedChShape2);
      AddAllowedChildSymbol(exprCh, curvedChShape3);

      /*
       # Insulin:
      ## Sum of insulins in past 2h minus the peak
      ## Curve for the peak in past 2h
      <exprins> ::= (<exprins> <op> <exprins>)
        |<preop> (<exprins>)
        |(<cte> <op> <exprins>)   
        |getVariable(2,k-<idx>)
        |(getSumOfValues(24,k,2) - getMaxValue(24,k,2) <op> (getMaxValue(24,k,2) <op> <curvedINS>))

      # INS in 2 (0.041,24), 3 (0.027,36) and 4 (0.02,48) hours with 3 shapes of beta:
      <curvedINS> ::= beta(0.041*Math.min(24,getMaxValueDistance(24,k,2)),2,5)
              |beta(0.041*Math.min(24,getMaxValueDistance(24,k,2)),3,3)
              |beta(0.041*Math.min(24,getMaxValueDistance(24,k,2)),5,2)
              |beta(0.027*Math.min(36,getMaxValueDistance(36,k,2)),2,5)
              |beta(0.027*Math.min(36,getMaxValueDistance(36,k,2)),3,3)
              |beta(0.027*Math.min(36,getMaxValueDistance(36,k,2)),5,2)
              |beta(0.02*Math.min(48,getMaxValueDistance(48,k,2)),2,5)
              |beta(0.02*Math.min(48,getMaxValueDistance(48,k,2)),3,3)
              |beta(0.02*Math.min(48,getMaxValueDistance(48,k,2)),5,2)

      */
      var opInsSet = new Symbol[] { plusIns, minusIns, prodIns, divIns, expIns, sinIns, cosIns, logIns };
      foreach (var opIns in opInsSet) {
        AddAllowedChildSymbol(exprIns, opIns);
      }

      // <exprins> ::= (<exprins> <op> <exprins>)
      // <exprins> ::= (<cte> <op> <exprins>)   
      foreach (var op in new Symbol[] { plusIns, minusIns, prodIns, divIns }) {
        AddAllowedChildSymbol(op, exprIns, 0);
        // AddAllowedChildSymbol(op, cteIns, 0); // cte is only allowed as first child
        AddAllowedChildSymbol(op, exprIns, 1);
      }
      // <exprins> ::= <preop> (<exprins>)
      foreach (var op in new Symbol[] { expIns, sinIns, cosIns, logIns }) {
        AddAllowedChildSymbol(op, exprIns, 0);
      }

      // <exprIns> ::= getVariable(2,k-<idx>)
      AddAllowedChildSymbol(exprIns, realInsVar);

      AddAllowedChildSymbol(exprIns, curvedInsShape1);
      AddAllowedChildSymbol(exprIns, curvedInsShape2);
      AddAllowedChildSymbol(exprIns, curvedInsShape3);

      // root is func
      AddAllowedChildSymbol(StartSymbol, func);
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new Grammar(this, cloner);
    }
  }
}