Java Complex.getImaginary方法代碼示例

import org.apache.commons.math3.complex.Complex; //導入方法依賴的package包/類
@Override
public double[] getNetOutput() {
	int i = 3;
	double[] output = new double[2 * i];

	Complex power = getAclfNet().getBranch("Bus5->Bus6(1)").powerFrom2To();
	output[0] = power.getReal();
	output[1] = power.getImaginary();
	power = getAclfNet().getBranch("Bus4->Bus7(1)").powerFrom2To();
	output[2] = power.getReal();
	output[3] = power.getImaginary();
	power = getAclfNet().getBranch("Bus4->Bus9(1)").powerFrom2To();
	output[4] = power.getReal();
	output[5] = power.getImaginary();
	return output;
}
 

import org.apache.commons.math3.complex.Complex; //導入方法依賴的package包/類
public SV otherSide(float r, float x, float g, float b, float ratio) {
    Complex z = new Complex(r, x); // z=r+jx
    Complex y = new Complex(g, b); // y=g+jb
    Complex s1 = new Complex(p, q); // s1=p1+jq1
    Complex u1 = ComplexUtils.polar2Complex(u, Math.toRadians(a));
    Complex v1 = u1.divide(Math.sqrt(3f)); // v1=u1/sqrt(3)

    Complex v1p = v1.multiply(ratio); // v1p=v1*rho
    Complex i1 = s1.divide(v1.multiply(3)).conjugate(); // i1=conj(s1/(3*v1))
    Complex i1p = i1.divide(ratio); // i1p=i1/rho
    Complex i2 = i1p.subtract(y.multiply(v1p)); // i2=i1p-y*v1p
    Complex v2 = v1p.subtract(z.multiply(i2)); // v2=v1p-z*i2
    Complex s2 = v2.multiply(3).multiply(i2.conjugate()); // s2=3*v2*conj(i2)

    Complex u2 = v2.multiply(Math.sqrt(3f));
    return new SV((float) -s2.getReal(), (float) -s2.getImaginary(), (float) u2.abs(), (float) Math.toDegrees(u2.getArgument()));
}
 

import org.apache.commons.math3.complex.Complex; //導入方法依賴的package包/類
static boolean isComplexNumber(String value) {
	
	boolean isComplex = true;
	Complex complex=null;
	try {
		DecimalFormat df = (DecimalFormat)NumberFormat.getNumberInstance(Locale.US);
		df.setGroupingUsed(false);
		
		// Numerical format ###.## (decimal symbol is the point)
		ComplexFormat complexFormat = new ComplexFormat(df);
		complex = complexFormat.parse(value);

	// This is because there is a bug parsing complex number. 9i is parsed as 9
		if (complex.getImaginary() == 0 && value.contains("i")) isComplex = false;
	} catch (Exception e) {
		isComplex = false;
	}

return isComplex;
}
 

import org.apache.commons.math3.complex.Complex; //導入方法依賴的package包/類
public ValueType setComplexValue(Complex c)
{
    real = c.getReal();
    imaginary = c.getImaginary();
    valueType = (imaginary != 0.0) ? ValueType.COMPLEX : ValueType.REAL;
    return valueType;
}
 

import org.apache.commons.math3.complex.Complex; //導入方法依賴的package包/類
@Override
public void complexOperate(double[] out, double ra, double ia, double rb, double ib) {
	Complex c = new Complex(ra, ia);
	c = ib == 0 ? c.pow(rb) : c.pow(new Complex(rb, ib));
	out[0] = c.getReal();
	out[1] = c.getImaginary();
}
 

import org.apache.commons.math3.complex.Complex; //導入方法依賴的package包/類
public StateVariable toSv2(StateVariable sv1) {
    Complex s1 = new Complex(-sv1.p, -sv1.q); // s1=p1+jq1
    Complex u1 = ComplexUtils.polar2Complex(sv1.u, Math.toRadians(sv1.theta));
    Complex v1 = u1.divide(SQUARE_3); // v1=u1/sqrt(3)
    Complex v1p = v1.multiply(ratio); // v1p=v1*rho
    Complex i1 = s1.divide(v1.multiply(3)).conjugate(); // i1=conj(s1/(3*v1))
    Complex i1p = i1.divide(ratio); // i1p=i1/rho
    Complex i2 = i1p.subtract(y.multiply(v1p)).negate(); // i2=-(i1p-y*v1p)
    Complex v2 = v1p.subtract(z.multiply(i2)); // v2=v1p-z*i2
    Complex s2 = v2.multiply(3).multiply(i2.conjugate()); // s2=3*v2*conj(i2)
    Complex u2 = v2.multiply(SQUARE_3);
    return new StateVariable(-s2.getReal(), -s2.getImaginary(), u2.abs(), Math.toDegrees(u2.getArgument()));
}
 

