程序包 org.hipparchus.complex

类 Complex

java.lang.Object

org.hipparchus.complex.Complex

所有已实现的接口:

Serializable, Comparable<Complex>, CalculusFieldElement<Complex>, FieldElement<Complex>

直接已知子类:

ComplexTest.TestComplex

       public class Complex extends Object implements CalculusFieldElement<Complex>, Comparable<Complex>, Serializable
      

表示复数，即具有实部和虚部的数字。

算术运算的实现根据 Double 的规则处理 NaN 和无限值，即对于具有实部或虚部中的 NaN 的所有实例，equals(java.lang.Object) 是一个等价关系，例如以下被认为是相等的：

• 1 + NaNi
• NaN + i
• NaN + NaNi

请注意，这与浮点数的 IEEE-754 标准相矛盾（根据该标准，如果 x 是 NaN，则测试 x == x 必须失败）。Precision 中的 equals for primitive double 方法符合 IEEE-754，而此类符合 Java 对象类型的标准行为。

另请参阅:

• 序列化表格

字段概要

字段

修饰符和类型	字段	说明
static final Complex	I	-1 的平方根。
static final Complex	INF	表示 "+INF + INFi" 的复数。
static final Complex	MINUS_I	-1 的平方根。
static final Complex	MINUS_ONE	表示 "-1.0 + 0.0i" 的复数。
static final Complex	NaN	表示 "NaN + NaNi" 的复数。
static final Complex	ONE	表示 "1.0 + 0.0i" 的复数。
static final Complex	PI	表示 "π + 0.0i" 的复数。
static final Complex	ZERO	表示 "0.0 + 0.0i" 的复数。

构造器概要

构造器

构造器	说明
Complex(double real)	仅给定实部创建一个复数。
Complex(double real, double imaginary)	给定实部和虚部创建一个复数。

方法概要

修饰符和类型	方法	说明
Complex	abs()	返回此复数的绝对值。
Complex	acos()	计算此复数的反余弦。
Complex	acosh()	反双曲余弦运算。
Complex	add(double addend)	返回一个值为 (this + addend) 的 Complex，其中 addend 被解释为实数。
Complex	add(Complex addend)	返回一个值为 (this + addend) 的 Complex。
Complex	asin()	计算此复数的反正弦。
Complex	asinh()	反双曲正弦运算。
Complex	atan()	计算此复数的反正切。
Complex	atan2(Complex x)	两参数反正切运算。
Complex	atanh()	反双曲正切运算。
Complex	cbrt()	立方根。
Complex	ceil()	获取大于实例的最小整数。
int	compareTo(Complex o)
Complex	conjugate()	返回此复数的共轭。
Complex	copySign(double r)	返回具有参数符号的实例。
Complex	copySign(Complex z)	返回具有参数符号的实例。
Complex	cos()	计算此复数的余弦。
Complex	cosh()	计算此复数的双曲余弦。
protected Complex	createComplex(double realPart, double imaginaryPart)	给定实部和虚部创建一个复数。
Complex	divide(double divisor)	返回一个值为 (this / divisor) 的 Complex，其中 divisor 被解释为实数。
Complex	divide(Complex divisor)	返回一个值为 (this / divisor) 的 Complex。
boolean	equals(Object other)	与另一个对象进行相等性测试。
static boolean	equals(Complex x, Complex y)	如果值按照equals(x, y, 1)定义相等，则返回true。
static boolean	equals(Complex x, Complex y, double eps)	如果实部和虚部都没有双精度值严格在参数之间，或者它们之间的差异在允许误差范围内（包括在内），则返回true。
static boolean	equals(Complex x, Complex y, int maxUlps)	复数对象之间的浮点数相等性测试。
static boolean	equalsWithRelativeTolerance(Complex x, Complex y, double eps)	如果实部和虚部都没有双精度值严格在参数之间，或者它们之间的相对差异小于或等于给定的公差，则返回true。
Complex	exp()	计算此复数的指数函数。
Complex	expm1()	指数减 1。
Complex	floor()	获取小于实例的最大整数。
double	getArgument()	计算此复数的幅角。
ComplexField	getField()	获取实例所属的Field。
double	getImaginary()	访问虚部。
double	getImaginaryPart()	访问虚部。
Complex	getPi()	获取阿基米德常数 π。
double	getReal()	访问实部。
double	getRealPart()	访问实部。
int	hashCode()	为复数获取哈希码。
Complex	hypot(Complex y)	返回三角形的斜边，其两边为 this 和 y - sqrt(this2 +y2)，避免中间溢出或下溢。
boolean	isInfinite()	检查此复数的实部或虚部是否取无限值（Double.POSITIVE_INFINITY 或 Double.NEGATIVE_INFINITY）且两部分都不是 NaN。
boolean	isMathematicalInteger()	检查实例是否为整数（即虚部为零且实部没有小数部分）。
boolean	isNaN()	检查此复数的任一部分或两部分是否为 NaN。
boolean	isReal()	检查实例是否为实数（即虚部为零）。
boolean	isZero()	检查元素是否语义上等于零。
Complex	linearCombination(double[] a, Complex[] b)	计算线性组合。
Complex	linearCombination(double a1, Complex b1, double a2, Complex b2)	计算线性组合。
Complex	linearCombination(double a1, Complex b1, double a2, Complex b2, double a3, Complex b3)	计算线性组合。
Complex	linearCombination(double a1, Complex b1, double a2, Complex b2, double a3, Complex b3, double a4, Complex b4)	计算线性组合。
Complex	linearCombination(Complex[] a, Complex[] b)	计算线性组合。
Complex	linearCombination(Complex a1, Complex b1, Complex a2, Complex b2)	计算线性组合。
Complex	linearCombination(Complex a1, Complex b1, Complex a2, Complex b2, Complex a3, Complex b3)	计算线性组合。
Complex	linearCombination(Complex a1, Complex b1, Complex a2, Complex b2, Complex a3, Complex b3, Complex a4, Complex b4)	计算线性组合。
Complex	log()	计算此复数的自然对数。
Complex	log10()	以 10 为底的对数。
Complex	log1p()	移位自然对数。
Complex	multiply(double factor)	返回一个值为 this * factor 的 Complex，其中 factor 被解释为实数。
Complex	multiply(int factor)	返回一个值为 this * factor 的 Complex，其中 factor 被解释为整数。
Complex	multiply(Complex factor)	返回一个值为 this * factor 的 Complex。
Complex	multiplyMinusI()	计算 this *- -i。
Complex	multiplyPlusI()	计算 this * i。
Complex	negate()	返回一个值为 (-this) 的 Complex。
Complex	newInstance(double realPart)	创建与常数实值对应的实例。
double	norm()	范数。
List<Complex>	nthRoot(int n)	计算此复数的 n 次根。
Complex	pow(double x)	返回将此复数的值提升到x次幂的结果。
Complex	pow(int n)	整数幂运算。
Complex	pow(Complex x)	返回将此复数的值提升到x次幂的结果。
protected final Object	readResolve()	解析反序列化复数对象中的瞬态字段。
Complex	reciprocal()	返回this元素的乘法逆元。
Complex	remainder(double a)	IEEE余数运算符。
Complex	remainder(Complex a)	IEEE余数运算符。
Complex	rint()	获取最接近实例的整数，如果x恰好处于两个整数之间，则获取偶数。
Complex	rootN(int n)	Nth根。
Complex	scalb(int n)	将实例乘以2的幂。
Complex	sign()	计算实例的符号。
Complex	sin()	计算此复数的正弦值。
FieldSinCos<Complex>	sinCos()	组合正弦和余弦运算。
Complex	sinh()	计算此复数的双曲正弦值。
FieldSinhCosh<Complex>	sinhCosh()	组合双曲正弦和余弦运算。
Complex	sqrt()	计算此复数的平方根。
Complex	sqrt1z()	计算此复数的1 - this2的平方根。
Complex	subtract(double subtrahend)	返回一个Complex，其值为(this - 减数)。
Complex	subtract(Complex subtrahend)	返回一个Complex，其值为(this - 减数)。
Complex	tan()	计算此复数的正切值。
Complex	tanh()	计算此复数的双曲正切值。
Complex	toDegrees()	将弧度转换为度，误差小于0.5 ULP
Complex	toRadians()	将度转换为弧度，误差小于0.5 ULP
String	toString()
Complex	ulp()	计算数字的最低有效位（最后一位单位）。
static Complex	valueOf(double realPart)	仅给出实部创建一个复数。
static Complex	valueOf(double realPart, double imaginaryPart)	给出实部和虚部创建一个复数。

