Example usage for org.apache.commons.math3.complex Complex NaN

List of usage examples for org.apache.commons.math3.complex Complex NaN

Introduction

In this page you can find the example usage for org.apache.commons.math3.complex Complex NaN.

Prototype

Complex NaN

To view the source code for org.apache.commons.math3.complex Complex NaN.

Click Source Link

Document

A complex number representing "NaN + NaNi"

Usage

From source file:de.thkwalter.et.betriebspunkt.Betriebspunkt.java

/**
 * Dieser Konstruktor erzeugt einen Betriebspunkt und initialisiert alle reellwertigen Gren mit {@link Double#NaN}.
 *//*  w ww  .ja v  a 2s  .c  o  m*/
public Betriebspunkt() {
    // Alle reellwertigen Gren werden mit Double.NaN initialisiert.
    this.u_LL = Double.NaN;
    this.i_L = Double.NaN;
    this.cosPhi = Double.NaN;
    this.p_el = Double.NaN;
    this.p_s = Double.NaN;

    // Der komplexe Zeiger des Stnderstroms (in A) wird initialisiert.
    this.z_i_s = Complex.NaN;
}

From source file:org.briljantframework.complex.MutableComplex.java

public Complex toComplex() {
    return Double.isNaN(real) || Double.isNaN(imag) ? Complex.NaN : Complex.valueOf(real, imag);
}

From source file:org.eclipse.january.dataset.BinaryOperationTest.java

