Java Code Examples for org.apache.commons.math.util.FastMath#atan2()

/**
 * Estimate a first guess of the phase.
 */
private void guessPhi() {
    // initialize the means
    double fcMean = 0;
    double fsMean = 0;

    double currentX = observations[0].getX();
    double currentY = observations[0].getY();
    for (int i = 1; i < observations.length; ++i) {
        // one step forward
        final double previousX = currentX;
        final double previousY = currentY;
        currentX = observations[i].getX();
        currentY = observations[i].getY();
        final double currentYPrime = (currentY - previousY) / (currentX - previousX);

        double omegaX = omega * currentX;
        double cosine = FastMath.cos(omegaX);
        double sine = FastMath.sin(omegaX);
        fcMean += omega * currentY * cosine - currentYPrime * sine;
        fsMean += omega * currentY * sine + currentYPrime * cosine;
    }

    phi = FastMath.atan2(-fsMean, fcMean);
}
 

/** Reset the instance as if built from two points.
 * <p>The line is oriented from p1 to p2</p>
 * @param p1 first point
 * @param p2 second point
 */
public void reset(final Vector2D p1, final Vector2D p2) {
    final double dx = p2.getX() - p1.getX();
    final double dy = p2.getY() - p1.getY();
    final double d = FastMath.hypot(dx, dy);
    if (d == 0.0) {
        angle        = 0.0;
        cos          = 1.0;
        sin          = 0.0;
        originOffset = p1.getY();
    } else {
        angle        = FastMath.PI + FastMath.atan2(-dy, -dx);
        cos          = FastMath.cos(angle);
        sin          = FastMath.sin(angle);
        originOffset = (p2.getX() * p1.getY() - p1.getX() * p2.getY()) / d;
    }
}
 

/**
 * Estimate a first guess of the phase.
 */
private void guessPhi() {
    // initialize the means
    double fcMean = 0;
    double fsMean = 0;

    double currentX = observations[0].getX();
    double currentY = observations[0].getY();
    for (int i = 1; i < observations.length; ++i) {
        // one step forward
        final double previousX = currentX;
        final double previousY = currentY;
        currentX = observations[i].getX();
        currentY = observations[i].getY();
        final double currentYPrime = (currentY - previousY) / (currentX - previousX);

        double omegaX = omega * currentX;
        double cosine = FastMath.cos(omegaX);
        double sine = FastMath.sin(omegaX);
        fcMean += omega * currentY * cosine - currentYPrime * sine;
        fsMean += omega * currentY * sine + currentYPrime * cosine;
    }

    phi = FastMath.atan2(-fsMean, fcMean);
}
 

/** {@inheritDoc} */
public Line apply(final Hyperplane<Euclidean2D> hyperplane) {
    final Line   line    = (Line) hyperplane;
    final double rOffset = c1X * line.cos + c1Y * line.sin + c11 * line.originOffset;
    final double rCos    = cXX * line.cos + cXY * line.sin;
    final double rSin    = cYX * line.cos + cYY * line.sin;
    final double inv     = 1.0 / FastMath.sqrt(rSin * rSin + rCos * rCos);
    return new Line(FastMath.PI + FastMath.atan2(-rSin, -rCos),
                    inv * rCos, inv * rSin,
                    inv * rOffset);
}
 

/** {@inheritDoc} */
public double value(double x, double y) {
    return FastMath.atan2(x, y);
}
 

/**
 * Compute the argument of this complex number.
 * The argument is the angle phi between the positive real axis and
 * the point representing this number in the complex plane.
 * The value returned is between -PI (not inclusive)
 * and PI (inclusive), with negative values returned for numbers with
 * negative imaginary parts.
 * <br/>
 * If either real or imaginary part (or both) is NaN, NaN is returned.
 * Infinite parts are handled as {@code Math.atan2} handles them,
 * essentially treating finite parts as zero in the presence of an
 * infinite coordinate and returning a multiple of pi/4 depending on
 * the signs of the infinite parts.
 * See the javadoc for {@code Math.atan2} for full details.
 *
 * @return the argument of {@code this}.
 */
public double getArgument() {
    return FastMath.atan2(getImaginary(), getReal());
}
 