从类继承的方法 java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

从接口继承的方法 org.hipparchus.CalculusFieldElement

getExponent, isFinite, round

字段详细资料

I

             public static final Complex I
            

-1的平方根。表示为"0.0 + 1.0i"的数字。

MINUS_I

             public static final Complex MINUS_I
            

-1的平方根。表示为"0.0 - 1.0i"的数字。

从以下版本开始:

1.7

NaN

             public static final Complex NaN
            

一个表示"NaN + NaNi"的复数。

INF

             public static final Complex INF
            

一个表示"+INF + INFi"的复数。

ONE

             public static final Complex ONE
            

一个表示"1.0 + 0.0i"的复数。

MINUS_ONE

             public static final Complex MINUS_ONE
            

一个表示"-1.0 + 0.0i"的复数。

从以下版本开始:

1.7

ZERO

             public static final Complex ZERO
            

一个表示"0.0 + 0.0i"的复数。

PI

             public static final Complex PI
            

一个表示"π + 0.0i"的复数。

构造器详细资料

Complex

             public Complex(double real)
            

仅给出实部创建一个复数。

参数:

real - 实部。

Complex

             public Complex(double real, double imaginary)
            

给出实部和虚部创建一个复数。

参数:

real - 实部。

imaginary - 虚部。

方法详细资料

abs

             public Complex abs()
            

返回此复数的绝对值。如果实部或虚部中有一个是NaN，则返回NaN，如果两部分都不是NaN但至少有一部分是无穷大，则返回Double.POSITIVE_INFINITY。

指定者:

abs 在接口中 CalculusFieldElement<Complex>

返回:

范数。

从以下版本开始:

2.0

norm

             public double norm()
            

范数。

指定者:

norm 在接口中 CalculusFieldElement<Complex>

返回:

norm(this)

add

             public Complex add(Complex addend) throws NullArgumentException
            

返回一个Complex，其值为(this + 加数)。使用定义公式

(a + bi) + (c + di) = (a+c) + (b+d)i

如果this或addend的任一部分具有NaN值，则返回NaN；否则根据Double算术规则，在结果的部分中返回Infinite和NaN值。

指定者:

add 在接口中 FieldElement<Complex>

参数:

addend - 要添加到此Complex的值。

返回:

this + addend。

抛出:

NullArgumentException - 如果addend为null。

add

             public Complex add(double addend)
            

返回一个Complex，其值为(this + addend)，将addend解释为实数。

指定者:

add 在接口中 CalculusFieldElement<Complex>

参数:

addend - 要添加到此Complex的值。

返回:

this + addend。

另请参阅:

• add(Complex)

conjugate

             public Complex conjugate()
            

返回此复数的共轭。 a + bi的共轭是a - bi。

如果此复数的实部或虚部之一等于Double.NaN，则返回NaN。

如果虚部是无穷大，并且实部不是NaN，则返回值的虚部具有相反符号的无穷大部分，例如1 + POSITIVE_INFINITY i的共轭是1 - NEGATIVE_INFINITY i。

返回:

此复数对象的共轭。

divide

             public Complex divide(Complex divisor) throws NullArgumentException
            

返回一个Complex，其值为(this / 除数)。实现定义公式

  
    a + bi          ac + bd + (bc - ad)i
    ----------- = -------------------------
    c + di         c2 + d2
  
 