import org.apache.commons.math3.complex.Complex; //導入方法依賴的package包/類
public StateVariable toSv1(StateVariable sv2) {
    Complex s2 = new Complex(-sv2.p, -sv2.q); // s2=p2+jq2
    Complex u2 = ComplexUtils.polar2Complex(sv2.u, Math.toRadians(sv2.theta));
    Complex v2 = u2.divide(SQUARE_3); // v2=u2/sqrt(3)
    Complex i2 = s2.divide(v2.multiply(3)).conjugate(); // i2=conj(s2/(3*v2))
    Complex v1p = v2.add(z.multiply(i2)); // v1'=v2+z*i2
    Complex i1p = i2.negate().add(y.multiply(v1p)); // i1'=-i2+v1'*y
    Complex i1 = i1p.multiply(ratio); // i1=i1p*ration
    Complex v1 = v1p.divide(ratio); // v1=v1p/ration
    Complex s1 = v1.multiply(3).multiply(i1.conjugate()); // s1=3*v1*conj(i1)
    Complex u1 = v1.multiply(SQUARE_3);
    return new StateVariable(-s1.getReal(), -s1.getImaginary(), u1.abs(), Math.toDegrees(u1.getArgument()));
}
 

import org.apache.commons.math3.complex.Complex; //導入方法依賴的package包/類
/*********************************************************
 * Re-implementation for methods for FormulaBase and FormulaTerm superclass's
 *********************************************************/

@Override
public CalculatedValue.ValueType getValue(CalculaterTask thread, CalculatedValue outValue) throws CancelException
{
    if (getFormulaRoot() instanceof Equation)
    {
        Equation eq = (Equation) getFormulaRoot();
        final int argNumber = eq.getArguments() != null ? eq.getArguments().size() : 0;
        String strValue = null;
        if (argNumber == 1 || argNumber == 2)
        {
            final int a0 = eq.getArgumentValue(0).getInteger();
            if (a0 < fileBuffer.size())
            {
                final ArrayList<String> line = fileBuffer.get(a0);
                final int a1 = (argNumber == 1) ? 0 : eq.getArgumentValue(1).getInteger();
                if (a1 < line.size())
                {
                    strValue = line.get(a1);
                }
            }
        }
        if (strValue != null)
        {
            try
            {
                return outValue.setValue(Double.parseDouble(strValue));
            }
            catch (Exception ex)
            {
                // nothing to do: we will try to convert it to complex
            }
            Complex cmplValue = TermParser.complexValueOf(strValue);
            if (cmplValue != null)
            {
                if (cmplValue.getImaginary() != 0.0)
                {
                    return outValue.setComplexValue(cmplValue.getReal(), cmplValue.getImaginary());
                }
                else
                {
                    return outValue.setValue(cmplValue.getReal());
                }
            }
        }
        return outValue.invalidate(CalculatedValue.ErrorType.NOT_A_NUMBER);
    }
    return outValue.invalidate(CalculatedValue.ErrorType.TERM_NOT_READY);
}
 

import org.apache.commons.math3.complex.Complex; //導入方法依賴的package包/類
/**
 * @param z
 *            given value as Complex
 */
public UseIfEqualTo(Complex z) {
	super(z.getReal());
	di = z.getImaginary();
}
 

import org.apache.commons.math3.complex.Complex; //導入方法依賴的package包/類
public Complex interpret() {
	Complex value = sum();
	
	if (current.type != Token.Type.END)
		throw new RuntimeException("Given expression has an invalid syntax");
	
	double real = value.getReal(), imag = value.getImaginary();
	
	real = Tools.round(real);
	imag = Tools.round(imag);
	
	return new Complex(real, imag);
}
 

import org.apache.commons.math3.complex.Complex; //導入方法依賴的package包/類
/**
 * Builds a new two dimensional array of {@code double} filled with the real
 * and imaginary parts of the specified {@link Complex} numbers. In the
 * returned array {@code dataRI}, the data is laid out as follows
 * <ul>
 * <li>{@code dataRI[0][i] = dataC[i].getReal()},</li>
 * <li>{@code dataRI[1][i] = dataC[i].getImaginary()}.</li>
 * </ul>
 *
 * @param dataC the array of {@link Complex} data to be transformed
 * @return a two dimensional array filled with the real and imaginary parts
 *   of the specified complex input
 */
public static double[][] createRealImaginaryArray(final Complex[] dataC) {
    final double[][] dataRI = new double[2][dataC.length];
    final double[] dataR = dataRI[0];
    final double[] dataI = dataRI[1];
    for (int i = 0; i < dataC.length; i++) {
        final Complex c = dataC[i];
        dataR[i] = c.getReal();
        dataI[i] = c.getImaginary();
    }
    return dataRI;
}
 

import org.apache.commons.math3.complex.Complex; //導入方法依賴的package包/類
/**
 * compute and return the mismatch based on the network solution 
 * for bus voltage
 * 
 * @param netVolt network bus voltage solution
 * @return mismatch info string
 */
public double[] getMismatch(double[] netVolt) {
	Complex maxMis= this.trainCaseBuilder.calMismatch(netVolt).maxMis;
	return new double[] {maxMis.getReal(),maxMis.getImaginary()};
}