Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
02/15/11 13:36:45 (14 years ago)
Author:
gkronber
Message:

#1227 implemented test cases and transformation rules for root and power symbols.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/SymbolicSimplifier.cs

    r5461 r5465  
    4242    private Logarithm logSymbol = new Logarithm();
    4343    private Exponential expSymbol = new Exponential();
     44    private Root rootSymbol = new Root();
     45    private Power powSymbol = new Power();
    4446    private Sine sineSymbol = new Sine();
    4547    private Cosine cosineSymbol = new Cosine();
     
    122124    private bool IsExp(SymbolicExpressionTreeNode node) {
    123125      return node.Symbol is Exponential;
     126    }
     127    private bool IsRoot(SymbolicExpressionTreeNode node) {
     128      return node.Symbol is Root;
     129    }
     130    private bool IsPower(SymbolicExpressionTreeNode node) {
     131      return node.Symbol is Power;
    124132    }
    125133    // trigonometric
     
    195203      } else if (IsExp(original)) {
    196204        return SimplifyExp(original);
     205      } else if (IsRoot(original)) {
     206        return SimplifyRoot(original);
     207      } else if (IsPower(original)) {
     208        return SimplifyPower(original);
    197209      } else if (IsSine(original)) {
    198210        return SimplifySine(original);
     
    347359      return MakeLog(GetSimplifiedTree(original.SubTrees[0]));
    348360    }
    349 
     361    private SymbolicExpressionTreeNode SimplifyRoot(SymbolicExpressionTreeNode original) {
     362      return MakeRoot(GetSimplifiedTree(original.SubTrees[0]), GetSimplifiedTree(original.SubTrees[1]));
     363    }
     364
     365    private SymbolicExpressionTreeNode SimplifyPower(SymbolicExpressionTreeNode original) {
     366      return MakePower(GetSimplifiedTree(original.SubTrees[0]), GetSimplifiedTree(original.SubTrees[1]));
     367    }
    350368    #endregion
    351 
    352 
    353369
    354370    #region low level tree restructuring
     
    462478
    463479    private SymbolicExpressionTreeNode MakeSine(SymbolicExpressionTreeNode node) {
    464       // todo implement more transformation rules
    465480      if (IsConstant(node)) {
    466481        var constT = node as ConstantTreeNode;
     
    473488    }
    474489    private SymbolicExpressionTreeNode MakeTangent(SymbolicExpressionTreeNode node) {
    475       // todo implement more transformation rules
    476490      if (IsConstant(node)) {
    477491        var constT = node as ConstantTreeNode;
     
    484498    }
    485499    private SymbolicExpressionTreeNode MakeCosine(SymbolicExpressionTreeNode node) {
    486       // todo implement more transformation rules
    487500      if (IsConstant(node)) {
    488501        var constT = node as ConstantTreeNode;
     
    495508    }
    496509    private SymbolicExpressionTreeNode MakeExp(SymbolicExpressionTreeNode node) {
    497       // todo implement more transformation rules
    498510      if (IsConstant(node)) {
    499511        var constT = node as ConstantTreeNode;
     
    501513      } else if (IsLog(node)) {
    502514        return node.SubTrees[0];
     515      } else if (IsAddition(node)) {
     516        return node.SubTrees.Select(s => MakeExp(s)).Aggregate((s, t) => MakeProduct(s, t));
     517      } else if (IsSubtraction(node)) {
     518        return node.SubTrees.Select(s => MakeExp(s)).Aggregate((s, t) => MakeProduct(s, Negate(t)));
    503519      } else {
    504520        var expNode = expSymbol.CreateTreeNode();
     
    508524    }
    509525    private SymbolicExpressionTreeNode MakeLog(SymbolicExpressionTreeNode node) {
    510       // todo implement more transformation rules
    511526      if (IsConstant(node)) {
    512527        var constT = node as ConstantTreeNode;
     
    526541        logNode.AddSubTree(node);
    527542        return logNode;
     543      }
     544    }
     545    private SymbolicExpressionTreeNode MakeRoot(SymbolicExpressionTreeNode a, SymbolicExpressionTreeNode b) {
     546      if (IsConstant(a) && IsConstant(b)) {
     547        var constA = a as ConstantTreeNode;
     548        var constB = b as ConstantTreeNode;
     549        return MakeConstant(Math.Pow(constA.Value, 1.0 / Math.Round(constB.Value)));
     550      } else if (IsConstant(b)) {
     551        var constB = b as ConstantTreeNode;
     552        var constBValue = Math.Round(constB.Value);
     553        if (constBValue.IsAlmost(1.0)) {
     554          return a;
     555        } else if (constBValue.IsAlmost(0.0)) {
     556          return MakeConstant(1.0);
     557        } else if (constBValue.IsAlmost(-1.0)) {
     558          return MakeFraction(MakeConstant(1.0), a);
     559        } else if (constBValue < 0) {
     560          var rootNode = rootSymbol.CreateTreeNode();
     561          rootNode.AddSubTree(a);
     562          rootNode.AddSubTree(MakeConstant(-1.0 * constBValue));
     563          return MakeFraction(MakeConstant(1.0), rootNode);
     564        } else {
     565          var rootNode = rootSymbol.CreateTreeNode();
     566          rootNode.AddSubTree(a);
     567          rootNode.AddSubTree(MakeConstant(constBValue));
     568          return rootNode;
     569        }
     570      } else {
     571        var rootNode = rootSymbol.CreateTreeNode();
     572        rootNode.AddSubTree(a);
     573        rootNode.AddSubTree(b);
     574        return rootNode;
     575      }
     576    }
     577    private SymbolicExpressionTreeNode MakePower(SymbolicExpressionTreeNode a, SymbolicExpressionTreeNode b) {
     578      if (IsConstant(a) && IsConstant(b)) {
     579        var constA = a as ConstantTreeNode;
     580        var constB = b as ConstantTreeNode;
     581        return MakeConstant(Math.Pow(constA.Value, Math.Round(constB.Value)));
     582      } else if (IsConstant(b)) {
     583        var constB = b as ConstantTreeNode;
     584        double exponent = Math.Round(constB.Value);
     585        if (exponent.IsAlmost(0.0)) {
     586          return MakeConstant(1.0);
     587        } else if (exponent.IsAlmost(1.0)) {
     588          return a;
     589        } else if (exponent.IsAlmost(-1.0)) {
     590          return MakeFraction(MakeConstant(1.0), a);
     591        } else if (exponent < 0) {
     592          var powNode = powSymbol.CreateTreeNode();
     593          powNode.AddSubTree(a);
     594          powNode.AddSubTree(MakeConstant(-1.0 * exponent));
     595          return MakeFraction(MakeConstant(1.0), powNode);
     596        } else {
     597          var powNode = powSymbol.CreateTreeNode();
     598          powNode.AddSubTree(a);
     599          powNode.AddSubTree(MakeConstant(exponent));
     600          return powNode;
     601        }
     602      } else {
     603        var powNode = powSymbol.CreateTreeNode();
     604        powNode.AddSubTree(a);
     605        powNode.AddSubTree(b);
     606        return powNode;
    528607      }
    529608    }
Note: See TracChangeset for help on using the changeset viewer.