/**
 * <p>Compute the argument of this complex number.
 * </p>
 * <p>The argument is the angle phi between the positive real axis and the point
 * representing this number in the complex plane. The value returned is between -PI (not inclusive)
 * and PI (inclusive), with negative values returned for numbers with negative imaginary parts.
 * </p>
 * <p>If either real or imaginary part (or both) is NaN, NaN is returned.  Infinite parts are handled
 * as java.Math.atan2 handles them, essentially treating finite parts as zero in the presence of
 * an infinite coordinate and returning a multiple of pi/4 depending on the signs of the infinite
 * parts.  See the javadoc for java.Math.atan2 for full details.</p>
 *
 * @return the argument of this complex number
 */
public double getArgument() {
    return FastMath.atan2(getImaginary(), getReal());
}
 

/**
 * <p>Compute the argument of this complex number.
 * </p>
 * <p>The argument is the angle phi between the positive real axis and the point
 * representing this number in the complex plane. The value returned is between -PI (not inclusive)
 * and PI (inclusive), with negative values returned for numbers with negative imaginary parts.
 * </p>
 * <p>If either real or imaginary part (or both) is NaN, NaN is returned.  Infinite parts are handled
 * as java.Math.atan2 handles them, essentially treating finite parts as zero in the presence of
 * an infinite coordinate and returning a multiple of pi/4 depending on the signs of the infinite
 * parts.  See the javadoc for java.Math.atan2 for full details.</p>
 *
 * @return the argument of this complex number
 */
public double getArgument() {
    return FastMath.atan2(getImaginary(), getReal());
}
 

/**
 * <p>Compute the argument of this complex number.
 * </p>
 * <p>The argument is the angle phi between the positive real axis and the point
 * representing this number in the complex plane. The value returned is between -PI (not inclusive)
 * and PI (inclusive), with negative values returned for numbers with negative imaginary parts.
 * </p>
 * <p>If either real or imaginary part (or both) is NaN, NaN is returned.  Infinite parts are handled
 * as java.Math.atan2 handles them, essentially treating finite parts as zero in the presence of
 * an infinite coordinate and returning a multiple of pi/4 depending on the signs of the infinite
 * parts.  See the javadoc for java.Math.atan2 for full details.</p>
 *
 * @return the argument of this complex number
 */
public double getArgument() {
    return FastMath.atan2(getImaginary(), getReal());
}
 

/**
 * Compute the argument of this complex number.
 * The argument is the angle phi between the positive real axis and
 * the point representing this number in the complex plane.
 * The value returned is between -PI (not inclusive)
 * and PI (inclusive), with negative values returned for numbers with
 * negative imaginary parts.
 * <br/>
 * If either real or imaginary part (or both) is NaN, NaN is returned.
 * Infinite parts are handled as {@code Math.atan2} handles them,
 * essentially treating finite parts as zero in the presence of an
 * infinite coordinate and returning a multiple of pi/4 depending on
 * the signs of the infinite parts.
 * See the javadoc for {@code Math.atan2} for full details.
 *
 * @return the argument of {@code this}.
 */
public double getArgument() {
    return FastMath.atan2(getImaginary(), getReal());
}
 

/**
 * Compute the argument of this complex number.
 * The argument is the angle phi between the positive real axis and
 * the point representing this number in the complex plane.
 * The value returned is between -PI (not inclusive)
 * and PI (inclusive), with negative values returned for numbers with
 * negative imaginary parts.
 * <br/>
 * If either real or imaginary part (or both) is NaN, NaN is returned.
 * Infinite parts are handled as {@code Math.atan2} handles them,
 * essentially treating finite parts as zero in the presence of an
 * infinite coordinate and returning a multiple of pi/4 depending on
 * the signs of the infinite parts.
 * See the javadoc for {@code Math.atan2} for full details.
 *
 * @return the argument of {@code this}.
 */
public double getArgument() {
    return FastMath.atan2(getImaginary(), getReal());
}
 

/**
 * Compute the argument of this complex number.
 * The argument is the angle phi between the positive real axis and
 * the point representing this number in the complex plane.
 * The value returned is between -PI (not inclusive)
 * and PI (inclusive), with negative values returned for numbers with
 * negative imaginary parts.
 * <br/>
 * If either real or imaginary part (or both) is NaN, NaN is returned.
 * Infinite parts are handled as {@code Math.atan2} handles them,
 * essentially treating finite parts as zero in the presence of an
 * infinite coordinate and returning a multiple of pi/4 depending on
 * the signs of the infinite parts.
 * See the javadoc for {@code Math.atan2} for full details.
 *
 * @return the argument of {@code this}.
 */
public double getArgument() {
    return FastMath.atan2(getImaginary(), getReal());
}
 

