Examples of ca.nengo.math.Function

ca.nengo.math.Function

A mathematical function from an n-D space to a 1-D space. For simplicity we always map to a 1-D space, and model maps to n-D spaces with n Functions.

Instances of Function are immutable once they are created (ie their parameters do not change over time).
@author Bryan Tripp

      reset(false);
//      Plotter.plot(output, "simulation "+i);
      rt[i] = getRefreactoryTime(Vm[i]);
    }


    Function result = fitter.fit(current, Vm);
//    Plotter.plot(result, 0, .1f, 60, "current -> Vm");
//    Plotter.plot(current, rt, "current -> rt");
    return result;
  }

View Full Code Here


  /*
   * Test method for 'ca.nengo.math.impl.DefaultFunctionInterpreter.registerFunction(String, Function)'
   */
  public void testRegisterFunction() {
    Function c = new ConstantFunction(2, 1f);
    DefaultFunctionInterpreter interpreter = new DefaultFunctionInterpreter();
    interpreter.registerFunction("const", c);
    PostfixFunction f = (PostfixFunction) interpreter.parse("const(x0, x1)", 2);
    List<Serializable> l = f.getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));

View Full Code Here

   * Test method for 'ca.nengo.math.impl.DefaultFunctionInterpreter.parse(String, int)'
   */
  public void testParse() {
    float tolerance = .0001f;
    DefaultFunctionInterpreter interpreter = new DefaultFunctionInterpreter();
    Function f = null;
    List<Serializable> l = null;
    
    // basic binary cases ...
    f = interpreter.parse("x0 + x1", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals("+", l.get(2).toString());
    TestUtil.assertClose(2f, f.map(new float[]{1f, 1f}), tolerance);
    
    f = interpreter.parse("x0 - x1", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals("-", l.get(2).toString());
    TestUtil.assertClose(0f, f.map(new float[]{1f, 1f}), tolerance);
    
    f = interpreter.parse("x0 * x1", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals("*", l.get(2).toString());
    TestUtil.assertClose(1f, f.map(new float[]{1f, 1f}), tolerance);
    
    f = interpreter.parse("x0 / x1", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals("/", l.get(2).toString());
    TestUtil.assertClose(.5f, f.map(new float[]{1f, 2f}), tolerance);
    
    f = interpreter.parse("x0 ^ x1", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals("^", l.get(2).toString());
    TestUtil.assertClose(4f, f.map(new float[]{2f, 2f}), tolerance);
    
    f = interpreter.parse("x0 < x1", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals("<", l.get(2).toString());
    TestUtil.assertClose(1f, f.map(new float[]{0f, 1f}), tolerance);
    TestUtil.assertClose(0f, f.map(new float[]{1f, 0f}), tolerance);
    
    f = interpreter.parse("x0 > x1", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals(">", l.get(2).toString());
    TestUtil.assertClose(0f, f.map(new float[]{0f, 1f}), tolerance);
    TestUtil.assertClose(1f, f.map(new float[]{1f, 0f}), tolerance);
    
    f = interpreter.parse("x0 & x1", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals("&", l.get(2).toString());
    TestUtil.assertClose(1f, f.map(new float[]{1f, 1f}), tolerance);
    TestUtil.assertClose(0f, f.map(new float[]{0f, 1f}), tolerance);
    
    f = interpreter.parse("x0 | x1", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals("|", l.get(2).toString());
    TestUtil.assertClose(0f, f.map(new float[]{0f, 0f}), tolerance);
    TestUtil.assertClose(1f, f.map(new float[]{0f, 1f}), tolerance);
    
    f = interpreter.parse("x0|x1", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals("|", l.get(2).toString());
    
    f = interpreter.parse("x0| x1", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals("|", l.get(2).toString());
    
    f = interpreter.parse("x0 |x1", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals("|", l.get(2).toString());
    
    f = interpreter.parse("x0 % x1", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals("%", l.get(2).toString());
    TestUtil.assertClose(0f, f.map(new float[]{10f, 2f}), tolerance);
    TestUtil.assertClose(1f, f.map(new float[]{10f, 3f}), tolerance);
    
    // basic unary cases ...  
    f = interpreter.parse("x0", 1);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    TestUtil.assertClose(1f, f.map(new float[]{1f}), tolerance);
    
    f = interpreter.parse("-x0", 1);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals("~", l.get(1).toString());
    TestUtil.assertClose(-1f, f.map(new float[]{1f}), tolerance);
    
    f = interpreter.parse("!x0", 1);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals("!", l.get(1).toString());
    TestUtil.assertClose(0f, f.map(new float[]{1f}), tolerance);
    TestUtil.assertClose(1f, f.map(new float[]{0f}), tolerance);
    
    f = interpreter.parse("! x0", 1);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals("!", l.get(1).toString());
    
    //precedence ... 
    f = interpreter.parse("x0 + x1 + x2", 3);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals("+", l.get(2).toString());
    assertEquals(Integer.valueOf(2), l.get(3));
    assertEquals("+", l.get(4).toString());
    TestUtil.assertClose(6f, f.map(new float[]{1f, 2f, 3f}), tolerance);
    
    f = interpreter.parse("x0 * x1 + x2", 3);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals("*", l.get(2).toString());
    assertEquals(Integer.valueOf(2), l.get(3));
    assertEquals("+", l.get(4).toString());
    TestUtil.assertClose(5f, f.map(new float[]{1f, 2f, 3f}), tolerance);
    
    f = interpreter.parse("x0 / x1 - x2", 3);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals("/", l.get(2).toString());
    assertEquals(Integer.valueOf(2), l.get(3));
    assertEquals("-", l.get(4).toString());
    TestUtil.assertClose(-2.5f, f.map(new float[]{1f, 2f, 3f}), tolerance);
    
    f = interpreter.parse("x0 + x1 * x2", 3);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals(Integer.valueOf(2), l.get(2));
    assertEquals("*", l.get(3).toString());
    assertEquals("+", l.get(4).toString());
    TestUtil.assertClose(7f, f.map(new float[]{1f, 2f, 3f}), tolerance);
    
    f = interpreter.parse("x0 + x1 * -x2", 3);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals(Integer.valueOf(2), l.get(2));
    assertEquals("~", l.get(3).toString());
    assertEquals("*", l.get(4).toString());
    assertEquals("+", l.get(5).toString());
    TestUtil.assertClose(-5f, f.map(new float[]{1f, 2f, 3f}), tolerance);
    
    f = interpreter.parse("x0 * x1 ^ x2", 3);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals(Integer.valueOf(2), l.get(2));
    assertEquals("^", l.get(3).toString());
    assertEquals("*", l.get(4).toString());
    TestUtil.assertClose(8f, f.map(new float[]{1f, 2f, 3f}), tolerance);
    
    f = interpreter.parse("x0 * x1 ^ x2 & x3", 4);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals(Integer.valueOf(2), l.get(2));
    assertEquals("^", l.get(3).toString());
    assertEquals("*", l.get(4).toString());
    assertEquals(Integer.valueOf(3), l.get(5));
    assertEquals("&", l.get(6).toString());
    TestUtil.assertClose(1f, f.map(new float[]{1f, 2f, 3f, 1f}), tolerance);
    
    //brackets ... 
    f = interpreter.parse("x0 * (x1 + x2)", 3);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals(Integer.valueOf(2), l.get(2));
    assertEquals("+", l.get(3).toString());
    assertEquals("*", l.get(4).toString());
    TestUtil.assertClose(5f, f.map(new float[]{1f, 2f, 3f}), tolerance);
    
    f = interpreter.parse("(x0 * x1) ^ (x2 & x3)", 4);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals("*", l.get(2).toString());
    assertEquals(Integer.valueOf(2), l.get(3));
    assertEquals(Integer.valueOf(3), l.get(4));
    assertEquals("&", l.get(5).toString());
    assertEquals("^", l.get(6).toString());
    TestUtil.assertClose(2f, f.map(new float[]{1f, 2f, 3f, 4f}), tolerance);
    
    f = interpreter.parse("x0 ^ (x1 * (x2 + x3))", 4);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals(Integer.valueOf(2), l.get(2));
    assertEquals(Integer.valueOf(3), l.get(3));
    assertEquals("+", l.get(4).toString());
    assertEquals("*", l.get(5).toString());
    assertEquals("^", l.get(6).toString());
    TestUtil.assertClose(16384f, f.map(new float[]{2f, 2f, 3f, 4f}), tolerance);
    
    //functions ... 
    f = interpreter.parse("x0 + sin(x1)", 4);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertTrue(l.get(2) instanceof SimpleFunctions.Sin);
    assertEquals("+", l.get(3).toString());
    TestUtil.assertClose(2f, f.map(new float[]{2f, (float) Math.PI, 1f, 1f}), tolerance);
    
    f = interpreter.parse("x0 + sin(x1 + x2)", 4);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertEquals(Integer.valueOf(1), l.get(1));
    assertEquals(Integer.valueOf(2), l.get(2));
    assertEquals("+", l.get(3).toString());
    assertTrue(l.get(4) instanceof SimpleFunctions.Sin);
    assertEquals("+", l.get(5).toString());
    TestUtil.assertClose(2f, f.map(new float[]{2f, (float) Math.PI / 2f, (float) Math.PI / 2f, 1f}), tolerance);
    
    //constants ... 
    f = interpreter.parse("1.1", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertTrue(l.get(0) instanceof Float);
    TestUtil.assertClose(1.1f, ((Float) l.get(0)).floatValue(), .0001f);
    TestUtil.assertClose(1.1f, f.map(new float[]{1f, 1f}), tolerance);
    
    f = interpreter.parse("x0 + 5", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertTrue(l.get(1) instanceof Float);
    TestUtil.assertClose(5f, ((Float) l.get(1)).floatValue(), .0001f);
    assertEquals("+", l.get(2).toString());
    TestUtil.assertClose(6f, f.map(new float[]{1f, 1f}), tolerance);
    
    f = interpreter.parse("x0 + 1.5", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertTrue(l.get(1) instanceof Float);
    TestUtil.assertClose(1.5f, ((Float) l.get(1)).floatValue(), .0001f);
    assertEquals("+", l.get(2).toString());
    TestUtil.assertClose(2.5f, f.map(new float[]{1f, 1f}), tolerance);
    
    f = interpreter.parse("x0 + 0.5", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertTrue(l.get(1) instanceof Float);
    TestUtil.assertClose(0.5f, ((Float) l.get(1)).floatValue(), .0001f);
    assertEquals("+", l.get(2).toString());
    TestUtil.assertClose(1.5f, f.map(new float[]{1f, 1f}), tolerance);
    
    f = interpreter.parse("x0 + .5", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertTrue(l.get(1) instanceof Float);
    TestUtil.assertClose(0.5f, ((Float) l.get(1)).floatValue(), .0001f);
    assertEquals("+", l.get(2).toString());
    TestUtil.assertClose(1.5f, f.map(new float[]{1f, 1f}), tolerance);
    
    f = interpreter.parse("x0 + pi", 2);
    l = ((PostfixFunction) f).getExpressionList();
    assertEquals(Integer.valueOf(0), l.get(0));
    assertTrue(l.get(1) instanceof Float);
    TestUtil.assertClose((float) Math.PI, ((Float) l.get(1)).floatValue(), .0001f);
    assertEquals("+", l.get(2).toString());
    TestUtil.assertClose(1f + (float) Math.PI, f.map(new float[]{1f, 1f}), tolerance);


    //dimension ... 
    f = interpreter.parse("x0", 5);
    assertEquals(5, f.getDimension());


    //don't need this -- dimension is now adjusted to suit expression
//    try {
//      interpreter.parse("x5", 1);
//      fail("Should have thrown exception due to index higher than dimension");
//    } catch (Exception e) {} //exception is expected
    
    //everything ... 
    f = interpreter.parse("2*pi + .5*x0 / sin((x1 + x2)^x3)", 4);
    l = ((PostfixFunction) f).getExpressionList();
    assertTrue(l.get(0) instanceof Float);
    TestUtil.assertClose(2f, ((Float) l.get(0)).floatValue(), .0001f);
    assertTrue(l.get(1) instanceof Float);
    TestUtil.assertClose((float) Math.PI, ((Float) l.get(1)).floatValue(), .0001f);
    assertEquals("*", l.get(2).toString());
    assertTrue(l.get(3) instanceof Float);
    TestUtil.assertClose(.5f, ((Float) l.get(3)).floatValue(), .0001f);
    assertEquals(Integer.valueOf(0), l.get(4));
    assertEquals("*", l.get(5).toString());
    assertEquals(Integer.valueOf(1), l.get(6));
    assertEquals(Integer.valueOf(2), l.get(7));
    assertEquals("+", l.get(8).toString());
    assertEquals(Integer.valueOf(3), l.get(9));
    assertEquals("^", l.get(10).toString());
    assertTrue(l.get(11) instanceof SimpleFunctions.Sin);    
    assertEquals("/", l.get(12).toString());
    assertEquals("+", l.get(13).toString());
    TestUtil.assertClose(2f * (float) Math.PI - 1 / .13235175f, f.map(new float[]{2f, 2f, 3f, 2f}), tolerance);
    
  }

View Full Code Here

   */
  public void testMap() throws StructuralException {
    //this is code that was giving Lloyd some trouble (not really a unit test) ...
    TimeSeries ts = new TimeSeries1DImpl(new float[]{ 0.0f, 0.5f, 1.0f},
        new float[]{0.0f, 0.5f, 1.0f}, Units.UNK);
    Function f = new TimeSeriesFunction(ts , 0);
//    FunctionInput input = new FunctionInput("input", new Function[]{f}, Units.UNK);


    //now for a little test
    TestUtil.assertClose(.2f, f.map(new float[]{.2f}), .00001f);
  }

View Full Code Here

    TestUtil.assertClose(.2f, f.map(new float[]{.2f}), .00001f);
  }


    //functional test
    public static void main(String[] args) {
        Function f = new SineFunction(10);
        TimeSeries series = TimeSeriesFunction.makeSeries(f, 0, .001f, 1, Units.UNK);
        Plotter.plot(f, 0, .001f, 1, "function output");
        Plotter.plot(series, "time series");


        Function f2 = new TimeSeriesFunction(series, 0);
        Plotter.plot(f2, 0, .0005f, 1, "derived function");
    }

View Full Code Here

    for (int i = 0; i < evalPoints.length; i++) {
      evalPoints[i] = new float[]{(float) i / (float) evalPoints.length};
    }
    
    //testing with eval points
    Function target = new FourierFunction(frequencies, amplitudes, phases);
    float[][] values = new float[frequencies.length][];
    for (int i = 0; i < frequencies.length; i++) {
      Function component = new FourierFunction(new float[]{frequencies[i]}, new float[]{1}, new float[]{phases[i]});
      values[i] = new float[evalPoints.length];
      for (int j = 0; j < evalPoints.length; j++) {
        values[i][j] = component.map(evalPoints[j]);
      }
    }
    
    WeightedCostApproximator.Factory factory = new WeightedCostApproximator.Factory(0f);
    LinearApproximator approximator = factory.getApproximator(evalPoints, values);
    float[] coefficients = approximator.findCoefficients(target);
    
    float approx;
    for (int j = 0; j < evalPoints.length; j++) {
      approx = 0f;
      for (int i = 0; i < frequencies.length; i++) {
        approx += coefficients[i] * values[i][j];
      }
      TestUtil.assertClose(approx, target.map(evalPoints[j]), 0.0001f);
    }
    
    //testing with eval signals
    TimeSeries1DImpl targetsig = (TimeSeries1DImpl)TimeSeriesFunction.makeSeries(new FourierFunction(frequencies, amplitudes, phases), 0.0f, 0.001f, 1.0f, Units.UNK);
    float[] times = targetsig.getTimes();
    float[][][] valuesig = new float[frequencies.length][1][];
    for (int i = 0; i < frequencies.length; i++) {
      Function component = new FourierFunction(new float[]{frequencies[i]}, new float[]{1}, new float[]{phases[i]});
      valuesig[i][0] = new float[times.length];
      for (int j = 0; j < times.length; j++) {
        valuesig[i][0][j] = component.map(new float[]{times[j]});
      }
    }
    float[][][] evalsigs = new float[1][1][];
    evalsigs[0][0] = times;
    factory = new WeightedCostApproximator.Factory(0f);

View Full Code Here

   */
    public float[] findCoefficients(Function target) {
    float[] result = new float[0];


    for (int i = 0; i < myDimensions.length; i++) {
      Function f = new FunctionWrapper(target, myDimensions[i]);
      float[] compCoeff = myComponents[i].findCoefficients(f);


      float[] newResult = new float[result.length + compCoeff.length];
      System.arraycopy(result, 0, newResult, 0, result.length);
      System.arraycopy(compCoeff, 0, newResult, result.length, compCoeff.length);

View Full Code Here

      values[2][i+99] = polys[4].map(evalPoints[i+99]);
    }
    comps[1] = new WeightedCostApproximator(evalPoints, values, new ConstantFunction(1,1f), 0f, -1);


    LinearApproximator approximator = new CompositeApproximator(comps, new int[][]{{0},{0}});
    Function target = new Polynomial(new float[]{3f,2f,-2f});
    float[] coefficients = approximator.findCoefficients(target);


    float approx = 0f;


    for (int j=0; j<evalPoints.length; j++) {

View Full Code Here

      int[] indepDims = new int[values.length];
      for (int i = 0; i < indepDims.length; i++) {
        indepDims[i] = (int) Math.floor((double) i / (double) nodesPerDim);
      }


      Function costWeight = new ConstantFunction(1, 1);
      return new IndependentDimensionApproximator(oneDimEvalPoints, values, indepDims, dimensions, costWeight, .1f);
    }

View Full Code Here

    public SpikeGenerator make() {
      float maxRate = myMaxRate.sample()[0];
      float intercept = myIntercept.sample()[0];
      float slope = maxRate / (1-intercept);
      float bias = - slope * intercept;
      Function line = new LinearFunction(new float[]{slope}, bias, myRectified);
      return new PoissonSpikeGenerator(line);
    }

View Full Code Here

0 1 2 3 4

TOP

Related Classes of ca.nengo.math.Function

ca.nengo.examples.IntegratorExample

ca.nengo.math.impl.CompositeApproximator

ca.nengo.math.impl.CompositeApproximatorTest

ca.nengo.math.impl.ConvolutionTest

ca.nengo.math.impl.DefaultFunctionInterpreterTest

ca.nengo.math.impl.FixedSignalFunctionTest

ca.nengo.math.impl.GradientDescentApproximatorTest

ca.nengo.math.impl.IndependentDimensionApproximator$Factory

ca.nengo.math.impl.IndependentDimensionApproximatorTest

ca.nengo.math.impl.LinearCurveFitterTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.