但使用操作数的预缩放来限制计算中的溢出和下溢的影响。

根据以下规则处理Infinite和NaN值，按照提出的顺序应用：

• 如果this或divisor的任一部分具有NaN值，则返回NaN。
• 如果divisor等于ZERO，则返回NaN。
• 如果this和divisor都是无穷大，则返回NaN。
• 如果this是有限的（即没有Infinite或NaN部分），并且divisor是无穷大（一个或两个部分无穷大），则返回ZERO。
• 如果this是无穷大，divisor是有限的，则根据应用于定义公式的Double规则，如果结果强制为NaN，则在结果的部分中返回NaN值。

指定者:

divide 在接口中 FieldElement<Complex>

参数:

divisor - 要除以此Complex的值。

返回:

this / divisor。

抛出:

NullArgumentException - 如果divisor为null。

divide

             public Complex divide(double divisor)
            

返回一个Complex，其值为(this / 除数)，将divisor解释为实数。

指定者:

divide 在接口中 CalculusFieldElement<Complex>

参数:

divisor - 要除以此Complex的值。

返回:

this / divisor。

另请参阅:

• divide(Complex)

reciprocal

             public Complex reciprocal()
            

返回this元素的乘法逆元。

指定者:

reciprocal 在接口中 CalculusFieldElement<Complex>

指定者:

reciprocal 在接口中 FieldElement<Complex>

返回:

this的倒数。

equals

             public boolean equals(Object other)
            

与另一个对象进行相等性测试。如果两个复数的实部和虚部完全相同，并且都不是Double.NaN，则认为这两个复数对象是相等的。行为与JDK的Double的equals(java.lang.Object)相同：

• 所有的NaN值都被认为是相等的，即如果复数的实部和虚部中的任一部分（或两者）等于Double.NaN，则该复数等于NaN。
• 使用不同表示的零（即“0”或“-0”）构造的实例不被视为相等。

覆盖:

equals 在类中 Object

参数:

other - 用于与此实例进行相等性测试的对象。

返回:

如果对象相等，则返回true，如果对象为null、不是Complex的实例或与此实例不相等，则返回false。

equals

             public static boolean equals(Complex x, Complex y, int maxUlps)
            

浮点数等式测试Complex对象之间的相等性。如果两个参数相等或在允许误差范围内（包括边界），则返回true。

参数:

x - 第一个值（不能为null）。

y - 第二个值（不能为null）。

maxUlps - (maxUlps - 1)是x和y的实部（或虚部）之间的浮点值数量。

返回:

如果x和y的实部（或虚部）之间的浮点值少于maxUlps，则返回true。

另请参阅:

• Precision.equals(double,double,int)

equals

             public static boolean equals(Complex x, Complex y)
            

返回true，如果值按照equals(x, y, 1)定义相等。

参数:

x - 第一个值（不能为null）。

y - 第二个值（不能为null）。

返回:

如果值相等，则返回true。

equals

             public static boolean equals(Complex x, Complex y, double eps)
            

如果对于实部和虚部，参数之间没有严格的双精度值，或它们之间的差值在允许误差范围内（包括边界），则返回true。如果任一参数为NaN，则返回false。

参数:

x - 第一个值（不能为null）。

y - 第二个值（不能为null）。

eps - 允许的绝对误差量。

返回:

如果值是两个相邻的浮点数，或它们在彼此范围内，则返回true。

另请参阅:

• Precision.equals(double,double,double)

equalsWithRelativeTolerance

             public static boolean equalsWithRelativeTolerance(Complex x, Complex y, double eps)
            

如果对于实部和虚部，参数之间没有严格的双精度值，或它们之间的相对差值小于或等于给定的容差，则返回true。如果任一参数为NaN，则返回false。

参数:

x - 第一个值（不能为null）。

y - 第二个值（不能为null）。

eps - 允许的相对误差量。

返回:

如果值是两个相邻的浮点数，或它们在彼此范围内，则返回true。

另请参阅:

• Precision.equalsWithRelativeTolerance(double,double,double)

hashCode

             public int hashCode()
            

获取复数的哈希码。实部或虚部中的任何Double.NaN值都会产生相同的哈希码7。

覆盖:

hashCode 在类中 Object

返回:

该对象的哈希码值。

isZero

             public boolean isZero()
            

检查元素是否在语义上等于零。

默认实现只是调用equals(getField().getZero())。但是，在某些情况下可能需要覆盖此方法，因为由于与hashCode()的兼容性，一些类以equals(Object)的方式实现，使得-0.0和+0.0是不同的，这可能是一个问题。例如，在LU分解的部分主元选取中，这可以防止识别对角线元素为零，应在这种情况下避免。

此实现认为+0.0和-0.0在实部和虚部上都是相等的。

指定者:

isZero 在接口中 FieldElement<Complex>

返回:

如果元素在语义上等于零，则返回true

从以下版本开始:

1.8

getImaginary

             public double getImaginary()
            

访问虚部。

返回:

虚部。

getImaginaryPart

             public double getImaginaryPart()
            

访问虚部。

返回:

虚部。

从以下版本开始:

2.0

getReal

             public double getReal()
            

访问实部。

指定者:

getReal 在接口中 FieldElement<Complex>

返回:

实部。

getRealPart

             public double getRealPart()
            

访问实部。

返回:

实部。

从以下版本开始:

2.0

isNaN

             public boolean isNaN()
            

检查此复数的实部或虚部是否为NaN。

指定者:

isNaN 在接口中 CalculusFieldElement<Complex>

返回:

如果此复数的实部或虚部中有一个或两个是NaN，则返回true；否则返回false。

isReal

             public boolean isReal()
            

检查实例是否为实数（即虚部为零）。

返回:

如果虚部为零，则返回true

从以下版本开始:

1.7

isMathematicalInteger

             public boolean isMathematicalInteger()
            

检查实例是否为整数（即虚部为零且实部没有小数部分）。

返回:

