home | career | drupal | java | mac | mysql | perl | scala | uml | unix  

Java example source code file (FieldVector3DTest.java)

This example Java source code file (FieldVector3DTest.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

decimalformat, derivativestructure, dimensionmismatchexception, fieldvector3d, fieldvector3dtest, matharithmeticexception, numberformat, test, text, util, vector3d, well1024a

The FieldVector3DTest.java Java example source code

/*
 * 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.math3.geometry.euclidean.threed;

import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.text.NumberFormat;
import java.util.Locale;

import org.apache.commons.math3.analysis.differentiation.DerivativeStructure;
import org.apache.commons.math3.exception.DimensionMismatchException;
import org.apache.commons.math3.exception.MathArithmeticException;
import org.apache.commons.math3.random.Well1024a;
import org.apache.commons.math3.util.FastMath;
import org.apache.commons.math3.util.Precision;
import org.junit.Assert;
import org.junit.Test;

public class FieldVector3DTest {

    @Test
    public void testConstructors() throws DimensionMismatchException {
        double cosAlpha = 1 / 2.0;
        double sinAlpha = FastMath.sqrt(3) / 2.0;
        double cosDelta = FastMath.sqrt(2) / 2.0;
        double sinDelta = -FastMath.sqrt(2) / 2.0;
        FieldVector3D<DerivativeStructure> u = new FieldVector3D(2,
                new FieldVector3D<DerivativeStructure>(new DerivativeStructure(2, 1, 0,  FastMath.PI / 3),
                        new DerivativeStructure(2, 1, 1, -FastMath.PI / 4)));
        checkVector(u, 2 * cosAlpha * cosDelta, 2 * sinAlpha * cosDelta, 2 * sinDelta);
        Assert.assertEquals(-2 * sinAlpha * cosDelta, u.getX().getPartialDerivative(1, 0), 1.0e-12);
        Assert.assertEquals(+2 * cosAlpha * cosDelta, u.getY().getPartialDerivative(1, 0), 1.0e-12);
        Assert.assertEquals(0,                        u.getZ().getPartialDerivative(1, 0), 1.0e-12);
        Assert.assertEquals(-2 * cosAlpha * sinDelta, u.getX().getPartialDerivative(0, 1), 1.0e-12);
        Assert.assertEquals(-2 * sinAlpha * sinDelta, u.getY().getPartialDerivative(0, 1), 1.0e-12);
        Assert.assertEquals(2 * cosDelta,             u.getZ().getPartialDerivative(0, 1), 1.0e-12);

        checkVector(new FieldVector3D<DerivativeStructure>(2, createVector(1, 0,  0, 3)),
                                   2, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 2);
        checkVector(new FieldVector3D<DerivativeStructure>(new DerivativeStructure(4, 1, 3,  2.0),
                                   createVector(1, 0,  0, 4)),
                                   2, 0, 0, 2, 0, 0, 1, 0, 2, 0, 0, 0, 0, 2, 0);
        checkVector(new FieldVector3D<DerivativeStructure>(new DerivativeStructure(4, 1, 3,  2.0),
                                   new Vector3D(1, 0,  0)),
                                   2, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0);

        checkVector(new FieldVector3D<DerivativeStructure>(2, createVector(1, 0,  0, 3),
                                   -3, createVector(0, 0, -1, 3)),
                                   2, 0, 3, -1, 0, 0, 0, -1, 0, 0, 0, -1);
        checkVector(new FieldVector3D<DerivativeStructure>(new DerivativeStructure(4, 1, 3,  2.0),
                                   createVector(1, 0,  0, 4),
                                   new DerivativeStructure(4, 1, 3, -3.0),
                                   createVector(0, 0, -1, 4)),
                                   2, 0, 3, -1, 0, 0, 1, 0, -1, 0, 0, 0, 0, -1, -1);
        checkVector(new FieldVector3D<DerivativeStructure>(new DerivativeStructure(4, 1, 3,  2.0),
                                   new Vector3D(1, 0,  0),
                                   new DerivativeStructure(4, 1, 3, -3.0),
                                   new Vector3D(0, 0, -1)),
                                   2, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, -1);

        checkVector(new FieldVector3D<DerivativeStructure>(2, createVector(1, 0, 0, 3),
                                   5, createVector(0, 1, 0, 3),
                                   -3, createVector(0, 0, -1, 3)),
                                   2, 5, 3, 4, 0, 0, 0, 4, 0, 0, 0, 4);
        checkVector(new FieldVector3D<DerivativeStructure>(new DerivativeStructure(4, 1, 3,  2.0),
                                   createVector(1, 0,  0, 4),
                                   new DerivativeStructure(4, 1, 3,  5.0),
                                   createVector(0, 1,  0, 4),
                                   new DerivativeStructure(4, 1, 3, -3.0),
                                   createVector(0, 0, -1, 4)),
                                   2, 5, 3, 4, 0, 0, 1, 0, 4, 0, 1, 0, 0, 4, -1);
        checkVector(new FieldVector3D<DerivativeStructure>(new DerivativeStructure(4, 1, 3,  2.0),
                                   new Vector3D(1, 0,  0),
                                   new DerivativeStructure(4, 1, 3,  5.0),
                                   new Vector3D(0, 1,  0),
                                   new DerivativeStructure(4, 1, 3, -3.0),
                                   new Vector3D(0, 0, -1)),
                                   2, 5, 3, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, -1);

        checkVector(new FieldVector3D<DerivativeStructure>(2, createVector(1, 0, 0, 3),
                                   5, createVector(0, 1, 0, 3),
                                   5, createVector(0, -1, 0, 3),
                                   -3, createVector(0, 0, -1, 3)),
                                   2, 0, 3, 9, 0, 0, 0, 9, 0, 0, 0, 9);
        checkVector(new FieldVector3D<DerivativeStructure>(new DerivativeStructure(4, 1, 3,  2.0),
                                   createVector(1, 0,  0, 4),
                                   new DerivativeStructure(4, 1, 3,  5.0),
                                   createVector(0, 1,  0, 4),
                                   new DerivativeStructure(4, 1, 3,  5.0),
                                   createVector(0, -1,  0, 4),
                                   new DerivativeStructure(4, 1, 3, -3.0),
                                   createVector(0, 0, -1, 4)),
                                   2, 0, 3, 9, 0, 0, 1, 0, 9, 0, 0, 0, 0, 9, -1);
        checkVector(new FieldVector3D<DerivativeStructure>(new DerivativeStructure(4, 1, 3,  2.0),
                                   new Vector3D(1, 0,  0),
                                   new DerivativeStructure(4, 1, 3,  5.0),
                                   new Vector3D(0, 1,  0),
                                   new DerivativeStructure(4, 1, 3,  5.0),
                                   new Vector3D(0, -1,  0),
                                   new DerivativeStructure(4, 1, 3, -3.0),
                                   new Vector3D(0, 0, -1)),
                                   2, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, -1);

        checkVector(new FieldVector3D<DerivativeStructure>(new DerivativeStructure[] {
            new DerivativeStructure(3, 1, 2,  2),
            new DerivativeStructure(3, 1, 1,  5),
            new DerivativeStructure(3, 1, 0, -3)
        }),
        2, 5, -3, 0, 0, 1, 0, 1, 0, 1, 0, 0);

    }

    @Test
    public void testEquals() {
        FieldVector3D<DerivativeStructure> u1 = createVector(1, 2, 3, 3);
        FieldVector3D<DerivativeStructure> v  = createVector(1, 2, 3 + 10 * Precision.EPSILON, 3);
        Assert.assertTrue(u1.equals(u1));
        Assert.assertTrue(u1.equals(new FieldVector3D<DerivativeStructure>(new DerivativeStructure(3, 1, 0, 1.0),
                                                   new DerivativeStructure(3, 1, 1, 2.0),
                                                   new DerivativeStructure(3, 1, 2, 3.0))));
        Assert.assertFalse(u1.equals(new FieldVector3D<DerivativeStructure>(new DerivativeStructure(3, 1, 1.0),
                                                    new DerivativeStructure(3, 1, 1, 2.0),
                                                    new DerivativeStructure(3, 1, 2, 3.0))));
        Assert.assertFalse(u1.equals(new FieldVector3D<DerivativeStructure>(new DerivativeStructure(3, 1, 0, 1.0),
                                                    new DerivativeStructure(3, 1, 2.0),
                                                    new DerivativeStructure(3, 1, 2, 3.0))));
        Assert.assertFalse(u1.equals(new FieldVector3D<DerivativeStructure>(new DerivativeStructure(3, 1, 0, 1.0),
                                                    new DerivativeStructure(3, 1, 1, 2.0),
                                                    new DerivativeStructure(3, 1, 3.0))));
        Assert.assertFalse(u1.equals(v));
        Assert.assertFalse(u1.equals(u1.toVector3D()));
        Assert.assertTrue(createVector(0, Double.NaN, 0, 3).equals(createVector(0, 0, Double.NaN, 3)));
    }

    @Test
    public void testHash() {
        Assert.assertEquals(createVector(0, Double.NaN, 0, 3).hashCode(), createVector(0, 0, Double.NaN, 3).hashCode());
        FieldVector3D<DerivativeStructure> u = createVector(1, 2, 3, 3);
        FieldVector3D<DerivativeStructure> v = createVector(1, 2, 3 + 10 * Precision.EPSILON, 3);
        Assert.assertTrue(u.hashCode() != v.hashCode());
    }

    @Test
    public void testInfinite() {
        Assert.assertTrue(createVector(1, 1, Double.NEGATIVE_INFINITY, 3).isInfinite());
        Assert.assertTrue(createVector(1, Double.NEGATIVE_INFINITY, 1, 3).isInfinite());
        Assert.assertTrue(createVector(Double.NEGATIVE_INFINITY, 1, 1, 3).isInfinite());
        Assert.assertFalse(createVector(1, 1, 2, 3).isInfinite());
        Assert.assertFalse(createVector(1, Double.NaN, Double.NEGATIVE_INFINITY, 3).isInfinite());
    }

    @Test
    public void testNaN() {
        Assert.assertTrue(createVector(1, 1, Double.NaN, 3).isNaN());
        Assert.assertTrue(createVector(1, Double.NaN, 1, 3).isNaN());
        Assert.assertTrue(createVector(Double.NaN, 1, 1, 3).isNaN());
        Assert.assertFalse(createVector(1, 1, 2, 3).isNaN());
        Assert.assertFalse(createVector(1, 1, Double.NEGATIVE_INFINITY, 3).isNaN());
    }

    @Test
    public void testToString() {
        Assert.assertEquals("{3; 2; 1}", createVector(3, 2, 1, 3).toString());
        NumberFormat format = new DecimalFormat("0.000", new DecimalFormatSymbols(Locale.US));
        Assert.assertEquals("{3.000; 2.000; 1.000}", createVector(3, 2, 1, 3).toString(format));
    }

    @Test(expected=DimensionMismatchException.class)
    public void testWrongDimension() throws DimensionMismatchException {
        new FieldVector3D<DerivativeStructure>(new DerivativeStructure[] {
            new DerivativeStructure(3, 1, 0, 2),
            new DerivativeStructure(3, 1, 0, 5)
        });
    }

    @Test
    public void testCoordinates() {
        FieldVector3D<DerivativeStructure> v = createVector(1, 2, 3, 3);
        Assert.assertTrue(FastMath.abs(v.getX().getReal() - 1) < 1.0e-12);
        Assert.assertTrue(FastMath.abs(v.getY().getReal() - 2) < 1.0e-12);
        Assert.assertTrue(FastMath.abs(v.getZ().getReal() - 3) < 1.0e-12);
        DerivativeStructure[] coordinates = v.toArray();
        Assert.assertTrue(FastMath.abs(coordinates[0].getReal() - 1) < 1.0e-12);
        Assert.assertTrue(FastMath.abs(coordinates[1].getReal() - 2) < 1.0e-12);
        Assert.assertTrue(FastMath.abs(coordinates[2].getReal() - 3) < 1.0e-12);
    }

    @Test
    public void testNorm1() {
        Assert.assertEquals( 0.0, createVector(0, 0, 0, 3).getNorm1().getReal(), 0);
        Assert.assertEquals( 6.0, createVector(1, -2, 3, 3).getNorm1().getReal(), 0);
        Assert.assertEquals( 1.0, createVector(1, -2, 3, 3).getNorm1().getPartialDerivative(1, 0, 0), 0);
        Assert.assertEquals(-1.0, createVector(1, -2, 3, 3).getNorm1().getPartialDerivative(0, 1, 0), 0);
        Assert.assertEquals( 1.0, createVector(1, -2, 3, 3).getNorm1().getPartialDerivative(0, 0, 1), 0);
    }

    @Test
    public void testNorm() {
        double r = FastMath.sqrt(14);
        Assert.assertEquals(0.0, createVector(0, 0, 0, 3).getNorm().getReal(), 0);
        Assert.assertEquals(r, createVector(1, 2, 3, 3).getNorm().getReal(), 1.0e-12);
        Assert.assertEquals( 1.0 / r, createVector(1, 2, 3, 3).getNorm().getPartialDerivative(1, 0, 0), 0);
        Assert.assertEquals( 2.0 / r, createVector(1, 2, 3, 3).getNorm().getPartialDerivative(0, 1, 0), 0);
        Assert.assertEquals( 3.0 / r, createVector(1, 2, 3, 3).getNorm().getPartialDerivative(0, 0, 1), 0);
    }

    @Test
    public void testNormSq() {
        Assert.assertEquals(0.0, createVector(0, 0, 0, 3).getNormSq().getReal(), 0);
        Assert.assertEquals(14, createVector(1, 2, 3, 3).getNormSq().getReal(), 1.0e-12);
        Assert.assertEquals( 2, createVector(1, 2, 3, 3).getNormSq().getPartialDerivative(1, 0, 0), 0);
        Assert.assertEquals( 4, createVector(1, 2, 3, 3).getNormSq().getPartialDerivative(0, 1, 0), 0);
        Assert.assertEquals( 6, createVector(1, 2, 3, 3).getNormSq().getPartialDerivative(0, 0, 1), 0);
    }

    @Test
    public void testNormInf() {
        Assert.assertEquals( 0.0, createVector(0, 0, 0, 3).getNormInf().getReal(), 0);
        Assert.assertEquals( 3.0, createVector(1, -2, 3, 3).getNormInf().getReal(), 0);
        Assert.assertEquals( 0.0, createVector(1, -2, 3, 3).getNormInf().getPartialDerivative(1, 0, 0), 0);
        Assert.assertEquals( 0.0, createVector(1, -2, 3, 3).getNormInf().getPartialDerivative(0, 1, 0), 0);
        Assert.assertEquals( 1.0, createVector(1, -2, 3, 3).getNormInf().getPartialDerivative(0, 0, 1), 0);
        Assert.assertEquals( 3.0, createVector(2, -1, 3, 3).getNormInf().getReal(), 0);
        Assert.assertEquals( 0.0, createVector(2, -1, 3, 3).getNormInf().getPartialDerivative(1, 0, 0), 0);
        Assert.assertEquals( 0.0, createVector(2, -1, 3, 3).getNormInf().getPartialDerivative(0, 1, 0), 0);
        Assert.assertEquals( 1.0, createVector(2, -1, 3, 3).getNormInf().getPartialDerivative(0, 0, 1), 0);
        Assert.assertEquals( 3.0, createVector(1, -3, 2, 3).getNormInf().getReal(), 0);
        Assert.assertEquals( 0.0, createVector(1, -3, 2, 3).getNormInf().getPartialDerivative(1, 0, 0), 0);
        Assert.assertEquals(-1.0, createVector(1, -3, 2, 3).getNormInf().getPartialDerivative(0, 1, 0), 0);
        Assert.assertEquals( 0.0, createVector(1, -3, 2, 3).getNormInf().getPartialDerivative(0, 0, 1), 0);
        Assert.assertEquals( 3.0, createVector(2, -3, 1, 3).getNormInf().getReal(), 0);
        Assert.assertEquals( 0.0, createVector(2, -3, 1, 3).getNormInf().getPartialDerivative(1, 0, 0), 0);
        Assert.assertEquals(-1.0, createVector(2, -3, 1, 3).getNormInf().getPartialDerivative(0, 1, 0), 0);
        Assert.assertEquals( 0.0, createVector(2, -3, 1, 3).getNormInf().getPartialDerivative(0, 0, 1), 0);
        Assert.assertEquals( 3.0, createVector(3, -1, 2, 3).getNormInf().getReal(), 0);
        Assert.assertEquals( 1.0, createVector(3, -1, 2, 3).getNormInf().getPartialDerivative(1, 0, 0), 0);
        Assert.assertEquals( 0.0, createVector(3, -1, 2, 3).getNormInf().getPartialDerivative(0, 1, 0), 0);
        Assert.assertEquals( 0.0, createVector(3, -1, 2, 3).getNormInf().getPartialDerivative(0, 0, 1), 0);
        Assert.assertEquals( 3.0, createVector(3, -2, 1, 3).getNormInf().getReal(), 0);
        Assert.assertEquals( 1.0, createVector(3, -2, 1, 3).getNormInf().getPartialDerivative(1, 0, 0), 0);
        Assert.assertEquals( 0.0, createVector(3, -2, 1, 3).getNormInf().getPartialDerivative(0, 1, 0), 0);
        Assert.assertEquals( 0.0, createVector(3, -2, 1, 3).getNormInf().getPartialDerivative(0, 0, 1), 0);
    }

    @Test
    public void testDistance1() {
        FieldVector3D<DerivativeStructure> v1 = createVector(1, -2, 3, 3);
        FieldVector3D<DerivativeStructure> v2 = createVector(-4, 2, 0, 3);
        Assert.assertEquals(0.0, FieldVector3D.distance1(createVector(-1, 0, 0, 3), createVector(-1, 0, 0, 3)).getReal(), 0);
        DerivativeStructure distance = FieldVector3D.distance1(v1, v2);
        Assert.assertEquals(12.0, distance.getReal(), 1.0e-12);
        Assert.assertEquals(0, distance.getPartialDerivative(1, 0, 0), 1.0e-12);
        Assert.assertEquals(0, distance.getPartialDerivative(0, 1, 0), 1.0e-12);
        Assert.assertEquals(0, distance.getPartialDerivative(0, 0, 1), 1.0e-12);
        distance = FieldVector3D.distance1(v1, new Vector3D(-4, 2, 0));
        Assert.assertEquals(12.0, distance.getReal(), 1.0e-12);
        Assert.assertEquals( 1, distance.getPartialDerivative(1, 0, 0), 1.0e-12);
        Assert.assertEquals(-1, distance.getPartialDerivative(0, 1, 0), 1.0e-12);
        Assert.assertEquals( 1, distance.getPartialDerivative(0, 0, 1), 1.0e-12);
        distance = FieldVector3D.distance1(new Vector3D(-4, 2, 0), v1);
        Assert.assertEquals(12.0, distance.getReal(), 1.0e-12);
        Assert.assertEquals( 1, distance.getPartialDerivative(1, 0, 0), 1.0e-12);
        Assert.assertEquals(-1, distance.getPartialDerivative(0, 1, 0), 1.0e-12);
        Assert.assertEquals( 1, distance.getPartialDerivative(0, 0, 1), 1.0e-12);
    }

    @Test
    public void testDistance() {
        FieldVector3D<DerivativeStructure> v1 = createVector(1, -2, 3, 3);
        FieldVector3D<DerivativeStructure> v2 = createVector(-4, 2, 0, 3);
        Assert.assertEquals(0.0, FieldVector3D.distance(createVector(-1, 0, 0, 3), createVector(-1, 0, 0, 3)).getReal(), 0);
        DerivativeStructure distance = FieldVector3D.distance(v1, v2);
        Assert.assertEquals(FastMath.sqrt(50), distance.getReal(), 1.0e-12);
        Assert.assertEquals(0, distance.getPartialDerivative(1, 0, 0), 1.0e-12);
        Assert.assertEquals(0, distance.getPartialDerivative(0, 1, 0), 1.0e-12);
        Assert.assertEquals(0, distance.getPartialDerivative(0, 0, 1), 1.0e-12);
        distance = FieldVector3D.distance(v1, new Vector3D(-4, 2, 0));
        Assert.assertEquals(FastMath.sqrt(50), distance.getReal(), 1.0e-12);
        Assert.assertEquals( 5 / FastMath.sqrt(50), distance.getPartialDerivative(1, 0, 0), 1.0e-12);
        Assert.assertEquals(-4 / FastMath.sqrt(50), distance.getPartialDerivative(0, 1, 0), 1.0e-12);
        Assert.assertEquals( 3 / FastMath.sqrt(50), distance.getPartialDerivative(0, 0, 1), 1.0e-12);
        distance = FieldVector3D.distance(new Vector3D(-4, 2, 0), v1);
        Assert.assertEquals(FastMath.sqrt(50), distance.getReal(), 1.0e-12);
        Assert.assertEquals( 5 / FastMath.sqrt(50), distance.getPartialDerivative(1, 0, 0), 1.0e-12);
        Assert.assertEquals(-4 / FastMath.sqrt(50), distance.getPartialDerivative(0, 1, 0), 1.0e-12);
        Assert.assertEquals( 3 / FastMath.sqrt(50), distance.getPartialDerivative(0, 0, 1), 1.0e-12);
    }

    @Test
    public void testDistanceSq() {
        FieldVector3D<DerivativeStructure> v1 = createVector(1, -2, 3, 3);
        FieldVector3D<DerivativeStructure> v2 = createVector(-4, 2, 0, 3);
        Assert.assertEquals(0.0, FieldVector3D.distanceSq(createVector(-1, 0, 0, 3), createVector(-1, 0, 0, 3)).getReal(), 0);
        DerivativeStructure distanceSq = FieldVector3D.distanceSq(v1, v2);
        Assert.assertEquals(50.0, distanceSq.getReal(), 1.0e-12);
        Assert.assertEquals(0, distanceSq.getPartialDerivative(1, 0, 0), 1.0e-12);
        Assert.assertEquals(0, distanceSq.getPartialDerivative(0, 1, 0), 1.0e-12);
        Assert.assertEquals(0, distanceSq.getPartialDerivative(0, 0, 1), 1.0e-12);
        distanceSq = FieldVector3D.distanceSq(v1, new Vector3D(-4, 2, 0));
        Assert.assertEquals(50.0, distanceSq.getReal(), 1.0e-12);
        Assert.assertEquals(10, distanceSq.getPartialDerivative(1, 0, 0), 1.0e-12);
        Assert.assertEquals(-8, distanceSq.getPartialDerivative(0, 1, 0), 1.0e-12);
        Assert.assertEquals( 6, distanceSq.getPartialDerivative(0, 0, 1), 1.0e-12);
        distanceSq = FieldVector3D.distanceSq(new Vector3D(-4, 2, 0), v1);
        Assert.assertEquals(50.0, distanceSq.getReal(), 1.0e-12);
        Assert.assertEquals(10, distanceSq.getPartialDerivative(1, 0, 0), 1.0e-12);
        Assert.assertEquals(-8, distanceSq.getPartialDerivative(0, 1, 0), 1.0e-12);
        Assert.assertEquals( 6, distanceSq.getPartialDerivative(0, 0, 1), 1.0e-12);
  }

    @Test
    public void testDistanceInf() {
        FieldVector3D<DerivativeStructure> v1 = createVector(1, -2, 3, 3);
        FieldVector3D<DerivativeStructure> v2 = createVector(-4, 2, 0, 3);
        Assert.assertEquals(0.0, FieldVector3D.distanceInf(createVector(-1, 0, 0, 3), createVector(-1, 0, 0, 3)).getReal(), 0);
        DerivativeStructure distance = FieldVector3D.distanceInf(v1, v2);
        Assert.assertEquals(5.0, distance.getReal(), 1.0e-12);
        Assert.assertEquals(0, distance.getPartialDerivative(1, 0, 0), 1.0e-12);
        Assert.assertEquals(0, distance.getPartialDerivative(0, 1, 0), 1.0e-12);
        Assert.assertEquals(0, distance.getPartialDerivative(0, 0, 1), 1.0e-12);
        distance = FieldVector3D.distanceInf(v1, new Vector3D(-4, 2, 0));
        Assert.assertEquals(5.0, distance.getReal(), 1.0e-12);
        Assert.assertEquals(1, distance.getPartialDerivative(1, 0, 0), 1.0e-12);
        Assert.assertEquals(0, distance.getPartialDerivative(0, 1, 0), 1.0e-12);
        Assert.assertEquals(0, distance.getPartialDerivative(0, 0, 1), 1.0e-12);
        distance = FieldVector3D.distanceInf(new Vector3D(-4, 2, 0), v1);
        Assert.assertEquals(5.0, distance.getReal(), 1.0e-12);
        Assert.assertEquals(1, distance.getPartialDerivative(1, 0, 0), 1.0e-12);
        Assert.assertEquals(0, distance.getPartialDerivative(0, 1, 0), 1.0e-12);
        Assert.assertEquals(0, distance.getPartialDerivative(0, 0, 1), 1.0e-12);
        Assert.assertEquals(v1.subtract(v2).getNormInf().getReal(), FieldVector3D.distanceInf(v1, v2).getReal(), 1.0e-12);

        Assert.assertEquals(5.0,
                            FieldVector3D.distanceInf(createVector( 1, -2, 3, 3), createVector(-4,  2, 0, 3)).getReal(),
                            1.0e-12);
        Assert.assertEquals(5.0,
                            FieldVector3D.distanceInf(createVector( 1, 3, -2, 3), createVector(-4, 0,  2, 3)).getReal(),
                            1.0e-12);
        Assert.assertEquals(5.0,
                            FieldVector3D.distanceInf(createVector(-2,  1, 3, 3), createVector( 2, -4, 0, 3)).getReal(),
                            1.0e-12);
        Assert.assertEquals(5.0,
                            FieldVector3D.distanceInf(createVector(-2, 3,  1, 3), createVector( 2, 0, -4, 3)).getReal(),
                            1.0e-12);
        Assert.assertEquals(5.0,
                            FieldVector3D.distanceInf(createVector(3, -2,  1, 3), createVector(0,  2, -4, 3)).getReal(),
                            1.0e-12);
        Assert.assertEquals(5.0,
                            FieldVector3D.distanceInf(createVector(3,  1, -2, 3), createVector(0, -4,  2, 3)).getReal(),
                            1.0e-12);

        Assert.assertEquals(5.0,
                            FieldVector3D.distanceInf(createVector( 1, -2, 3, 3), new Vector3D(-4,  2, 0)).getReal(),
                            1.0e-12);
        Assert.assertEquals(5.0,
                            FieldVector3D.distanceInf(createVector( 1, 3, -2, 3), new Vector3D(-4, 0,  2)).getReal(),
                            1.0e-12);
        Assert.assertEquals(5.0,
                            FieldVector3D.distanceInf(createVector(-2,  1, 3, 3), new Vector3D( 2, -4, 0)).getReal(),
                            1.0e-12);
        Assert.assertEquals(5.0,
                            FieldVector3D.distanceInf(createVector(-2, 3,  1, 3), new Vector3D( 2, 0, -4)).getReal(),
                            1.0e-12);
        Assert.assertEquals(5.0,
                            FieldVector3D.distanceInf(createVector(3, -2,  1, 3), new Vector3D(0,  2, -4)).getReal(),
                            1.0e-12);
        Assert.assertEquals(5.0,
                            FieldVector3D.distanceInf(createVector(3,  1, -2, 3), new Vector3D(0, -4,  2)).getReal(),
                            1.0e-12);

    }

    @Test
    public void testSubtract() {
        FieldVector3D<DerivativeStructure> v1 = createVector(1, 2, 3, 3);
        FieldVector3D<DerivativeStructure> v2 = createVector(-3, -2, -1, 3);
        v1 = v1.subtract(v2);
        checkVector(v1, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0);

        checkVector(v2.subtract(v1), -7, -6, -5, 1, 0, 0, 0, 1, 0, 0, 0, 1);
        checkVector(v2.subtract(new Vector3D(4, 4, 4)), -7, -6, -5, 1, 0, 0, 0, 1, 0, 0, 0, 1);
        checkVector(v2.subtract(3, v1), -15, -14, -13, 1, 0, 0, 0, 1, 0, 0, 0, 1);
        checkVector(v2.subtract(3, new Vector3D(4, 4, 4)), -15, -14, -13, 1, 0, 0, 0, 1, 0, 0, 0, 1);
        checkVector(v2.subtract(new DerivativeStructure(3, 1, 2, 3), new Vector3D(4, 4, 4)),
                    -15, -14, -13, 1, 0, -4, 0, 1, -4, 0, 0, -3);

        checkVector(createVector(1, 2, 3, 4).subtract(new DerivativeStructure(4, 1, 3, 5.0),
                                                      createVector(3, -2, 1, 4)),
                    -14, 12, -2,
                     -4,  0,  0, -3,
                      0, -4,  0,  2,
                      0,  0, -4, -1);

    }

    @Test
    public void testAdd() {
        FieldVector3D<DerivativeStructure> v1 = createVector(1, 2, 3, 3);
        FieldVector3D<DerivativeStructure> v2 = createVector(-3, -2, -1, 3);
        v1 = v1.add(v2);
        checkVector(v1, -2, 0, 2, 2, 0, 0, 0, 2, 0, 0, 0, 2);

        checkVector(v2.add(v1), -5, -2, 1, 3, 0, 0, 0, 3, 0, 0, 0, 3);
        checkVector(v2.add(new Vector3D(-2, 0, 2)), -5, -2, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1);
        checkVector(v2.add(3, v1), -9, -2, 5, 7, 0, 0, 0, 7, 0, 0, 0, 7);
        checkVector(v2.add(3, new Vector3D(-2, 0, 2)), -9, -2, 5, 1, 0, 0, 0, 1, 0, 0, 0, 1);
        checkVector(v2.add(new DerivativeStructure(3, 1, 2, 3), new Vector3D(-2, 0, 2)),
                    -9, -2, 5, 1, 0, -2, 0, 1, 0, 0, 0, 3);

        checkVector(createVector(1, 2, 3, 4).add(new DerivativeStructure(4, 1, 3, 5.0),
                                                 createVector(3, -2, 1, 4)),
                    16, -8,  8,
                     6,  0,  0,  3,
                     0,  6,  0, -2,
                     0,  0,  6,  1);

    }

    @Test
    public void testScalarProduct() {
        FieldVector3D<DerivativeStructure> v = createVector(1, 2, 3, 3);
        v = v.scalarMultiply(3);
        checkVector(v, 3, 6, 9);

        checkVector(v.scalarMultiply(0.5), 1.5, 3, 4.5);
    }

    @Test
    public void testVectorialProducts() {
        FieldVector3D<DerivativeStructure> v1 = createVector(2, 1, -4, 3);
        FieldVector3D<DerivativeStructure> v2 = createVector(3, 1, -1, 3);

        Assert.assertTrue(FastMath.abs(FieldVector3D.dotProduct(v1, v2).getReal() - 11) < 1.0e-12);
        Assert.assertTrue(FastMath.abs(FieldVector3D.dotProduct(v1, v2.toVector3D()).getReal() - 11) < 1.0e-12);
        Assert.assertTrue(FastMath.abs(FieldVector3D.dotProduct(v1.toVector3D(), v2).getReal() - 11) < 1.0e-12);

        FieldVector3D<DerivativeStructure> v3 = FieldVector3D.crossProduct(v1, v2);
        checkVector(v3, 3, -10, -1);
        Assert.assertTrue(FastMath.abs(FieldVector3D.dotProduct(v1, v3).getReal()) < 1.0e-12);
        Assert.assertTrue(FastMath.abs(FieldVector3D.dotProduct(v2, v3).getReal()) < 1.0e-12);

        v3 = FieldVector3D.crossProduct(v1, v2.toVector3D());
        checkVector(v3, 3, -10, -1);
        Assert.assertTrue(FastMath.abs(FieldVector3D.dotProduct(v1, v3).getReal()) < 1.0e-12);
        Assert.assertTrue(FastMath.abs(FieldVector3D.dotProduct(v2, v3).getReal()) < 1.0e-12);

        v3 = FieldVector3D.crossProduct(v1.toVector3D(), v2);
        checkVector(v3, 3, -10, -1);
        Assert.assertTrue(FastMath.abs(FieldVector3D.dotProduct(v1, v3).getReal()) < 1.0e-12);
        Assert.assertTrue(FastMath.abs(FieldVector3D.dotProduct(v2, v3).getReal()) < 1.0e-12);

    }

    @Test
    public void testCrossProductCancellation() {
        FieldVector3D<DerivativeStructure> v1 = createVector(9070467121.0, 4535233560.0, 1, 3);
        FieldVector3D<DerivativeStructure> v2 = createVector(9070467123.0, 4535233561.0, 1, 3);
        checkVector(FieldVector3D.crossProduct(v1, v2), -1, 2, 1);

        double scale    = FastMath.scalb(1.0, 100);
        FieldVector3D<DerivativeStructure> big1   = new FieldVector3D(scale, v1);
        FieldVector3D<DerivativeStructure> small2 = new FieldVector3D(1 / scale, v2);
        checkVector(FieldVector3D.crossProduct(big1, small2), -1, 2, 1);

    }

    @Test
    public void testAngular() {
        Assert.assertEquals(0,           createVector(1, 0, 0, 3).getAlpha().getReal(), 1.0e-10);
        Assert.assertEquals(0,           createVector(1, 0, 0, 3).getDelta().getReal(), 1.0e-10);
        Assert.assertEquals(FastMath.PI / 2, createVector(0, 1, 0, 3).getAlpha().getReal(), 1.0e-10);
        Assert.assertEquals(0,           createVector(0, 1, 0, 3).getDelta().getReal(), 1.0e-10);
        Assert.assertEquals(FastMath.PI / 2, createVector(0, 0, 1, 3).getDelta().getReal(), 1.0e-10);

        FieldVector3D<DerivativeStructure> u = createVector(-1, 1, -1, 3);
        Assert.assertEquals(3 * FastMath.PI /4, u.getAlpha().getReal(), 1.0e-10);
        Assert.assertEquals(-1.0 / FastMath.sqrt(3), u.getDelta().sin().getReal(), 1.0e-10);
    }

    @Test
    public void testAngularSeparation() throws MathArithmeticException {
        FieldVector3D<DerivativeStructure> v1 = createVector(2, -1, 4, 3);

        FieldVector3D<DerivativeStructure>  k = v1.normalize();
        FieldVector3D<DerivativeStructure>  i = k.orthogonal();
        FieldVector3D<DerivativeStructure> v2 = k.scalarMultiply(FastMath.cos(1.2)).add(i.scalarMultiply(FastMath.sin(1.2)));

        Assert.assertTrue(FastMath.abs(FieldVector3D.angle(v1, v2).getReal() - 1.2) < 1.0e-12);
        Assert.assertTrue(FastMath.abs(FieldVector3D.angle(v1, v2.toVector3D()).getReal() - 1.2) < 1.0e-12);
        Assert.assertTrue(FastMath.abs(FieldVector3D.angle(v1.toVector3D(), v2).getReal() - 1.2) < 1.0e-12);

        try {
            FieldVector3D.angle(v1, Vector3D.ZERO);
            Assert.fail("an exception should have been thrown");
        } catch (MathArithmeticException mae) {
            // expected
        }
        Assert.assertEquals(0.0, FieldVector3D.angle(v1, v1.toVector3D()).getReal(), 1.0e-15);
        Assert.assertEquals(FastMath.PI, FieldVector3D.angle(v1, v1.negate().toVector3D()).getReal(), 1.0e-15);

    }

    @Test
    public void testNormalize() throws MathArithmeticException {
        Assert.assertEquals(1.0, createVector(5, -4, 2, 3).normalize().getNorm().getReal(), 1.0e-12);
        try {
            createVector(0, 0, 0, 3).normalize();
            Assert.fail("an exception should have been thrown");
        } catch (MathArithmeticException ae) {
            // expected behavior
        }
    }

    @Test
    public void testNegate() {
        checkVector(createVector(0.1, 2.5, 1.3, 3).negate(),
                    -0.1, -2.5, -1.3, -1, 0, 0, 0, -1, 0, 0, 0, -1);
    }

    @Test
    public void testOrthogonal() throws MathArithmeticException {
        FieldVector3D<DerivativeStructure> v1 = createVector(0.1, 2.5, 1.3, 3);
        Assert.assertEquals(0.0, FieldVector3D.dotProduct(v1, v1.orthogonal()).getReal(), 1.0e-12);
        FieldVector3D<DerivativeStructure> v2 = createVector(2.3, -0.003, 7.6, 3);
        Assert.assertEquals(0.0, FieldVector3D.dotProduct(v2, v2.orthogonal()).getReal(), 1.0e-12);
        FieldVector3D<DerivativeStructure> v3 = createVector(-1.7, 1.4, 0.2, 3);
        Assert.assertEquals(0.0, FieldVector3D.dotProduct(v3, v3.orthogonal()).getReal(), 1.0e-12);
        FieldVector3D<DerivativeStructure> v4 = createVector(4.2, 0.1, -1.8, 3);
        Assert.assertEquals(0.0, FieldVector3D.dotProduct(v4, v4.orthogonal()).getReal(), 1.0e-12);
        try {
            createVector(0, 0, 0, 3).orthogonal();
            Assert.fail("an exception should have been thrown");
        } catch (MathArithmeticException ae) {
            // expected behavior
        }
    }

    @Test
    public void testAngle() throws MathArithmeticException {
        Assert.assertEquals(0.22572612855273393616,
                            FieldVector3D.angle(createVector(1, 2, 3, 3), createVector(4, 5, 6, 3)).getReal(),
                            1.0e-12);
        Assert.assertEquals(7.98595620686106654517199e-8,
                            FieldVector3D.angle(createVector(1, 2, 3, 3), createVector(2, 4, 6.000001, 3)).getReal(),
                            1.0e-12);
        Assert.assertEquals(3.14159257373023116985197793156,
                            FieldVector3D.angle(createVector(1, 2, 3, 3), createVector(-2, -4, -6.000001, 3)).getReal(),
                            1.0e-12);
        try {
            FieldVector3D.angle(createVector(0, 0, 0, 3), createVector(1, 0, 0, 3));
            Assert.fail("an exception should have been thrown");
        } catch (MathArithmeticException ae) {
            // expected behavior
        }
    }

    @Test
    public void testAccurateDotProduct() {
        // the following two vectors are nearly but not exactly orthogonal
        // naive dot product (i.e. computing u1.x * u2.x + u1.y * u2.y + u1.z * u2.z
        // leads to a result of 0.0, instead of the correct -1.855129...
        FieldVector3D<DerivativeStructure> u1 = createVector(-1321008684645961.0 /  268435456.0,
                                   -5774608829631843.0 /  268435456.0,
                                   -7645843051051357.0 / 8589934592.0, 3);
        FieldVector3D<DerivativeStructure> u2 = createVector(-5712344449280879.0 /    2097152.0,
                                   -4550117129121957.0 /    2097152.0,
                                    8846951984510141.0 /     131072.0, 3);
        DerivativeStructure sNaive = u1.getX().multiply(u2.getX()).add(u1.getY().multiply(u2.getY())).add(u1.getZ().multiply(u2.getZ()));
        DerivativeStructure sAccurate = FieldVector3D.dotProduct(u1, u2);
        Assert.assertEquals(0.0, sNaive.getReal(), 1.0e-30);
        Assert.assertEquals(-2088690039198397.0 / 1125899906842624.0, sAccurate.getReal(), 1.0e-15);
    }

    @Test
    public void testDotProduct() {
        // we compare accurate versus naive dot product implementations
        // on regular vectors (i.e. not extreme cases like in the previous test)
        Well1024a random = new Well1024a(553267312521321234l);
        for (int i = 0; i < 10000; ++i) {
            double ux = 10000 * random.nextDouble();
            double uy = 10000 * random.nextDouble();
            double uz = 10000 * random.nextDouble();
            double vx = 10000 * random.nextDouble();
            double vy = 10000 * random.nextDouble();
            double vz = 10000 * random.nextDouble();
            double sNaive = ux * vx + uy * vy + uz * vz;

            FieldVector3D<DerivativeStructure> uds = createVector(ux, uy, uz, 3);
            FieldVector3D<DerivativeStructure> vds = createVector(vx, vy, vz, 3);
            Vector3D v = new Vector3D(vx, vy, vz);

            DerivativeStructure sAccurate = FieldVector3D.dotProduct(uds, vds);
            Assert.assertEquals(sNaive, sAccurate.getReal(), 2.5e-16 * sNaive);
            Assert.assertEquals(ux + vx, sAccurate.getPartialDerivative(1, 0, 0), 2.5e-16 * sNaive);
            Assert.assertEquals(uy + vy, sAccurate.getPartialDerivative(0, 1, 0), 2.5e-16 * sNaive);
            Assert.assertEquals(uz + vz, sAccurate.getPartialDerivative(0, 0, 1), 2.5e-16 * sNaive);

            sAccurate = FieldVector3D.dotProduct(uds, v);
            Assert.assertEquals(sNaive, sAccurate.getReal(), 2.5e-16 * sNaive);
            Assert.assertEquals(vx, sAccurate.getPartialDerivative(1, 0, 0), 2.5e-16 * sNaive);
            Assert.assertEquals(vy, sAccurate.getPartialDerivative(0, 1, 0), 2.5e-16 * sNaive);
            Assert.assertEquals(vz, sAccurate.getPartialDerivative(0, 0, 1), 2.5e-16 * sNaive);

        }
    }

    @Test
    public void testAccurateCrossProduct() {
        // the vectors u1 and u2 are nearly but not exactly anti-parallel
        // (7.31e-16 degrees from 180 degrees) naive cross product (i.e.
        // computing u1.x * u2.x + u1.y * u2.y + u1.z * u2.z
        // leads to a result of   [0.0009765, -0.0001220, -0.0039062],
        // instead of the correct [0.0006913, -0.0001254, -0.0007909]
        final FieldVector3D<DerivativeStructure> u1 = createVector(-1321008684645961.0 /   268435456.0,
                                         -5774608829631843.0 /   268435456.0,
                                         -7645843051051357.0 /  8589934592.0, 3);
        final FieldVector3D<DerivativeStructure> u2 = createVector( 1796571811118507.0 /  2147483648.0,
                                          7853468008299307.0 /  2147483648.0,
                                          2599586637357461.0 / 17179869184.0, 3);
        final FieldVector3D<DerivativeStructure> u3 = createVector(12753243807587107.0 / 18446744073709551616.0,
                                         -2313766922703915.0 / 18446744073709551616.0,
                                          -227970081415313.0 /   288230376151711744.0, 3);
        FieldVector3D<DerivativeStructure> cNaive = new FieldVector3D(u1.getY().multiply(u2.getZ()).subtract(u1.getZ().multiply(u2.getY())),
                                       u1.getZ().multiply(u2.getX()).subtract(u1.getX().multiply(u2.getZ())),
                                       u1.getX().multiply(u2.getY()).subtract(u1.getY().multiply(u2.getX())));
        FieldVector3D<DerivativeStructure> cAccurate = FieldVector3D.crossProduct(u1, u2);
        Assert.assertTrue(FieldVector3D.distance(u3, cNaive).getReal() > 2.9 * u3.getNorm().getReal());
        Assert.assertEquals(0.0, FieldVector3D.distance(u3, cAccurate).getReal(), 1.0e-30 * cAccurate.getNorm().getReal());
    }

    @Test
    public void testCrossProduct() {
        // we compare accurate versus naive cross product implementations
        // on regular vectors (i.e. not extreme cases like in the previous test)
        Well1024a random = new Well1024a(885362227452043214l);
        for (int i = 0; i < 10000; ++i) {
            double ux = random.nextDouble();
            double uy = random.nextDouble();
            double uz = random.nextDouble();
            double vx = random.nextDouble();
            double vy = random.nextDouble();
            double vz = random.nextDouble();
            Vector3D cNaive = new Vector3D(uy * vz - uz * vy, uz * vx - ux * vz, ux * vy - uy * vx);

            FieldVector3D<DerivativeStructure> uds = createVector(ux, uy, uz, 3);
            FieldVector3D<DerivativeStructure> vds = createVector(vx, vy, vz, 3);
            Vector3D v = new Vector3D(vx, vy, vz);

            checkVector(FieldVector3D.crossProduct(uds, vds),
                        cNaive.getX(), cNaive.getY(), cNaive.getZ(),
                        0, vz - uz, uy - vy,
                        uz - vz, 0, vx - ux,
                        vy - uy, ux - vx, 0);

            checkVector(FieldVector3D.crossProduct(uds, v),
                        cNaive.getX(), cNaive.getY(), cNaive.getZ(),
                          0,  vz, -vy,
                        -vz,   0,  vx,
                         vy, -vx,   0);

        }
    }

    private FieldVector3D<DerivativeStructure> createVector(double x, double y, double z, int params) {
        return new FieldVector3D<DerivativeStructure>(new DerivativeStructure(params, 1, 0, x),
                              new DerivativeStructure(params, 1, 1, y),
                              new DerivativeStructure(params, 1, 2, z));
    }

    private void checkVector(FieldVector3D<DerivativeStructure> v, double x, double y, double z) {
        Assert.assertEquals(x, v.getX().getReal(), 1.0e-12);
        Assert.assertEquals(y, v.getY().getReal(), 1.0e-12);
        Assert.assertEquals(z, v.getZ().getReal(), 1.0e-12);
    }

    private void checkVector(FieldVector3D<DerivativeStructure> v, double x, double y, double z,
                             double dxdx, double dxdy, double dxdz,
                             double dydx, double dydy, double dydz,
                             double dzdx, double dzdy, double dzdz) {
        Assert.assertEquals(x, v.getX().getReal(), 1.0e-12);
        Assert.assertEquals(y, v.getY().getReal(), 1.0e-12);
        Assert.assertEquals(z, v.getZ().getReal(), 1.0e-12);
        Assert.assertEquals(dxdx, v.getX().getPartialDerivative(1, 0, 0), 1.0e-12);
        Assert.assertEquals(dxdy, v.getX().getPartialDerivative(0, 1, 0), 1.0e-12);
        Assert.assertEquals(dxdz, v.getX().getPartialDerivative(0, 0, 1), 1.0e-12);
        Assert.assertEquals(dydx, v.getY().getPartialDerivative(1, 0, 0), 1.0e-12);
        Assert.assertEquals(dydy, v.getY().getPartialDerivative(0, 1, 0), 1.0e-12);
        Assert.assertEquals(dydz, v.getY().getPartialDerivative(0, 0, 1), 1.0e-12);
        Assert.assertEquals(dzdx, v.getZ().getPartialDerivative(1, 0, 0), 1.0e-12);
        Assert.assertEquals(dzdy, v.getZ().getPartialDerivative(0, 1, 0), 1.0e-12);
        Assert.assertEquals(dzdz, v.getZ().getPartialDerivative(0, 0, 1), 1.0e-12);
    }

    private void checkVector(FieldVector3D<DerivativeStructure> v, double x, double y, double z,
                             double dxdx, double dxdy, double dxdz, double dxdt,
                             double dydx, double dydy, double dydz, double dydt,
                             double dzdx, double dzdy, double dzdz, double dzdt) {
        Assert.assertEquals(x, v.getX().getReal(), 1.0e-12);
        Assert.assertEquals(y, v.getY().getReal(), 1.0e-12);
        Assert.assertEquals(z, v.getZ().getReal(), 1.0e-12);
        Assert.assertEquals(dxdx, v.getX().getPartialDerivative(1, 0, 0, 0), 1.0e-12);
        Assert.assertEquals(dxdy, v.getX().getPartialDerivative(0, 1, 0, 0), 1.0e-12);
        Assert.assertEquals(dxdz, v.getX().getPartialDerivative(0, 0, 1, 0), 1.0e-12);
        Assert.assertEquals(dxdt, v.getX().getPartialDerivative(0, 0, 0, 1), 1.0e-12);
        Assert.assertEquals(dydx, v.getY().getPartialDerivative(1, 0, 0, 0), 1.0e-12);
        Assert.assertEquals(dydy, v.getY().getPartialDerivative(0, 1, 0, 0), 1.0e-12);
        Assert.assertEquals(dydz, v.getY().getPartialDerivative(0, 0, 1, 0), 1.0e-12);
        Assert.assertEquals(dydt, v.getY().getPartialDerivative(0, 0, 0, 1), 1.0e-12);
        Assert.assertEquals(dzdx, v.getZ().getPartialDerivative(1, 0, 0, 0), 1.0e-12);
        Assert.assertEquals(dzdy, v.getZ().getPartialDerivative(0, 1, 0, 0), 1.0e-12);
        Assert.assertEquals(dzdz, v.getZ().getPartialDerivative(0, 0, 1, 0), 1.0e-12);
        Assert.assertEquals(dzdt, v.getZ().getPartialDerivative(0, 0, 0, 1), 1.0e-12);
    }

}

Other Java examples (source code examples)

Here is a short list of links related to this Java FieldVector3DTest.java source code file:



my book on functional programming

 

new blog posts

 

Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.