예제 #1
0
 public static void plot(Monitor monitor, OctaveEngine octave) {
   octave.eval(toOctaveString("time", "robustness", monitor));
   octave.eval(
       "plot(time, robustness, ';"
           + monitor.getProperty().toString().replace("[", "{[").replace("]", "]}")
           + ";');drawnow();");
 }
예제 #2
0
 /** @throws Exception */
 public void testOctaveScalar() throws Exception {
   final OctaveObject i1 = Octave.scalar(42);
   final OctaveEngine octave = new OctaveEngineFactory().getScriptEngine();
   octave.put("i", i1);
   final OctaveDouble i2 = octave.get(OctaveDouble.class, "i");
   assertEquals(i1, i2);
   octave.close();
 }
예제 #3
0
  /** Test that we can get and set globals */
  public void testOctaveGlobal() {
    final OctaveEngine octave = new OctaveEngineFactory().getScriptEngine();

    octave.eval("global x");
    octave.put("x", Octave.scalar(42.0));

    final OctaveDouble x = octave.get(OctaveDouble.class, "x");
    assertEquals(42.0, x.get(1));

    octave.close();
  }
예제 #4
0
 /** @throws Exception */
 public void testOctaveGet() throws Exception {
   final OctaveEngine octave = new OctaveEngineFactory().getScriptEngine();
   octave.eval("m=[1 2;3 4];");
   final OctaveDouble m = octave.get(OctaveDouble.class, "m");
   assertEquals(
       ""
           + //
           "# name: m\n"
           + //
           "# type: matrix\n"
           + //
           "# rows: 2\n"
           + //
           "# columns: 2\n"
           + //
           " 1.0 2.0\n"
           + //
           " 3.0 4.0\n" //
       ,
       OctaveIO.toText(m, "m"));
   octave.close();
 }
예제 #5
0
 public static void plotRecursively(Monitor monitor, OctaveEngine octaveEngine) {
   List<Monitor> monitors = new ArrayList<>();
   monitors.add(monitor);
   for (int i = 0; i < monitors.size(); i++) {
     monitors.addAll(monitors.get(i).getSubmonitors());
   }
   int sqrt = (int) Math.ceil(Math.sqrt(monitors.size()));
   int index = 1;
   for (Monitor m : monitors) {
     octaveEngine.eval("subplot(" + sqrt + ", " + sqrt + ", " + index + ");");
     plot(m, octaveEngine);
     index++;
   }
 }
예제 #6
0
 /** @throws Exception */
 public void testOctaveSetExecGet() throws Exception {
   final double[] numbers = {1, 2, 3, 4, 5, 6};
   final OctaveEngine octave = new OctaveEngineFactory().getScriptEngine();
   final OctaveDouble in = new OctaveDouble(numbers, 2, 3);
   octave.put("in", in);
   octave.eval("out=in;");
   final OctaveDouble out = octave.get(OctaveDouble.class, "out");
   assertEquals(OctaveIO.toText(in), OctaveIO.toText(out));
   octave.eval("slicerow=in(2,:); slicecol=in(:,2);");
   final OctaveDouble slicerow = octave.get(OctaveDouble.class, "slicerow");
   final OctaveDouble slicecol = octave.get(OctaveDouble.class, "slicecol");
   assertEquals(2.0, slicerow.get(1, 1));
   assertEquals(4.0, slicerow.get(1, 2));
   assertEquals(6.0, slicerow.get(1, 3));
   assertEquals(3.0, slicecol.get(1, 1));
   assertEquals(4.0, slicecol.get(2, 1));
   octave.close();
 }
예제 #7
0
 /** Test */
 public void testOctave3dMatrix() {
   final OctaveDouble matrix3d = new OctaveDouble(3, 4, 2);
   matrix3d.set(42.0, 1, 3, 2);
   matrix3d.set(-1.0, 3, 1, 1);
   final OctaveEngine octave = new OctaveEngineFactory().getScriptEngine();
   octave.put("matrix3d", matrix3d);
   octave.eval("x1 = matrix3d(:,:,1);");
   octave.eval("x2 = matrix3d(:,:,2);");
   octave.eval("x3 = matrix3d(:,3,:);");
   octave.eval("x4 = matrix3d(3,:,:);");
   final OctaveDouble x1 = octave.get(OctaveDouble.class, "x1");
   final OctaveDouble x2 = octave.get(OctaveDouble.class, "x2");
   final OctaveDouble x3 = octave.get(OctaveDouble.class, "x3");
   final OctaveDouble x4 = octave.get(OctaveDouble.class, "x4");
   octave.close();
   assertEquals(0.0, x1.get(1, 3));
   assertEquals(-1.0, x1.get(3, 1));
   assertEquals(42.0, x2.get(1, 3));
   assertEquals(0.0, x2.get(3, 1));
   assertEquals(42.0, x3.get(1, 1, 2));
   assertEquals(-1.0, x4.get(1, 1, 1));
 }