如果虚部为零且实部没有小数部分，则返回true

从以下版本开始:

1.7

isInfinite

             public boolean isInfinite()
            

检查此复数的实部或虚部是否取无限值（即Double.POSITIVE_INFINITY或Double.NEGATIVE_INFINITY）且两部分都不是NaN。

指定者:

isInfinite 在接口中 CalculusFieldElement<Complex>

返回:

如果此复数的一部分或两部分都是无限的且两部分都不是NaN，则返回true。

multiply

             public Complex multiply(Complex factor) throws NullArgumentException
            

返回一个值为this * factor的Complex。实现了对NaN和无穷大的初步检查，然后按照定义公式进行计算：

(a + bi)(c + di) = (ac - bd) + (ad + bc)i

如果this或factor中有一个或多个NaN部分，则返回NaN。

如果this和factor都没有一个或多个NaN部分，并且this或factor中有一个或多个无限部分（无论组件的符号如何），则返回INF。

在所有其他情况下，根据定义公式返回结果的组件中的有限值。

指定者:

multiply 在接口中 FieldElement<Complex>

参数:

factor - 要乘以此Complex的值。

返回:

this * factor。

抛出:

NullArgumentException - 如果factor为null。

multiply

             public Complex multiply(int factor)
            

返回一个值为this * factor的Complex，其中factor被解释为整数。

指定者:

multiply 在接口中 FieldElement<Complex>

参数:

factor - 要乘以此Complex的值。

返回:

this * factor。

另请参阅:

• multiply(Complex)

multiply

             public Complex multiply(double factor)
            

返回一个值为this * factor的Complex，其中factor被解释为实数。

指定者:

multiply 在接口中 CalculusFieldElement<Complex>

参数:

factor - 与此Complex相乘的值。

返回:

this * factor。

另请参阅:

• multiply(Complex)

multiplyPlusI

             public Complex multiplyPlusI()
            

计算此 * i。

返回:

this * i

从以下版本开始:

2.0

multiplyMinusI

             public Complex multiplyMinusI()
            

计算此 *- -i。

返回:

this * i

从以下版本开始:

2.0

negate

             public Complex negate()
            

返回一个值为Complex的对象，其值为(-this)。如果此复数的实部或虚部中有一个为Double.NaN，则返回NaN。

指定者:

negate 在接口中 FieldElement<Complex>

返回:

-this。

subtract

             public Complex subtract(Complex subtrahend) throws NullArgumentException
            

返回一个值为Complex的对象，其值为(this - subtrahend)。使用定义公式

(a + bi) - (c + di) = (a-c) + (b-d)i

如果this或subtrahend的任一部分为NaN值，则返回NaN；否则，根据Double算术规则，结果的部分中返回无限和NaN值。

指定者:

subtract 在接口中 FieldElement<Complex>

参数:

subtrahend - 从此Complex中减去的值。

返回:

this - subtrahend。

抛出:

NullArgumentException - 如果subtrahend为null。

subtract

             public Complex subtract(double subtrahend)
            

返回一个值为Complex的对象，其值为(this - subtrahend)。

指定者:

subtract 在接口中 CalculusFieldElement<Complex>

参数:

subtrahend - 从此Complex中减去的值。

返回:

this - subtrahend。

另请参阅:

• subtract(Complex)

acos

             public Complex acos()
            

计算此复数的反余弦。实现公式：

acos(z) = -i (log(z + i (sqrt(1 - z<sup>2</sup>))))

如果输入参数的实部或虚部中有一个为NaN或无穷大，则返回NaN。

指定者:

acos 在接口中 CalculusFieldElement<Complex>

返回:

此复数的反余弦。

asin

             public Complex asin()
            

计算此复数的反正弦。实现公式：

asin(z) = -i (log(sqrt(1 - z<sup>2</sup>) + iz))

如果输入参数的实部或虚部中有一个为NaN或无穷大，则返回NaN。

指定者:

asin 在接口中 CalculusFieldElement<Complex>

返回:

此复数的反正弦。

atan

             public Complex atan()
            

计算此复数的反正切。实现公式：

atan(z) = (i/2) log((1 - iz)/(1 + iz))

如果输入参数的实部或虚部中有一个为NaN或无穷大，则返回NaN。

指定者:

atan 在接口中 CalculusFieldElement<Complex>

返回:

此复数的反正切

cos

             public Complex cos()
            

计算此复数的余弦。实现公式：

cos(a + bi) = cos(a)cosh(b) - sin(a)sinh(b)i

其中右侧的（实）函数为FastMath.sin(double)、FastMath.cos(double)、FastMath.cosh(double)和FastMath.sinh(double)。

如果输入参数的实部或虚部中有一个为NaN，则返回NaN。

输入的实部或虚部中的无限值可能导致结果的部分返回无限或NaN值。

  例子:
  
   cos(1 ± INFINITY i) = 1 ∓ INFINITY i
   cos(±INFINITY + i) = NaN + NaN i
   cos(±INFINITY ± INFINITY i) = NaN + NaN i
  
 

指定者:

cos 在接口中 CalculusFieldElement<Complex>

返回:

此复数的余弦。

cosh

             public Complex cosh()
            

计算此复数的双曲余弦。实现公式：

  
   cosh(a + bi) = cosh(a)cos(b) + sinh(a)sin(b)i
  
 

其中右侧的（实）函数为FastMath.sin(double)、FastMath.cos(double)、FastMath.cosh(double)和FastMath.sinh(double)。

如果输入参数的实部或虚部中有一个为NaN，则返回NaN。

输入的实部或虚部中的无限值可能导致结果的部分返回无限或NaN值。

  例子:
  
   cosh(1 ± INFINITY i) = NaN + NaN i
   cosh(±INFINITY + i) = INFINITY ± INFINITY i
   cosh(±INFINITY ± INFINITY i) = NaN + NaN i
  
 

指定者:

cosh 在接口中 CalculusFieldElement<Complex>

返回:

此复数的双曲余弦。

