/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.commons.nabla.forward;
  
  import org.apache.commons.math3.analysis.UnivariateFunction;
  import org.apache.commons.math3.analysis.differentiation.DerivativeStructure;
  import org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction;
  import org.apache.commons.math3.util.FastMath;
  import org.apache.commons.nabla.AbstractMathTest;
  import org.junit.Assert;
  import org.junit.Test;
  
  public class ForwardModeDifferentiatorTest extends AbstractMathTest {
  
      @Test
      public void testSingleCall() {
          checkReference(new ReferenceFunction() {
              public double value(double t) { return FastMath.cos(t); }
              public double firstDerivative(double t) { return -FastMath.sin(t); }
          }, 0, 2 * FastMath.PI, 20, 2.0e-16);
      }
  
      @Test
      public void testEmbeddedCalls() {
          checkReference(new ReferenceFunction() {
              public double value(double t) { return FastMath.exp(FastMath.sin(t)); }
              public double firstDerivative(double t) { return FastMath.cos(t) * FastMath.exp(FastMath.sin(t)); }
          }, 0.1, 10, 20, 2.0e-16);
      }
  
      @Test
      public void testParameterIndependent() {
          checkReference(new ReferenceFunction() {
              public double value(double t) { return 12; }
              public double firstDerivative(double t) { return 0; }
          }, 0.1, 5, 20, 1.0e-20);
      }
  
      @Test
      public void testSimpleExpression() {
          checkReference(new ReferenceFunction() {
              public double value(double t) { return 1.0 / t; }
              public double firstDerivative(double t) { return -1 / (t * t); }
          }, 0.1, 5, 20, 2.0e-14);
      }
  
      @Test
      public void testMul() {
          checkReference(new ReferenceFunction() {
              public double value(double t) { return t * t; }
              public double firstDerivative(double t) { return 2 * t; }
          }, 0.1, 5, 20, 1.0e-20);
      }
  
      @Test
      public void testPolynomialExpression() {
          checkReference(new ReferenceFunction() {
              public double value(double t) { return (((4 * t + 2) * t + 1) * t - 2) * t + 5; }
              public double firstDerivative(double t) { return ((16 * t + 6) * t + 2) * t - 2; }
          }, 0.1, 5, 20, 3.0e-13);
      }
  
      @Test
      public void testNarrowing() {
          checkReference(new ReferenceFunction() {
              public double value(double t) { return t - (int) t; }
              public double firstDerivative(double t) { return 1; }
          }, 0.1, 5, 20, 1.0e-20);
      }
  
      @Test
      public void testLocalVariables() {
          checkReference(new ReferenceFunction() {
              public double value(double t) { double threeT = 3 * t; return threeT * threeT; }
              public double firstDerivative(double t) { return 18 * t; }
          }, -5, 5, 20, 2.0e-14);
      }
  
      @Test
      public void testLoopLdc() {
          checkReference(new ReferenceFunction() {
              public double value(double t) {
                  double result = 2.0;
                  for (int i = 0; i < 3; ++i) {
                      result *= t;
                 }
                 return result;
             }
             public double firstDerivative(double t) { return 6 * t * t; }
         }, -5, 5, 20, 2.0e-14);
     }
 
     @Test
     public void testLoopDcons() {
         checkReference(new ReferenceFunction() {
             public double value(double t) {
                 double result = 1.0;
                 for (int i = 0; i < 3; ++i) {
                     result *= t;
                 }
                 return result;
             }
             public double firstDerivative(double t) { return 3 * t * t; }
         }, -5, 5, 20, 8.0e-15);
     }
 
     @Test
     public void testPartialDerivatives() throws Exception {
         PartialFunction function = new PartialFunction(1);
 
         final UnivariateDifferentiableFunction derivative = new
                 ForwardModeDifferentiator().differentiate(function);
         DerivativeStructure t = new DerivativeStructure(1, 1, 0, 1.0);
         Assert.assertEquals(3, derivative.value(t).getPartialDerivative(1), 1.0e-20);
         Assert.assertEquals(2, derivative.value(t).getValue(), 1.0e-20);
         function.setX(2);
         Assert.assertEquals(4, derivative.value(t).getPartialDerivative(1), 1.0e-20);
         Assert.assertEquals(3, derivative.value(t).getValue(), 1.0e-20);
     }
 
     public class PartialFunction implements UnivariateFunction {
         private double x;
         public PartialFunction(double x) {
             this.x = x;
         }
         public void setX(double x) {
             this.x = x;
         }
         public double getX() {
             return x;
         }
         public double value(double y) {
             return x * y + y * y;
         }
     }
 
 }