/**
 * Compute the argument of this complex number.
 * The argument is the angle phi between the positive real axis and
 * the point representing this number in the complex plane.
 * The value returned is between -PI (not inclusive)
 * and PI (inclusive), with negative values returned for numbers with
 * negative imaginary parts.
 * <br/>
 * If either real or imaginary part (or both) is NaN, NaN is returned.
 * Infinite parts are handled as {@code Math.atan2} handles them,
 * essentially treating finite parts as zero in the presence of an
 * infinite coordinate and returning a multiple of pi/4 depending on
 * the signs of the infinite parts.
 * See the javadoc for {@code Math.atan2} for full details.
 *
 * @return the argument of {@code this}.
 */
public double getArgument() {
    return FastMath.atan2(getImaginary(), getReal());
}
 

/** Get the azimuth of the vector.
 * @return azimuth (α) of the vector, between -π and +π
 * @see #Vector3D(double, double)
 */
public double getAlpha() {
    return FastMath.atan2(y, x);
}
 

/** Get the azimuth of the vector.
 * @return azimuth (α) of the vector, between -π and +π
 * @see #Vector3D(double, double)
 */
public double getAlpha() {
  return FastMath.atan2(y, x);
}
 

/**
 * <p>Compute the argument of this complex number.
 * </p>
 * <p>The argument is the angle phi between the positive real axis and the point
 * representing this number in the complex plane. The value returned is between -PI (not inclusive)
 * and PI (inclusive), with negative values returned for numbers with negative imaginary parts.
 * </p>
 * <p>If either real or imaginary part (or both) is NaN, NaN is returned.  Infinite parts are handled
 * as java.Math.atan2 handles them, essentially treating finite parts as zero in the presence of
 * an infinite coordinate and returning a multiple of pi/4 depending on the signs of the infinite
 * parts.  See the javadoc for java.Math.atan2 for full details.</p>
 *
 * @return the argument of this complex number
 */
public double getArgument() {
    return FastMath.atan2(getImaginary(), getReal());
}
 

/** Get the azimuth of the vector.
 * @return azimuth (α) of the vector, between -π and +π
 * @see #Vector3D(double, double)
 */
public double getAlpha() {
    return FastMath.atan2(y, x);
}
 

/**
 * <p>Compute the argument of this complex number.
 * </p>
 * <p>The argument is the angle phi between the positive real axis and the point
 * representing this number in the complex plane. The value returned is between -PI (not inclusive)
 * and PI (inclusive), with negative values returned for numbers with negative imaginary parts.
 * </p>
 * <p>If either real or imaginary part (or both) is NaN, NaN is returned.  Infinite parts are handled
 * as java.Math.atan2 handles them, essentially treating finite parts as zero in the presence of
 * an infinite coordinate and returning a multiple of pi/4 depending on the signs of the infinite
 * parts.  See the javadoc for java.Math.atan2 for full details.</p>
 *
 * @return the argument of this complex number
 */
public double getArgument() {
    return FastMath.atan2(getImaginary(), getReal());
}
 

/**
 * Compute the argument of this complex number.
 * The argument is the angle phi between the positive real axis and
 * the point representing this number in the complex plane.
 * The value returned is between -PI (not inclusive)
 * and PI (inclusive), with negative values returned for numbers with
 * negative imaginary parts.
 * <br/>
 * If either real or imaginary part (or both) is NaN, NaN is returned.
 * Infinite parts are handled as {@code Math.atan2} handles them,
 * essentially treating finite parts as zero in the presence of an
 * infinite coordinate and returning a multiple of pi/4 depending on
 * the signs of the infinite parts.
 * See the javadoc for {@code Math.atan2} for full details.
 *
 * @return the argument of {@code this}.
 */
public double getArgument() {
    return FastMath.atan2(getImaginary(), getReal());
}
 

/**
 * <p>Compute the argument of this complex number.
 * </p>
 * <p>The argument is the angle phi between the positive real axis and the point
 * representing this number in the complex plane. The value returned is between -PI (not inclusive)
 * and PI (inclusive), with negative values returned for numbers with negative imaginary parts.
 * </p>
 * <p>If either real or imaginary part (or both) is NaN, NaN is returned.  Infinite parts are handled
 * as java.Math.atan2 handles them, essentially treating finite parts as zero in the presence of
 * an infinite coordinate and returning a multiple of pi/4 depending on the signs of the infinite
 * parts.  See the javadoc for java.Math.atan2 for full details.</p>
 *
 * @return the argument of this complex number
 */
public double getArgument() {
    return FastMath.atan2(getImaginary(), getReal());
}