exp

             public Complex exp()
            

计算此复数的指数函数。实现公式：

  
   exp(a + bi) = exp(a)cos(b) + exp(a)sin(b)i
  
 

其中右侧的（实）函数为FastMath.exp(double)、FastMath.cos(double)和FastMath.sin(double)。

如果输入参数的实部或虚部中有一个为NaN，则返回NaN。

输入的实部或虚部中的无限值可能导致结果的部分返回无限或NaN值。

  例子:
  
   exp(1 ± INFINITY i) = NaN + NaN i
   exp(INFINITY + i) = INFINITY + INFINITY i
   exp(-INFINITY + i) = 0 + 0i
   exp(±INFINITY ± INFINITY i) = NaN + NaN i
  
 

指定者:

exp 在接口中 CalculusFieldElement<Complex>

返回:

ethis。

expm1

             public Complex expm1()
            

指数减1。

指定者:

expm1 在接口中 CalculusFieldElement<Complex>

返回:

实例的指数减一

从以下版本开始:

1.7

log

             public Complex log()
            

计算此复数的自然对数。实现公式：

  
   log(a + bi) = ln(|a + bi|) + arg(a + bi)i
  
 

其中右侧的ln是FastMath.log(double)，|a + bi|是模，abs()，而arg(a + bi) = FastMath.atan2(double, double)(b, a)。

如果输入参数的实部或虚部为NaN，则返回NaN。

实部或虚部中的无限（或临界）值可能导致结果的某些部分返回无限或NaN值。

  示例:
  
   log(1 ± 无穷大 i) = 无穷大 ± (π/2)i
   log(无穷大 + i) = 无穷大 + 0i
   log(-无穷大 + i) = 无穷大 + πi
   log(无穷大 ± 无穷大 i) = 无穷大 ± (π/4)i
   log(-无穷大 ± 无穷大 i) = 无穷大 ± (3π/4)i
   log(0 + 0i) = -无穷大 + 0i
  
 

指定者:

log 在接口中 CalculusFieldElement<Complex>

返回:

值ln this，即this的自然对数。

log1p

             public Complex log1p()
            

移位自然对数。

指定者:

log1p 在接口中 CalculusFieldElement<Complex>

返回:

实例的自然对数加一

从以下版本开始:

1.7

log10

             public Complex log10()
            

底数为10的对数。

指定者:

log10 在接口中 CalculusFieldElement<Complex>

返回:

实例的以10为底的对数

从以下版本开始:

1.7

pow

             public Complex pow(Complex x) throws NullArgumentException
            

返回此复数的值的x次幂。

如果x是一个实数，其实部具有整数值，则返回pow(int)，如果this和x都是实数，并且使用相应的实数参数调用FastMath.pow(double, double)会返回一个有限数（既不是NaN也不是无穷大），则返回转换为Complex的相同值，具有相同的特殊情况。在所有其他情况下，实现y^x = exp(x·log(y))。

指定者:

pow 在接口中 CalculusFieldElement<Complex>

参数:

x - 要将此Complex提升为的指数。

返回:

thisx。

抛出:

NullArgumentException - 如果x为null。

pow

             public Complex pow(double x)
            

返回此复数的值的x次幂。

如果x具有整数值，则返回pow(int)，如果this是实数，并且使用相应的实数参数调用FastMath.pow(double, double)会返回一个有限数（既不是NaN也不是无穷大），则返回转换为Complex的相同值，具有相同的特殊情况。在所有其他情况下，实现y^x = exp(x·log(y))。

指定者:

pow 在接口中 CalculusFieldElement<Complex>

参数:

x - 要将此Complex提升为的指数。

返回:

thisx。

pow

             public Complex pow(int n)
            

整数幂运算。

指定者:

pow 在接口中 CalculusFieldElement<Complex>

参数:

n - 要应用的幂

返回:

thisⁿ

从以下版本开始:

1.7

sin

             public Complex sin()
            

计算此复数的正弦。实现公式：

  
   sin(a + bi) = sin(a)cosh(b) + cos(a)sinh(b)i
  
 

其中右侧的（实）函数是FastMath.sin(double)，FastMath.cos(double)，FastMath.cosh(double)和FastMath.sinh(double)。

如果输入参数的实部或虚部为NaN，则返回NaN。

实部或虚部中的无限值可能导致结果的某些部分返回无限或NaN值。

  示例:
  
   sin(1 ± 无穷大 i) = 1 ± 无穷大 i
   sin(±无穷大 + i) = NaN + NaN i
   sin(±无穷大 ± 无穷大 i) = NaN + NaN i
  
 

指定者:

sin 在接口中 CalculusFieldElement<Complex>

返回:

此复数的正弦值。

sinCos

             public FieldSinCos<Complex> sinCos()
            

组合正弦和余弦运算。

指定者:

sinCos 在接口中 CalculusFieldElement<Complex>

返回:

[sin(this), cos(this)]

atan2

             public Complex atan2(Complex x)
            

两参数反正切运算。

注意参数的顺序！由于这是基于两个参数的函数，为了与参数顺序保持一致，实例是第一个参数，而提供的单个参数是第二个参数。为了与编程语言atan2保持一致，此方法计算atan2(this, x)，即实例表示y参数，而传递的x参数是作为单个参数传递的。这可能看起来令人困惑，特别是对于Wolfram alpha的用户，因为该站点与编程语言atan2的两参数反正切不一致，并将x作为其第一个参数。

指定者:

atan2 在接口中 CalculusFieldElement<Complex>

参数:

x - 反正切的第二个参数

返回:

atan2(this, x)

从以下版本开始:

1.7

acosh

             public Complex acosh()
            

反双曲余弦运算。

分支切割在实轴上，低于+1。

指定者:

acosh 在接口中 CalculusFieldElement<Complex>

返回:

acosh(this)

从以下版本开始:

1.7

asinh

             public Complex asinh()
            

反双曲正弦运算。

分支切割在虚轴上，高于+i且低于-i。