@Parameters
public static Collection<Object[]> parameters() {
    return Arrays.asList(new Object[][] {
            { Operations.Addition.class, null,
                    new Object[][] { { false, 0l, 0l }, { true, 1l, 0l }, { true, 0l, 1l }, { true, 1l, 1l },
                            { 0l, 0l, 0l }, { 1l, 1l, 0l }, { 1l, 0l, 1l }, { 2l, 1l, 1l }, { 0d, 0d, 0d },
                            { 1d, 1d, 0d }, { 1d, 0d, 1d }, { 2d, 1d, 1d }, { new Complex(0), 0d, 0d, 0d, 0d },
                            { new Complex(1), 1d, 0d, 0d, 0d }, { new Complex(1), 0d, 0d, 1d, 0d },
                            { new Complex(2), 1d, 0d, 1d, 0d }, { new Complex(0, 0), 0d, 0d, 0d, 0d },
                            { new Complex(1, 1), 1d, 1d, 0d, 0d }, { new Complex(1, 1), 0d, 1d, 1d, 0d },
                            { new Complex(2, 2), 1d, 1d, 1d, 1d }, } },
            { Operations.Subtraction.class, null,
                    new Object[][] { { true, 0l, 0l }, { true, 1l, 0l }, { false, 0l, 1l }, { true, 1l, 1l },
                            { 0l, 0l, 0l }, { 1l, 1l, 0l }, { -1l, 0l, 1l }, { 0l, 1l, 1l }, { 0d, 0d, 0d },
                            { 1d, 1d, 0d }, { -1d, 0d, 1d }, { 0d, 1d, 1d }, { new Complex(0), 0d, 0d, 0d, 0d },
                            { new Complex(1), 1d, 0d, 0d, 0d }, { new Complex(-1), 0d, 0d, 1d, 0d },
                            { new Complex(0), 1d, 0d, 1d, 0d }, { new Complex(0, 0), 0d, 0d, 0d, 0d },
                            { new Complex(1, 1), 1d, 1d, 0d, 0d }, { new Complex(-1, 1), 0d, 1d, 1d, 0d },
                            { new Complex(0, 0), 1d, 1d, 1d, 1d }, } },
            { Operations.Multiplication.class, null,
                    new Object[][] { { false, 0l, 0l }, { false, 1l, 0l }, { false, 0l, 1l }, { true, 1l, 1l },
                            { 0l, 0l, 0l }, { 0l, 1l, 0l }, { 0l, 0l, 1l }, { 2l, 2l, 1l }, { 0d, 0d, 0d },
                            { 0d, 1d, 0d }, { 0d, 0d, 1d }, { 2d, 2d, 1d }, { new Complex(0), 0d, 0d, 0d, 0d },
                            { new Complex(0), 1d, 0d, 0d, 0d }, { new Complex(0), 0d, 0d, 1d, 0d },
                            { new Complex(1), 1d, 0d, 1d, 0d }, { new Complex(0, 0), 0d, 0d, 0d, 0d },
                            { new Complex(0), 1d, 1d, 0d, 0d }, { new Complex(0, 1), 0d, 1d, 1d, 0d },
                            { new Complex(0, 2), 1d, 1d, 1d, 1d }, } },
            { Operations.Division.class, null,
                    new Object[][] { { false, 0l, 0l }, { true, 1l, 0l }, { false, 0l, 1l }, { false, 1l, 1l },
                            { 0l, 0l, 0l }, { 0l, 1l, 0l }, { 0l, 0l, 1l }, { 2l, 2l, 1l }, { -2l, -5l, 2l },
                            { -1l, -5l, 3l }, { -2l, 5l, -2l }, { -1l, 5l, -3l }, { 2l, -5l, -2l },
                            { 1l, -5l, -3l }, { Double.NaN, 0d, 0d }, { Double.POSITIVE_INFINITY, 1d, 0d },
                            { 0d, 0d, 1d }, { 2d, 2d, 1d },
                            { new Complex(Double.NaN, Double.NaN), 0d, 0d, 0d, 0d },
                            { new Complex(Double.POSITIVE_INFINITY, Double.NaN), 1d, 0d, 0d, 0d },
                            { new Complex(0), 0d, 0d, 1d, 0d }, { new Complex(1), 1d, 0d, 1d, 0d },
                            { new Complex(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY), 1d, 1d, 0d, 0d },
                            { new Complex(0, 1), 0d, 1d, 1d, 0d }, { new Complex(1, 0), 1d, 1d, 1d, 1d }, } },
            { Operations.DivisionWithZero.class, null,
                    new Object[][] { { false, 0l, 0l }, { true, 1l, 0l }, { false, 0l, 1l }, { false, 1l, 1l },
                            { 0l, 0l, 0l }, { 0l, 1l, 0l }, { 0l, 0l, 1l }, { 2l, 2l, 1l },
                            { new Complex(0d), 0d, 0d, 0d, 0d }, { new Complex(0d), 1d, 0d, 0d, 0d },
                            { new Complex(0), 0d, 0d, 1d, 0d }, { new Complex(1), 1d, 0d, 1d, 0d },
                            { new Complex(0d), 1d, 1d, 0d, 0d }, { new Complex(0, 1), 0d, 1d, 1d, 0d },
                            { new Complex(1, 0), 1d, 1d, 1d, 1d }, } },
            { Operations.DivisionTowardsFloor.class, null,
                    new Object[][] { { false, 0l, 0l }, { true, 1l, 0l }, { false, 0l, 1l }, { false, 1l, 1l },
                            { 0l, 0l, 0l }, { 0l, 1l, 0l }, { 0l, 0l, 1l }, { 2l, 2l, 1l }, { -3l, -5l, 2l },
                            { -2l, -5l, 3l }, { -3l, 5l, -2l }, { -2l, 5l, -3l }, { 2l, -5l, -2l },
                            { 1l, -5l, -3l }, { Double.NaN, 0d, 0d }, { Double.POSITIVE_INFINITY, 1d, 0d },
                            { 0d, 0d, 1d }, { 2d, 2d, 1d }, { Complex.NaN, 0d, 0d, 0d, 0d },
                            { new Complex(Double.POSITIVE_INFINITY, Double.NaN), 1d, 0d, 0d, 0d },
                            { new Complex(0), 0d, 0d, 1d, 0d }, { new Complex(1), 1d, 0d, 1d, 0d },
                            { Complex.INF, 1d, 1d, 0d, 0d }, { new Complex(0, 1), 0d, 1d, 1d, 0d },
                            { new Complex(1, 0), 1d, 1d, 1d, 1d }, } },
            { Operations.Remainder.class, null,
                    new Object[][] { { 0l, 0l, 0l }, { 0l, 1l, 0l }, { 0l, 0l, 1l }, { 0l, 2l, 1l },
                            { -1l, -5l, 2l }, { -2l, -5l, 3l }, { 1l, 5l, -2l }, { 2l, 5l, -3l },
                            { -1l, -5l, -2l }, { -2l, -5l, -3l }, { Double.NaN, 0d, 0d },
                            { Double.NaN, 1d, 0d }, { 0d, 0d, 1d }, { 0d, 2d, 1d }, } },
            { Operations.Exponentiation.class, null,
                    new Object[][] { { true, 0l, 0l }, { true, 1l, 0l }, { false, 0l, 1l }, { true, 1l, 1l },
                            { 1l, 0l, 0l }, { 1l, 1l, 0l }, { 0l, 0l, 1l }, { 2l, 2l, 1l }, { 1d, 0d, 0d },
                            { 1d, 1d, 0d }, { 0d, 0d, 1d }, { 2d, 2d, 1d }, { Complex.NaN, 0d, 0d, 0d, 0d },
                            { new Complex(1), 1d, 0d, 0d, 0d }, { Complex.NaN, 0d, 0d, 1d, 0d },
                            { new Complex(1), 1d, 0d, 1d, 0d }, { Complex.NaN, 0d, 0d, 0d, 0d },
                            { new Complex(1), 1d, 1d, 0d, 0d }, { new Complex(0, 1), 0d, 1d, 1d, 0d },
                            { new Complex(C_M * Math.cos(C_A), C_M * Math.sin(C_A)), 1d, 1d, 1d, 1d }, } },
            { Operations.Maximum.class, null,
                    new Object[][] { { false, 0l, 0l }, { true, 1l, 0l }, { true, 0l, 1l }, { true, 1l, 1l },
                            { 0l, 0l, 0l }, { 1l, 1l, 0l }, { 1l, 0l, 1l }, { 2l, 2l, 1l }, { 2l, -5l, 2l },
                            { 3l, -5l, 3l }, { 5l, 5l, -2l }, { 5l, 5l, -3l }, { -2l, -5l, -2l },
                            { -3l, -5l, -3l }, { 0d, 0d, 0d }, { 1d, 1d, 0d }, { 1d, 0d, 1d },
                            { 2d, 2d, 1d }, } },
            { Operations.Minimum.class, null,
                    new Object[][] { { false, 0l, 0l }, { false, 1l, 0l }, { false, 0l, 1l }, { true, 1l, 1l },
                            { 0l, 0l, 0l }, { 0l, 1l, 0l }, { 0l, 0l, 1l }, { 1l, 2l, 1l }, { -5l, -5l, 2l },
                            { -5l, -5l, 3l }, { -2l, 5l, -2l }, { -3l, 5l, -3l }, { -5l, -5l, -2l },
                            { -5l, -5l, -3l }, { 0d, 0d, 0d }, { 10, 1d, 0d }, { 0d, 0d, 1d },
                            { 1d, 2d, 1d }, } },
            { Operations.UseIfGreaterThan.class, -2.5,
                    new Object[][] { { false, 0l, 0l }, { true, 1l, 0l }, { false, 0l, 1l }, { true, 1l, 1l },
                            { 0l, 0l, 0l }, { -2l, 1l, 0l }, { 0l, 0l, 1l }, { -2l, 2l, 1l }, { -5l, -5l, 2l },
                            { -5l, -5l, 3l }, { -2l, 5l, -2l }, { -2l, 5l, -3l }, { -5l, -5l, -2l },
                            { -5l, -5l, -3l }, { 0d, 0d, 0d }, { -2.5d, 1d, 0d }, { 0d, 0d, 1d },
                            { -2.5d, 2d, 1d }, } },
            { Operations.UseIfGreaterThanOrEqualTo.class, -2.5,
                    new Object[][] { { true, 0l, 0l }, { true, 1l, 0l }, { false, 0l, 1l }, { true, 1l, 1l },
                            { -2l, 0l, 0l }, { -2l, 1l, 0l }, { 0l, 0l, 1l }, { -2l, 2l, 1l }, { -5l, -5l, 2l },
                            { -5l, -5l, 3l }, { -2l, 5l, -2l }, { -2l, 5l, -3l }, { -5l, -5l, -2l },
                            { -5l, -5l, -3l }, { -2.5d, 0d, 0d }, { -2.5d, 1d, 0d }, { 0d, 0d, 1d },
                            { -2.5d, 2d, 1d }, } },
            { Operations.UseIfLessThan.class, -2.5,
                    new Object[][] { { false, 0l, 0l }, { true, 1l, 0l }, { true, 0l, 1l }, { true, 1l, 1l },
                            { 0l, 0l, 0l }, { 1l, 1l, 0l }, { -2l, 0l, 1l }, { 2l, 2l, 1l }, { -2l, -5l, 2l },
                            { -2l, -5l, 3l }, { 5l, 5l, -2l }, { 5l, 5l, -3l }, { -2l, -5l, -2l },
                            { -2l, -5l, -3l }, { 0d, 0d, 0d }, { 1d, 1d, 0d }, { -2.5d, 0d, 1d },
                            { 2d, 2d, 1d }, } },
            { Operations.UseIfLessThanOrEqualTo.class, -2.5,
                    new Object[][] { { true, 0l, 0l }, { true, 1l, 0l }, { true, 0l, 1l }, { true, 1l, 1l },
                            { -2l, 0l, 0l }, { 1l, 1l, 0l }, { -2l, 0l, 1l }, { 2l, 2l, 1l }, { -2l, -5l, 2l },
                            { -2l, -5l, 3l }, { 5l, 5l, -2l }, { 5l, 5l, -3l }, { -2l, -5l, -2l },
                            { -2l, -5l, -3l }, { -2.5d, 0d, 0d }, { 1d, 1d, 0d }, { -2.5d, 0d, 1d },
                            { 2d, 2d, 1d }, } },
            { Operations.UseIfEqualTo.class, -2.5,
                    new Object[][] { { true, 0l, 0l }, { true, 1l, 0l }, { false, 0l, 1l }, { true, 1l, 1l },
                            { -2l, 0l, 0l }, { 1l, 1l, 0l }, { 0l, 0l, 1l }, { 2l, 2l, 1l }, { -5l, -5l, 2l },
                            { -5l, -5l, 3l }, { 5l, 5l, -2l }, { 5l, 5l, -3l }, { -5l, -5l, -2l },
                            { -5l, -5l, -3l }, { -2.5d, 0d, 0d }, { 1d, 1d, 0d }, { 0d, 0d, 1d },
                            { 2d, 2d, 1d }, } }, });
}

