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

Introduction

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

Prototype

Complex INF

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

Click Source Link

Document

A complex number representing "+INF + INFi"

Usage

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 }, } }, });
}

---