指定者:

asinh 在接口中 CalculusFieldElement<Complex>

返回:

asin(this)

从以下版本开始:

1.7

atanh

             public Complex atanh()
            

反双曲正切运算。

分支切割在实轴上，高于+1且低于-1。

指定者:

atanh 在接口中 CalculusFieldElement<Complex>

返回:

atanh(this)

从以下版本开始:

1.7

sinh

             public Complex sinh()
            

计算此复数的双曲正弦。实现公式：

  
   sinh(a + bi) = sinh(a)cos(b)) + cosh(a)sin(b)i
  
 

其中右侧的（实）函数是FastMath.sin(double)，FastMath.cos(double)，FastMath.cosh(double)和FastMath.sinh(double)。

如果输入参数的实部或虚部为NaN，则返回NaN。

实部或虚部中的无限值可能导致结果的某些部分返回无限或NaN值。

  示例:
  
   sinh(1 ± 无穷大 i) = NaN + NaN i
   sinh(±无穷大 + i) = ± 无穷大 + 无穷大 i
   sinh(±无穷大 ± 无穷大 i) = NaN + NaN i
  
 

</

指定者:

sinh 在接口中 CalculusFieldElement<Complex>

返回:

this的双曲正弦。

sinhCosh

             public FieldSinhCosh<Complex> sinhCosh()
            

组合双曲正弦和双曲余弦操作。

指定者:

sinhCosh 在接口中 CalculusFieldElement<Complex>

返回:

[sinh(this), cosh(this)]

sqrt

             public Complex sqrt()
            

计算此复数的平方根。实现以下算法来计算sqrt(a + bi)：

1. 令t = sqrt((|a| + |a + bi|) / 2)

2. 如果 a ≥ 0，返回t + (b/2t)i
     否则返回|b|/2t + sign(b)t i 

其中

• |a| = abs(a)
• |a + bi| = hypot(a, b)
• sign(b) = copySign(1, b)

因此，实部始终为非负数。

如果输入参数的实部或虚部为NaN，则返回NaN。

输入的实部或虚部中的无限值可能导致结果的部分为无限或NaN值。

  例子:
  
   sqrt(1 ± ∞ i) = ∞ + NaN i
   sqrt(∞ + i) = ∞ + 0i
   sqrt(-∞ + i) = 0 + ∞ i
   sqrt(∞ ± ∞ i) = ∞ + NaN i
   sqrt(-∞ ± ∞ i) = NaN ± ∞ i
  
 

指定者:

sqrt 在接口中 CalculusFieldElement<Complex>

返回:

this的平方根，实部为非负数。

sqrt1z

             public Complex sqrt1z()
            

计算此复数的1 - this2的平方根。直接计算结果为sqrt(ONE.subtract(z.multiply(z)))。

如果输入参数的实部或虚部为NaN，则返回NaN。

输入的实部或虚部中的无限值可能导致结果的部分为无限或NaN值。

返回:

1 - this2的平方根。

cbrt

             public Complex cbrt()
            

立方根。

此实现通过沿着实负轴的分支切割计算主立方根。

指定者:

cbrt 在接口中 CalculusFieldElement<Complex>

返回:

实例的立方根

从以下版本开始:

1.7

rootN

             public Complex rootN(int n)
            

N^th根。

此实现通过沿着实负轴的分支切割计算主n^th根。

指定者:

rootN 在接口中 CalculusFieldElement<Complex>

参数:

n - 根的阶数

返回:

实例的n^th根

从以下版本开始:

1.7

tan

             public Complex tan()
            

计算此复数的tan。

实现公式：

  
   tan(a + bi) = sin(2a)/(cos(2a)+cosh(2b)) + [sinh(2b)/(cos(2a)+cosh(2b))]i
  
 

其中右侧的（实）函数为FastMath.sin(double)、FastMath.cos(double)、FastMath.cosh(double)和FastMath.sinh(double)。

如果输入参数的实部或虚部为NaN，则返回NaN。

输入的实部或虚部中的无限（或临界）值可能导致结果的部分为无限或NaN值。

  例子:
  
   tan(a ± INFINITY i) = 0 ± i
   tan(±INFINITY + bi) = NaN + NaN i
   tan(±INFINITY ± INFINITY i) = NaN + NaN i
   tan(±π/2 + 0 i) = ±INFINITY + NaN i
  
 

指定者:

tan 在接口中 CalculusFieldElement<Complex>

返回:

this的正切。

tanh

             public Complex tanh()
            

计算此复数的双曲正切。

实现公式：

  
   tan(a + bi) = sinh(2a)/(cosh(2a)+cos(2b)) + [sin(2b)/(cosh(2a)+cos(2b))]i
  
 

其中右侧的（实）函数为FastMath.sin(double)、FastMath.cos(double)、FastMath.cosh(double)和FastMath.sinh(double)。

如果输入参数的实部或虚部为NaN，则返回NaN。

输入的实部或虚部中的无限值可能导致结果的部分为无限或NaN值。

  例子:
  
   tanh(a ± INFINITY i) = NaN + NaN i
   tanh(±INFINITY + bi) = ±1 + 0 i
   tanh(±INFINITY ± INFINITY i) = NaN + NaN i
   tanh(0 + (π/2)i) = NaN + INFINITY i
  
 

指定者:

tanh 在接口中 CalculusFieldElement<Complex>

返回:

this的双曲正切。

getArgument

             public double getArgument()
            

计算此复数的幅角。幅角是正实轴和表示复平面中此数的点之间的角度phi。返回的值在-PI（不包括）和PI（包括）之间，对于具有负虚部的数字返回负值。

如果实部或虚部（或两者）为NaN，则返回NaN。无限部分的处理方式类似于Math.atan2处理它们，基本上在存在无限坐标的情况下将有限部分视为零，并根据无限部分的符号返回pi/4的倍数。有关完整详细信息，请参阅Math.atan2的javadoc。

返回:

this的幅角。