예제 #8
0
  /** Test */
  public void testOctaveNdMatrix() {
    final OctaveEngine octave = new OctaveEngineFactory().getScriptEngine();
    final TreeMap<String, OctaveObject> vars = new TreeMap<String, OctaveObject>();
    final double[] bigdata = new double[2 * 3 * 4];
    for (int idx = 0; idx < bigdata.length; idx++) {
      bigdata[idx] = idx + 1.0;
    }
    final double[] data2d = {1.0, 2.0, 3.0, 5.0, 8.0, 13.0};
    final double[] datascalar = {42.0};
    vars.put("bigmatrix", new OctaveDouble(bigdata, 1, 2, 3, 4));
    vars.put("matrix2d", new OctaveDouble(data2d, 2, 3));
    vars.put("matrixscalar", new OctaveDouble(datascalar, 1, 1));
    vars.put("matrixzero", new OctaveDouble(0, 0, 0, 0));
    vars.put("matrixzero2d", new OctaveDouble(0, 0));
    octave.putAll(vars);
    final OctaveDouble matrixzero = octave.get(OctaveDouble.class, "matrixzero");
    final OctaveDouble matrix2d = octave.get(OctaveDouble.class, "matrix2d");
    final OctaveDouble bigmatrix = octave.get(OctaveDouble.class, "bigmatrix");
    final OctaveDouble matrixzero2d = octave.get(OctaveDouble.class, "matrixzero2d");
    final OctaveDouble matrixscalar = octave.get(OctaveDouble.class, "matrixscalar");
    assertEquals(matrixzero, vars.get("matrixzero"));
    assertEquals(matrixzero2d, vars.get("matrixzero2d"));
    assertEquals(matrixscalar, vars.get("matrixscalar"));
    assertEquals(matrix2d, vars.get("matrix2d"));
    assertEquals(bigmatrix, vars.get("bigmatrix"));
    octave.close();

    assertEquals(
        ""
            + //
            "# name: matrixzero2d\n"
            + //
            "# type: matrix\n"
            + //
            "# rows: 0\n"
            + //
            "# columns: 0\n" //
        ,
        OctaveIO.toText(matrixzero2d, "matrixzero2d"));

    assertEquals(
        ""
            + //
            "# name: matrixzero\n"
            + //
            "# type: matrix\n"
            + //
            "# ndims: 4\n"
            + //
            " 0 0 0 0\n" //
        ,
        OctaveIO.toText(matrixzero, "matrixzero"));

    assertEquals(
        ""
            + //
            "# name: matrixscalar\n"
            + //
            "# type: scalar\n"
            + //
            "42.0\n" //
        ,
        OctaveIO.toText(matrixscalar, "matrixscalar"));

    assertEquals(
        ""
            + //
            "# name: matrix2d\n"
            + //
            "# type: matrix\n"
            + //
            "# rows: 2\n"
            + //
            "# columns: 3\n"
            + //
            " 1.0 3.0 8.0\n"
            + //
            " 2.0 5.0 13.0\n" //
        ,
        OctaveIO.toText(matrix2d, "matrix2d"));

    assertEquals(
        ""
            + //
            "# name: bigmatrix\n"
            + //
            "# type: matrix\n"
            + //
            "# ndims: 4\n"
            + //
            " 1 2 3 4\n"
            + //
            " 1.0\n"
            + //
            " 2.0\n"
            + //
            " 3.0\n"
            + //
            " 4.0\n"
            + //
            " 5.0\n"
            + //
            " 6.0\n"
            + //
            " 7.0\n"
            + //
            " 8.0\n"
            + //
            " 9.0\n"
            + //
            " 10.0\n"
            + //
            " 11.0\n"
            + //
            " 12.0\n"
            + //
            " 13.0\n"
            + //
            " 14.0\n"
            + //
            " 15.0\n"
            + //
            " 16.0\n"
            + //
            " 17.0\n"
            + //
            " 18.0\n"
            + //
            " 19.0\n"
            + //
            " 20.0\n"
            + //
            " 21.0\n"
            + //
            " 22.0\n"
            + //
            " 23.0\n"
            + //
            " 24.0\n" //
        ,
        OctaveIO.toText(bigmatrix, "bigmatrix"));
  }
예제 #9
0
  /**
   * Test how the system handles save of Inf and NaN
   *
   * @throws Exception
   */
  public void testOctaveSaveNanInf() throws Exception {
    final StringWriter stderr = new StringWriter();
    final OctaveEngine octave = new OctaveEngineFactory().getScriptEngine();
    octave.setErrorWriter(stderr);

    octave.eval("ok=1;");
    final OctaveDouble okOne = Octave.scalar(1);
    OctaveDouble ok;

    octave.eval("xnan=[NaN 0];");
    ok = octave.get(OctaveDouble.class, "ok");
    assertEquals(okOne, ok);
    final OctaveDouble xnan = octave.get(OctaveDouble.class, "xnan");
    assertEquals(Double.NaN, xnan.get(1, 1));
    assertEquals(Double.valueOf(0), xnan.get(1, 2));
    ok = octave.get(OctaveDouble.class, "ok");
    assertEquals(okOne, ok);

    octave.eval("xinf=[Inf -Inf];");
    ok = octave.get(OctaveDouble.class, "ok");
    assertEquals(okOne, ok);
    final OctaveDouble xinf = octave.get(OctaveDouble.class, "xinf");
    assertEquals(Double.POSITIVE_INFINITY, xinf.get(1, 1));
    assertEquals(Double.NEGATIVE_INFINITY, xinf.get(1, 2));
    ok = octave.get(OctaveDouble.class, "ok");
    assertEquals(okOne, ok);

    octave.close();
    stderr.close();
    assertEquals("", stderr.toString()); // No warning when saving matrix with NaN/Inf
  }