From source file:uk.ac.diamond.scisoft.analysis.dataset.BinaryOperationTest.java

@Parameters
public static Collection<Object[]> parameters() {
    return Arrays.asList(new Object[][] {
            { BinaryOperation.Addition.class,
                    new Object[][] { { false, 0l, 0l }, { true, 1l, 0l }, { true, 0l, 1l }, { true, 1l, 1l },
                            { 0l, 0l, 0l }, { 1l, 1l, 0l }, { 1l, 0l, 1l }, { 2l, 1l, 1l }, { 0d, 0d, 0d },
                            { 1d, 1d, 0d }, { 1d, 0d, 1d }, { 2d, 1d, 1d }, { new Complex(0), 0d, 0d, 0d, 0d },
                            { new Complex(1), 1d, 0d, 0d, 0d }, { new Complex(1), 0d, 0d, 1d, 0d },
                            { new Complex(2), 1d, 0d, 1d, 0d }, { new Complex(0, 0), 0d, 0d, 0d, 0d },
                            { new Complex(1, 1), 1d, 1d, 0d, 0d }, { new Complex(1, 1), 0d, 1d, 1d, 0d },
                            { new Complex(2, 2), 1d, 1d, 1d, 1d }, } },
            { BinaryOperation.Subtraction.class,
                    new Object[][] { { true, 0l, 0l }, { true, 1l, 0l }, { false, 0l, 1l }, { true, 1l, 1l },
                            { 0l, 0l, 0l }, { 1l, 1l, 0l }, { -1l, 0l, 1l }, { 0l, 1l, 1l }, { 0d, 0d, 0d },
                            { 1d, 1d, 0d }, { -1d, 0d, 1d }, { 0d, 1d, 1d }, { new Complex(0), 0d, 0d, 0d, 0d },
                            { new Complex(1), 1d, 0d, 0d, 0d }, { new Complex(-1), 0d, 0d, 1d, 0d },
                            { new Complex(0), 1d, 0d, 1d, 0d }, { new Complex(0, 0), 0d, 0d, 0d, 0d },
                            { new Complex(1, 1), 1d, 1d, 0d, 0d }, { new Complex(-1, 1), 0d, 1d, 1d, 0d },
                            { new Complex(0, 0), 1d, 1d, 1d, 1d }, } },
            { BinaryOperation.Multiplication.class,
                    new Object[][] { { false, 0l, 0l }, { false, 1l, 0l }, { false, 0l, 1l }, { true, 1l, 1l },
                            { 0l, 0l, 0l }, { 0l, 1l, 0l }, { 0l, 0l, 1l }, { 2l, 2l, 1l }, { 0d, 0d, 0d },
                            { 0d, 1d, 0d }, { 0d, 0d, 1d }, { 2d, 2d, 1d }, { new Complex(0), 0d, 0d, 0d, 0d },
                            { new Complex(0), 1d, 0d, 0d, 0d }, { new Complex(0), 0d, 0d, 1d, 0d },
                            { new Complex(1), 1d, 0d, 1d, 0d }, { new Complex(0, 0), 0d, 0d, 0d, 0d },
                            { new Complex(0), 1d, 1d, 0d, 0d }, { new Complex(0, 1), 0d, 1d, 1d, 0d },
                            { new Complex(0, 2), 1d, 1d, 1d, 1d }, } },
            { BinaryOperation.Division.class,
                    new Object[][] { { false, 0l, 0l }, { true, 1l, 0l }, { false, 0l, 1l }, { false, 1l, 1l },
                            { 0l, 0l, 0l }, { 0l, 1l, 0l }, { 0l, 0l, 1l }, { 2l, 2l, 1l }, { -2l, -5l, 2l },
                            { -1l, -5l, 3l }, { -2l, 5l, -2l }, { -1l, 5l, -3l }, { 2l, -5l, -2l },
                            { 1l, -5l, -3l }, { Double.NaN, 0d, 0d }, { Double.POSITIVE_INFINITY, 1d, 0d },
                            { 0d, 0d, 1d }, { 2d, 2d, 1d },
                            { new Complex(Double.NaN, Double.NaN), 0d, 0d, 0d, 0d },
                            { new Complex(Double.POSITIVE_INFINITY, Double.NaN), 1d, 0d, 0d, 0d },
                            { new Complex(0), 0d, 0d, 1d, 0d }, { new Complex(1), 1d, 0d, 1d, 0d },
                            { new Complex(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY), 1d, 1d, 0d, 0d },
                            { new Complex(0, 1), 0d, 1d, 1d, 0d }, { new Complex(1, 0), 1d, 1d, 1d, 1d }, } },
            { BinaryOperation.DivisionWithZero.class,
                    new Object[][] { { false, 0l, 0l }, { true, 1l, 0l }, { false, 0l, 1l }, { false, 1l, 1l },
                            { 0l, 0l, 0l }, { 0l, 1l, 0l }, { 0l, 0l, 1l }, { 2l, 2l, 1l },
                            { new Complex(0d), 0d, 0d, 0d, 0d }, { new Complex(0d), 1d, 0d, 0d, 0d },
                            { new Complex(0), 0d, 0d, 1d, 0d }, { new Complex(1), 1d, 0d, 1d, 0d },
                            { new Complex(0d), 1d, 1d, 0d, 0d }, { new Complex(0, 1), 0d, 1d, 1d, 0d },
                            { new Complex(1, 0), 1d, 1d, 1d, 1d }, } },
            { BinaryOperation.DivisionTowardsFloor.class,
                    new Object[][] { { false, 0l, 0l }, { true, 1l, 0l }, { false, 0l, 1l }, { false, 1l, 1l },
                            { 0l, 0l, 0l }, { 0l, 1l, 0l }, { 0l, 0l, 1l }, { 2l, 2l, 1l }, { -3l, -5l, 2l },
                            { -2l, -5l, 3l }, { -3l, 5l, -2l }, { -2l, 5l, -3l }, { 2l, -5l, -2l },
                            { 1l, -5l, -3l }, { Double.NaN, 0d, 0d }, { Double.POSITIVE_INFINITY, 1d, 0d },
                            { 0d, 0d, 1d }, { 2d, 2d, 1d }, { Complex.NaN, 0d, 0d, 0d, 0d },
                            { new Complex(Double.POSITIVE_INFINITY, Double.NaN), 1d, 0d, 0d, 0d },
                            { new Complex(0), 0d, 0d, 1d, 0d }, { new Complex(1), 1d, 0d, 1d, 0d },
                            { Complex.INF, 1d, 1d, 0d, 0d }, { new Complex(0, 1), 0d, 1d, 1d, 0d },
                            { new Complex(1, 0), 1d, 1d, 1d, 1d }, } },
            { BinaryOperation.Remainder.class,
                    new Object[][] { { 0l, 0l, 0l }, { 0l, 1l, 0l }, { 0l, 0l, 1l }, { 0l, 2l, 1l },
                            { -1l, -5l, 2l }, { -2l, -5l, 3l }, { 1l, 5l, -2l }, { 2l, 5l, -3l },
                            { -1l, -5l, -2l }, { -2l, -5l, -3l }, { Double.NaN, 0d, 0d },
                            { Double.NaN, 1d, 0d }, { 0d, 0d, 1d }, { 0d, 2d, 1d }, } },
            { BinaryOperation.Exponentiation.class,
                    new Object[][] { { true, 0l, 0l }, { true, 1l, 0l }, { false, 0l, 1l }, { true, 1l, 1l },
                            { 1l, 0l, 0l }, { 1l, 1l, 0l }, { 0l, 0l, 1l }, { 2l, 2l, 1l }, { 1d, 0d, 0d },
                            { 1d, 1d, 0d }, { 0d, 0d, 1d }, { 2d, 2d, 1d }, { Complex.NaN, 0d, 0d, 0d, 0d },
                            { new Complex(1), 1d, 0d, 0d, 0d }, { Complex.NaN, 0d, 0d, 1d, 0d },
                            { new Complex(1), 1d, 0d, 1d, 0d }, { Complex.NaN, 0d, 0d, 0d, 0d },
                            { new Complex(1), 1d, 1d, 0d, 0d }, { new Complex(0, 1), 0d, 1d, 1d, 0d },
                            { new Complex(C_M * Math.cos(C_A), C_M * Math.sin(C_A)), 1d, 1d, 1d, 1d }, } }, });
}