nthRoot

             public List<Complex> nthRoot(int n) throws MathIllegalArgumentException
            

计算此复数的n次根。n次根由以下公式定义：

  
   zk = abs1/n (cos(phi + 2πk/n) + i (sin(phi + 2πk/n))
  
 

对于k=0, 1, ..., n-1，其中abs和phi分别是此复数的模和幅角。

如果此复数的一个或两个部分为NaN，则返回一个只包含一个元素NaN的列表。如果两个部分都不是NaN，但至少有一个部分是无限的，则结果是一个包含INF的一个元素列表。

参数:

n - 根的次数。

返回:

所有n次根的列表。

抛出:

MathIllegalArgumentException - 如果n <= 0。

createComplex

             protected Complex createComplex(double realPart, double imaginaryPart)
            

给定实部和虚部创建一个复数。

参数:

realPart - 实部。

imaginaryPart - 虚部。

返回:

一个新的复数实例。

另请参阅:

• valueOf(double, double)

valueOf

             public static Complex valueOf(double realPart, double imaginaryPart)
            

给定实部和虚部创建一个复数。

参数:

realPart - 实部。

imaginaryPart - 虚部。

返回:

一个复数实例。

valueOf

             public static Complex valueOf(double realPart)
            

仅给定实部创建一个复数。

参数:

realPart - 实部。

返回:

一个复数实例。

newInstance

             public Complex newInstance(double realPart)
            

创建与常数实值对应的实例。

指定者:

newInstance 在接口中 CalculusFieldElement<Complex>

参数:

realPart - 常数实值

返回:

与常数实值对应的实例

readResolve

             protected final Object readResolve()
            

解析反序列化的复数对象中的瞬态字段。子类将需要重写createComplex(double, double)以正确反序列化。

返回:

所有字段都已解析的复数实例。

getField

             public ComplexField getField()
            

获取实例所属的Field。

指定者:

getField 在接口中 FieldElement<Complex>

返回:

Field 实例所属的字段

toString

             public String toString()
            

覆盖:

toString 在类中 Object

scalb

             public Complex scalb(int n)
            

将实例乘以2的幂。

指定者:

scalb 在接口中 CalculusFieldElement<Complex>

参数:

n - 2的幂

返回:

this × 2ⁿ

从以下版本开始:

1.7

ulp

             public Complex ulp()
            

计算数字的最低有效位（最后一位单位）。

指定者:

ulp 在接口中 CalculusFieldElement<Complex>

返回:

ulp(this)

hypot

             public Complex hypot(Complex y)
            

返回三角形的斜边，其两边为this和y - sqrt(this² +y²)，避免中间溢出或下溢。

• 如果任一参数为无穷大，则结果为正无穷大。
• 否则，如果任一参数为NaN，则结果为NaN。

指定者:

hypot 在接口中 CalculusFieldElement<Complex>

参数:

y - 一个值

返回:

sqrt(this² +y²)

从以下版本开始:

1.7

linearCombination

             public Complex linearCombination(Complex[] a, Complex[] b) throws MathIllegalArgumentException
            

计算线性组合。

指定者:

linearCombination 在接口中 CalculusFieldElement<Complex>

参数:

a - 因子。

b - 因子。

返回:

Σi ai bi。

抛出:

MathIllegalArgumentException - 如果数组维度不匹配

从以下版本开始:

1.7

linearCombination

             public Complex linearCombination(double[] a, Complex[] b) throws MathIllegalArgumentException
            

计算线性组合。

指定者:

linearCombination 在接口中 CalculusFieldElement<Complex>

参数:

a - 因子。

b - 因子。

返回:

Σi ai bi。

抛出:

MathIllegalArgumentException - 如果数组维度不匹配

从以下版本开始:

1.7

linearCombination

             public Complex linearCombination(Complex a1, Complex b1, Complex a2, Complex b2)
            

计算线性组合。

指定者:

linearCombination 在接口中 CalculusFieldElement<Complex>

参数:

a1 - 第一项的第一个因子

b1 - 第一项的第二个因子

a2 - 第二项的第一个因子

b2 - 第二项的第二个因子

返回:

a₁×b₁ + a₂×b₂

从以下版本开始:

1.7

另请参阅:

• CalculusFieldElement.linearCombination(FieldElement, FieldElement, FieldElement, FieldElement, FieldElement, FieldElement)
• CalculusFieldElement.linearCombination(FieldElement, FieldElement, FieldElement, FieldElement, FieldElement, FieldElement, FieldElement, FieldElement)

linearCombination

             public Complex linearCombination(double a1, Complex b1, double a2, Complex b2)
            

计算线性组合。

指定者:

linearCombination 在接口中 CalculusFieldElement<Complex>

参数:

a1 - 第一项的第一个因子

b1 - 第一项的第二个因子

a2 - 第二项的第一个因子

b2 - 第二项的第二个因子

返回:

a₁×b₁ + a₂×b₂

从以下版本开始:

1.7

另请参阅:

• CalculusFieldElement.linearCombination(double, FieldElement, double, FieldElement, double, FieldElement)
• CalculusFieldElement.linearCombination(double, FieldElement, double, FieldElement, double, FieldElement, double, FieldElement)

linearCombination

             public Complex linearCombination(Complex a1, Complex b1, Complex a2, Complex b2, Complex a3, Complex b3)
            

计算线性组合。

指定者:

linearCombination 在接口中 CalculusFieldElement<Complex>

参数:

a1 - 第一项的第一个因子

b1 - 第一项的第二个因子

a2 - 第二项的第一个因子

b2 - 第二项的第二个因子

a3 - 第三项的第一个因子

b3 - 第三项的第二个因子

返回:

a₁×b₁ + a₂×b₂ + a₃×b₃

从以下版本开始:

1.7

另请参阅:

• CalculusFieldElement.linearCombination(FieldElement, FieldElement, FieldElement, FieldElement)
• CalculusFieldElement.linearCombination(FieldElement, FieldElement, FieldElement, FieldElement, FieldElement, FieldElement, FieldElement, FieldElement)

linearCombination

             public Complex linearCombination(double a1, Complex b1, double a2, Complex b2, double a3, Complex b3)
            

计算线性组合。

指定者:

linearCombination 在接口中 CalculusFieldElement<Complex>

参数:

a1 - 第一项的第一个因子

b1 - 第一项的第二个因子

a2 - 第二项的第一个因子

b2 - 第二项的第二个因子

a3 - 第三项的第一个因子

b3 - 第三项的第二个因子

返回:

a₁×b₁ + a₂×b₂ + a₃×b₃

从以下版本开始:

1.7

另请参阅:

• CalculusFieldElement.linearCombination(double, FieldElement, double, FieldElement)
• CalculusFieldElement.linearCombination(double, FieldElement, double, FieldElement, double, FieldElement, double, FieldElement)

linearCombination

             public Complex linearCombination(Complex a1, Complex b1, Complex a2, Complex b2, Complex a3, Complex b3, Complex a4, Complex b4)
            

计算线性组合。

指定者:

linearCombination 在接口中 CalculusFieldElement<Complex>

参数:

a1 - 第一项的第一个因子

b1 - 第一项的第二个因子

a2 - 第二项的第一个因子

b2 - 第二项的第二个因子

a3 - 第三项的第一个因子

b3 - 第三项的第二个因子

a4 - 第四项的第一个因子

b4 - 第四项的第二个因子

返回:

a₁×b₁

linearCombination

             public Complex linearCombination(double a1, Complex b1, double a2, Complex b2, double a3, Complex b3, double a4, Complex b4)
            

计算线性组合。

指定者:

linearCombination 在接口中 CalculusFieldElement<Complex>

参数:

a1 - 第一项的第一个因子

b1 - 第一项的第二个因子

a2 - 第二项的第一个因子

b2 - 第二项的第二个因子

a3 - 第三项的第一个因子

b3 - 第三项的第二个因子

a4 - 第四项的第一个因子

b4 - 第四项的第二个因子

返回:

a₁×b₁ + a₂×b₂ + a₃×b₃ + a₄×b₄

从以下版本开始:

1.7

另请参阅:

• CalculusFieldElement.linearCombination(double, FieldElement, double, FieldElement)
• CalculusFieldElement.linearCombination(double, FieldElement, double, FieldElement, double, FieldElement)

getPi

             public Complex getPi()
            

获取阿基米德常数 π。

阿基米德常数是圆周长与直径的比值。

指定者:

getPi 在接口中 CalculusFieldElement<Complex>

返回:

阿基米德常数 π

ceil

             public Complex ceil()
            

获取大于实例的最小整数。

指定者:

ceil 在接口中 CalculusFieldElement<Complex>

返回:

ceil(this)

从以下版本开始:

1.7

floor

             public Complex floor()
            

获取小于实例的最大整数。

指定者:

floor 在接口中 CalculusFieldElement<Complex>

返回:

floor(this)

从以下版本开始:

1.7

rint

             public Complex rint()
            

获取与实例最接近的整数，如果 x 恰好处于两个整数之间，则返回偶数。

指定者:

rint 在接口中 CalculusFieldElement<Complex>

返回:

一个双精度数 r，满足 r 是整数 r - 0.5 ≤ this ≤ r + 0.5

从以下版本开始:

1.7

remainder

             public Complex remainder(double a)
            

IEEE 取余运算符。

对于复数，与 this.subtract(remainder(a)).divide(a) 对应的整数 n 是一个维基百科 - 高斯整数。

指定者:

remainder 在接口中 CalculusFieldElement<Complex>

参数:

a - 运算符的右侧参数

返回:

this - n × a，其中 n 是最接近 this/a 的整数

从以下版本开始:

1.7

remainder

             public Complex remainder(Complex a)
            

IEEE 取余运算符。

对于复数，与 this.subtract(remainder(a)).divide(a) 对应的整数 n 是一个维基百科 - 高斯整数。

指定者:

remainder 在接口中 CalculusFieldElement<Complex>

参数:

a - 运算符的右侧参数

返回:

this - n × a，其中 n 是最接近 this/a 的整数

从以下版本开始:

1.7

sign

             public Complex sign()
            

计算实例的符号。对于负数，符号为 -1，对于正数，符号为 +1，否则为 0，对于复数，它在单位圆上延伸（相当于 z/|z|，对于 0 和 NaN 进行特殊处理）。

指定者:

sign 在接口中 CalculusFieldElement<Complex>

返回:

-1.0, -0.0, +0.0, +1.0 或 NaN，取决于 a 的符号

从以下版本开始:

2.0

copySign

             public Complex copySign(Complex z)
            

返回具有参数符号的实例。NaN sign 参数被视为正数。

实部和虚部的符号分别独立复制。

指定者:

copySign 在接口中 CalculusFieldElement<Complex>

参数:

z - 返回值的符号

返回:

具有与 sign 参数相同符号的实例

从以下版本开始:

1.7

copySign

             public Complex copySign(double r)
            

返回具有参数符号的实例。NaN sign 参数被视为正数。

指定者:

copySign 在接口中 CalculusFieldElement<Complex>

参数:

r - 返回值的符号

返回:

具有与 sign 参数相同符号的实例

从以下版本开始:

1.7

toDegrees

             public Complex toDegrees()
            

将弧度转换为度，误差小于 0.5 ULP

指定者:

toDegrees 在接口中 CalculusFieldElement<Complex>

返回:

转换为度的实例

toRadians

             public Complex toRadians()
            

将度转换为弧度，误差小于 0.5 ULP

指定者:

toRadians 在接口中 CalculusFieldElement<Complex>

返回:

转换为弧度的实例

compareTo

             public int compareTo(Complex o)
            

使用实部排序作为主要排序顺序，虚部排序作为次要排序顺序进行比较。

指定者:

compareTo 在接口中 Comparable<Complex>

从以下版本开始:

3.0