程序包 org.hipparchus.complex

类 FieldComplex<T extends CalculusFieldElement<T>>

java.lang.Object

org.hipparchus.complex.FieldComplex<T>

类型参数:

T - 字段元素的类型

所有已实现的接口:

CalculusFieldElement<FieldComplex<T>>, FieldElement<FieldComplex<T>>

直接已知子类:

FieldComplexTest.TestComplex

       public class FieldComplex<T extends CalculusFieldElement<T>> extends Object implements CalculusFieldElement<FieldComplex<T>>
      

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

算术运算的实现根据 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 对象类型的标准行为。

从以下版本开始:

2.0

构造器概要

构造器

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

方法概要

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

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

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

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

getExponent, isFinite, norm, round

构造器详细资料

FieldComplex

             public FieldComplex(T real)
            

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

参数:

real - 实部。

FieldComplex

             public FieldComplex(T real, T imaginary)
            

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

参数:

real - 实部。

imaginary - 虚部。

方法详细资料

getI

             public static <T extends CalculusFieldElement<T>> FieldComplex<T> getI(Field<T> field)
            

获取-1的平方根。

类型参数:

T - 字段元素的类型

参数:

field - 复数组件所属的字段

返回:

表示"0.0 + 1.0i"的数字

getMinusI

             public static <T extends CalculusFieldElement<T>> FieldComplex<T> getMinusI(Field<T> field)
            

获取-1的平方根。

类型参数:

T - 字段元素的类型

参数:

field - 复数组件所属的字段

返回:

表示"0.0 _ 1.0i"的数字

getNaN

             public static <T extends CalculusFieldElement<T>> FieldComplex<T> getNaN(Field<T> field)
            

获取表示"NaN + NaNi"的复数。

类型参数:

T - 字段元素的类型

参数:

field - 复数组件所属的字段

返回:

表示"NaN + NaNi"的复数

getInf

             public static <T extends CalculusFieldElement<T>> FieldComplex<T> getInf(Field<T> field)
            

获取表示"+INF + INFi"的复数。

类型参数:

T - 字段元素的类型

参数:

field - 复数组件所属的字段

返回:

表示"+INF + INFi"的复数

getOne

             public static <T extends CalculusFieldElement<T>> FieldComplex<T> getOne(Field<T> field)
            

获取表示"1.0 + 0.0i"的复数。

类型参数:

T - 字段元素的类型

参数:

field - 复数组件所属的字段

返回:

表示"1.0 + 0.0i"的复数

getMinusOne

             public static <T extends CalculusFieldElement<T>> FieldComplex<T> getMinusOne(Field<T> field)
            

获取表示"-1.0 + 0.0i"的复数。

类型参数:

T - 字段元素的类型

参数:

field - 复数组件所属的字段

返回:

表示"-1.0 + 0.0i"的复数

getZero

             public static <T extends CalculusFieldElement<T>> FieldComplex<T> getZero(Field<T> field)
            

获取表示"0.0 + 0.0i"的复数。

类型参数:

T - 字段元素的类型

参数:

field - 复数组件所属的字段

返回:

表示"0.0 + 0.0i"的复数

getPi

             public static <T extends CalculusFieldElement<T>> FieldComplex<T> getPi(Field<T> field)
            

获取表示"π + 0.0i"的复数。

类型参数:

T - 字段元素的类型

参数:

field - 复数组件所属的字段

返回:

表示"π + 0.0i"的复数

abs

             public FieldComplex<T> abs()
            

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

指定者:

abs 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

绝对值。

add

             public FieldComplex<T> add(FieldComplex<T> addend) throws NullArgumentException
            

返回一个值为(this + addend)的Complex。使用定义公式

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

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

指定者:

add 在接口中 FieldElement<T extends CalculusFieldElement<T>>

参数:

addend - 要添加到此Complex的值。

返回:

this + addend。

抛出:

NullArgumentException - 如果addend为null。

add

             public FieldComplex<T> add(T addend)
            

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

参数:

addend - 要添加到此Complex的值。

返回:

this + addend。

另请参阅:

• add(FieldComplex)

add

             public FieldComplex<T> add(double addend)
            

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

指定者:

add 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

addend - 要添加到此Complex的值。

返回:

this + addend。

另请参阅:

• add(FieldComplex)

conjugate

             public FieldComplex<T> conjugate()
            

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

如果此复数的实部或虚部等于Double.NaN，则返回getNaN(Field)。

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

返回:

此复数的共轭。

divide

             public FieldComplex<T> divide(FieldComplex<T> divisor) throws NullArgumentException
            

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

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

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

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

• 如果this或divisor的任一部分具有NaN值，则返回getNaN(Field)。
• 如果divisor等于getZero(Field)，则返回getNaN(Field)。
• 如果this和divisor都是无穷大，则返回getNaN(Field)。
• 如果this是有限的（即没有Infinite或NaN部分），而divisor是无穷大（一个或两个部分无穷大），则返回getZero(Field)。
• 如果this是无穷大且divisor是有限的，则如果应用于定义公式的Double规则强制产生NaN结果，则在结果的部分中返回NaN值。

指定者:

divide 在接口中 FieldElement<T extends CalculusFieldElement<T>>

参数:

divisor - 用于除以此Complex的值。

返回:

this / divisor。

抛出:

NullArgumentException - 如果divisor为null。

divide

             public FieldComplex<T> divide(T divisor)
            

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

参数:

divisor - 用于除以此Complex的值。

返回:

this / divisor。

另请参阅:

• divide(FieldComplex)

divide

             public FieldComplex<T> divide(double divisor)
            

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

指定者:

divide 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

divisor - 用于除以此Complex的值。

返回:

this / divisor。

另请参阅:

• divide(FieldComplex)

reciprocal

             public FieldComplex<T> reciprocal()
            

返回this元素的乘法逆元。

指定者:

reciprocal 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

指定者:

reciprocal 在接口中 FieldElement<T extends CalculusFieldElement<T>>

返回:

this的逆元。

equals

             public boolean equals(Object other)
            

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

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

覆盖:

equals 在类中 Object

参数:

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

返回:

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

equals

             public static <T extends CalculusFieldElement<T>> boolean equals(FieldComplex<T> x, FieldComplex<T> y, int maxUlps)
            

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

类型参数:

T - 字段元素的类型

参数:

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

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

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

返回:

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

另请参阅:

• Precision.equals(double,double,int)

equals

             public static <T extends CalculusFieldElement<T>> boolean equals(FieldComplex<T> x, FieldComplex<T> y)
            

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

类型参数:

T - 字段元素的类型

参数:

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

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

返回:

如果值相等，则返回true。

equals

             public static <T extends CalculusFieldElement<T>> boolean equals(FieldComplex<T> x, FieldComplex<T> y, double eps)
            

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

类型参数:

T - 字段元素的类型

参数:

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

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

eps - 允许的绝对误差量。

返回:

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

另请参阅:

• Precision.equals(double,double,double)

equalsWithRelativeTolerance

             public static <T extends CalculusFieldElement<T>> boolean equalsWithRelativeTolerance(FieldComplex<T> x, FieldComplex<T> y, double eps)
            

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

类型参数:

T - 字段元素的类型

参数:

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

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

eps - 允许的相对误差量。

返回:

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

另请参阅:

• Precision.equalsWithRelativeTolerance(double,double,double)

hashCode

             public int hashCode()
            

为复数获取一个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<T extends CalculusFieldElement<T>>

返回:

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

getImaginary

             public T getImaginary()
            

访问虚部。

返回:

虚部。

getImaginaryPart

             public T getImaginaryPart()
            

访问虚部。

返回:

虚部。

getReal

             public double getReal()
            

访问实部。

指定者:

getReal 在接口中 FieldElement<T extends CalculusFieldElement<T>>

返回:

实部。

getRealPart

             public T getRealPart()
            

访问实部。

返回:

实部。

isNaN

             public boolean isNaN()
            

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

指定者:

isNaN 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

如果此复数的实部或虚部或两者为NaN，则为true；否则为false。

isReal

             public boolean isReal()
            

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

返回:

如果虚部为零，则为true

isMathematicalInteger

             public boolean isMathematicalInteger()
            

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

返回:

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

isInfinite

             public boolean isInfinite()
            

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

指定者:

isInfinite 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

如果此复数的一部分或两部分均为无限大且两部分均不为NaN，则为true。

multiply

             public FieldComplex<T> multiply(FieldComplex<T> factor) throws NullArgumentException
            

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

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

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

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

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

指定者:

multiply 在接口中 FieldElement<T extends CalculusFieldElement<T>>

参数:

factor - 与此Complex相乘的值。

返回:

this * factor。

抛出:

NullArgumentException - 如果factor为null。

multiply

             public FieldComplex<T> multiply(int factor)
            

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

指定者:

multiply 在接口中 FieldElement<T extends CalculusFieldElement<T>>

参数:

factor - 与此Complex相乘的值。

返回:

this * factor。

另请参阅:

• multiply(FieldComplex)

multiply

             public FieldComplex<T> multiply(double factor)
            

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

指定者:

multiply 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

factor - 与此Complex相乘的值。

返回:

this * factor。

另请参阅:

• multiply(FieldComplex)

multiply

             public FieldComplex<T> multiply(T factor)
            

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

参数:

factor - 与此Complex相乘的值。

返回:

this * factor。

另请参阅:

• multiply(FieldComplex)

multiplyPlusI

             public FieldComplex<T> multiplyPlusI()
            

计算this * i。

返回:

this * i

从以下版本开始:

2.0

multiplyMinusI

             public FieldComplex<T> multiplyMinusI()
            

计算this *- -i。

返回:

this * i

从以下版本开始:

2.0

negate

             public FieldComplex<T> negate()
            

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

指定者:

negate 在接口中 FieldElement<T extends CalculusFieldElement<T>>

返回:

-this。

subtract

             public FieldComplex<T> subtract(FieldComplex<T> subtrahend) throws NullArgumentException
            

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

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

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

指定者:

subtract 在接口中 FieldElement<T extends CalculusFieldElement<T>>

参数:

subtrahend - 从此Complex中减去的值。

返回:

this - subtrahend。

抛出:

NullArgumentException - 如果subtrahend为null。

subtract

             public FieldComplex<T> subtract(double subtrahend)
            

返回一个值为(this - subtrahend)的Complex。

指定者:

subtract 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

subtrahend - 从此Complex中减去的值。

返回:

this - subtrahend。

另请参阅:

• subtract(FieldComplex)

subtract

             public FieldComplex<T> subtract(T subtrahend)
            

返回一个值为(this - subtrahend)的Complex。

参数:

subtrahend - 从此Complex中减去的值。

返回:

this - subtrahend。

另请参阅:

• subtract(FieldComplex)

acos

             public FieldComplex<T> acos()
            

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

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

如果输入参数的实部或虚部为NaN或无穷大，则返回getNaN(Field)。

指定者:

acos 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

此复数的反余弦。

asin

             public FieldComplex<T> asin()
            

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

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

如果输入参数的实部或虚部为NaN或无穷大，则返回getNaN(Field)。

指定者:

asin 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

此复数的反正弦。

atan

             public FieldComplex<T> atan()
            

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

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

如果输入参数的实部或虚部为NaN或无穷大，则返回getNaN(Field)。

指定者:

atan 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

此复数的反正切

cos

             public FieldComplex<T> 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，则返回getNaN(Field)。

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

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

指定者:

cos 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

此复数的余弦。

cosh

             public FieldComplex<T> 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，则返回getNaN(Field)。

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

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

指定者:

cosh 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

此复数的双曲余弦。

exp

             public FieldComplex<T> exp()
            

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

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

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

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

输入的实部或虚部为无穷大值可能导致结果的部分为无穷大或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<T extends CalculusFieldElement<T>>

返回:

ethis。

expm1

             public FieldComplex<T> expm1()
            

指数减1。

指定者:

expm1 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

实例的指数减一

log

             public FieldComplex<T> 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，则返回getNaN(Field)。

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

  例子:
  
   log(1 ± INFINITY i) = INFINITY ± (π/2)i
   log(INFINITY + i) = INFINITY + 0i
   log(-INFINITY + i) = INFINITY + πi
   log(INFINITY ± INFINITY i) = INFINITY ± (π/4)i
   log(-INFINITY ± INFINITY i) = INFINITY ± (3π/4)i
   log(0 + 0i) = -INFINITY + 0i
  
 

指定者:

log 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

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

log1p

             public FieldComplex<T> log1p()
            

移位的自然对数。

指定者:

log1p 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

实例加一的对数

log10

             public FieldComplex<T> log10()
            

底数为10的对数。

指定者:

log10 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

实例的底数为10的对数

pow

             public FieldComplex<T> pow(FieldComplex<T> x) throws NullArgumentException
            

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

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

指定者:

pow 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

x - 要提升为的幂次方。

返回:

thisx。

抛出:

NullArgumentException - 如果x为null。

pow

             public FieldComplex<T> pow(T x)
            

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

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

参数:

x - 要提升为的幂次方。

返回:

thisx。

pow

             public FieldComplex<T> pow(double x)
            

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

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

指定者:

pow 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

x - 要提升为的幂次方。

返回:

thisx。

pow

             public FieldComplex<T> pow(int n)
            

整数幂运算。

指定者:

pow 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

n - 要应用的幂次方

返回:

thisⁿ

sin

             public FieldComplex<T> 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，则返回getNaN(Field)。

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

  示例：
  
   sin(1 ± INFINITY i) = 1 ± INFINITY i
   sin(±INFINITY + i) = NaN + NaN i
   sin(±INFINITY ± INFINITY i) = NaN + NaN i
  
 

指定者:

sin 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

此复数的正弦。

sinCos

             public FieldSinCos<FieldComplex<T>> sinCos()
            

组合正弦和余弦运算。

指定者:

sinCos 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

[sin(this), cos(this)]

atan2

             public FieldComplex<T> atan2(FieldComplex<T> x)
            

两个参数的反正切运算。

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

指定者:

atan2 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

x - 反正切的第二个参数

返回:

atan2(this, x)

acosh

             public FieldComplex<T> acosh()
            

反双曲余弦运算。

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

指定者:

acosh 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

acosh(this)

asinh

             public FieldComplex<T> asinh()
            

反双曲正弦运算。

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

指定者:

asinh 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

asin(this)

atanh

             public FieldComplex<T> atanh()
            

反双曲正切运算。

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

指定者:

atanh 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

atanh(this)

sinh

             public FieldComplex<T> 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，则返回getNaN(Field)。

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

  示例：
  
   sinh(1 ± INFINITY i) = NaN + NaN i
   sinh(±INFINITY + i) = ± INFINITY + INFINITY i
   sinh(±INFINITY ± INFINITY i) = NaN + NaN i
  
 

指定者:

sinh 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

this的双曲正弦。

sinhCosh

             public FieldSinhCosh<FieldComplex<T>> sinhCosh()
            

组合双曲正弦和余弦运算。

指定者:

sinhCosh 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

[sinh(this), cosh(this)]

sqrt

             public FieldComplex<T> 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<T extends CalculusFieldElement<T>>

返回:

具有非负实部的this的平方根。

sqrt1z

             public FieldComplex<T> sqrt1z()
            

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

如果输入参数的实部或虚部为NaN，则返回getNaN(Field)。输入的实部或虚部中的无限值可能导致结果的某些部分返回无限或NaN值。

返回:

1 - this2的平方根。

cbrt

             public FieldComplex<T> cbrt()
            

立方根。

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

指定者:

cbrt 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

实例的立方根

rootN

             public FieldComplex<T> rootN(int n)
            

N^th根。

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

指定者:

rootN 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

n - 根的阶数

返回:

实例的n^th根

tan

             public FieldComplex<T> 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，则返回getNaN(Field)。输入的实部或虚部中的无限（或临界）值可能导致结果的某些部分返回无限或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<T extends CalculusFieldElement<T>>

返回:

this的正切。

tanh

             public FieldComplex<T> 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，则返回getNaN(Field)。输入的实部或虚部中的无限值可能导致结果的某些部分返回无限或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<T extends CalculusFieldElement<T>>

返回:

this的双曲正切。

getArgument

             public T getArgument()
            

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

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

返回:

this的幅角。

nthRoot

             public List<FieldComplex<T>> 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，则返回一个只包含一个元素getNaN(Field)的列表。如果两个部分都不是NaN，但至少有一个部分是无限的，则结果是一个包含getInf(Field)的一个元素列表。

参数:

n - 根的次数。

返回:

所有n次根的列表。

抛出:

MathIllegalArgumentException - 如果n <= 0。

createComplex

             protected FieldComplex<T> createComplex(T realPart, T imaginaryPart)
            

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

参数:

realPart - 实部。

imaginaryPart - 虚部。

返回:

一个新的复数实例。

另请参阅:

• valueOf(CalculusFieldElement, CalculusFieldElement)

valueOf

             public static <T extends CalculusFieldElement<T>> FieldComplex<T> valueOf(T realPart, T imaginaryPart)
            

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

类型参数:

T - 字段元素的类型

参数:

realPart - 实部。

imaginaryPart - 虚部。

返回:

一个复数实例。

valueOf

             public static <T extends CalculusFieldElement<T>> FieldComplex<T> valueOf(T realPart)
            

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

类型参数:

T - 字段元素的类型

参数:

realPart - 实部。

返回:

一个复数实例。

newInstance

             public FieldComplex<T> newInstance(double realPart)
            

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

指定者:

newInstance 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

realPart - 常数实部值

返回:

对应于常数实部值的实例

getField

             public FieldComplexField<T> getField()
            

获取实例所属的Field。

指定者:

getField 在接口中 FieldElement<T extends CalculusFieldElement<T>>

返回:

实例所属的Field

getPartsField

             public Field<T> getPartsField()
            

获取实部和虚部所属的Field。

返回:

实部和虚部所属的Field

toString

             public String toString()
            

覆盖:

toString 在类中 Object

scalb

             public FieldComplex<T> scalb(int n)
            

将实例乘以2的幂。

指定者:

scalb 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

n - 2的幂

返回:

this × 2ⁿ

ulp

             public FieldComplex<T> ulp()
            

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

指定者:

ulp 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

ulp(this)

hypot

             public FieldComplex<T> hypot(FieldComplex<T> y)
            

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

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

指定者:

hypot 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

y - 一个值

返回:

sqrt(this² +y²)

linearCombination

             public FieldComplex<T> linearCombination(FieldComplex<T>[] a, FieldComplex<T>[] b) throws MathIllegalArgumentException
            

计算线性组合。

指定者:

linearCombination 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

a - 因子。

b - 因子。

返回:

Σi ai bi。

抛出:

MathIllegalArgumentException - 如果数组维度不匹配

linearCombination

             public FieldComplex<T> linearCombination(double[] a, FieldComplex<T>[] b) throws MathIllegalArgumentException
            

计算线性组合。

指定者:

linearCombination 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

a - 因子。

b - 因子。

返回:

Σi ai bi。

抛出:

MathIllegalArgumentException - 如果数组维度不匹配

linearCombination

             public FieldComplex<T> linearCombination(FieldComplex<T> a1, FieldComplex<T> b1, FieldComplex<T> a2, FieldComplex<T> b2)
            

计算线性组合。

指定者:

linearCombination 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

a1 - 第一项的第一个因子

b1 - 第一项的第二个因子

a2 - 第二项的第一个因子

b2 - 第二项的第二个因子

返回:

a₁×b₁ + a₂×b₂

另请参阅:

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

linearCombination

             public FieldComplex<T> linearCombination(double a1, FieldComplex<T> b1, double a2, FieldComplex<T> b2)
            

计算线性组合。

指定者:

linearCombination 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

a1 - 第一项的第一个因子

b1 - 第一项的第二个因子

a2 - 第二项的第一个因子

b2 - 第二项的第二个因子

返回:

a₁×b₁ + a₂×b₂

另请参阅:

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

linearCombination

             public FieldComplex<T> linearCombination(FieldComplex<T> a1, FieldComplex<T> b1, FieldComplex<T> a2, FieldComplex<T> b2, FieldComplex<T> a3, FieldComplex<T> b3)
            

计算线性组合。

指定者:

linearCombination 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

a1 - 第一项的第一个因子

b1 - 第一项的第二个因子

a2 - 第二项的第一个因子

b2 - 第二项的第二个因子

a3 - 第三项的第一个因子

b3 - 第三项的第二个因子

返回:

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

另请参阅:

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

linearCombination

             public FieldComplex<T> linearCombination(double a1, FieldComplex<T> b1, double a2, FieldComplex<T> b2, double a3, FieldComplex<T> b3)
            

计算线性组合。

指定者:

linearCombination 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

a1 - 第一项的第一个因子

b1 - 第一项的第二个因子

a2 - 第二项的第一个因子

b2 - 第二项的第二个因子

a3 - 第三项的第一个因子

b3 - 第三项的第二个因子

返回:

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

另请参阅:

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

linearCombination

             public FieldComplex<T> linearCombination(FieldComplex<T> a1, FieldComplex<T> b1, FieldComplex<T> a2, FieldComplex<T> b2, FieldComplex<T> a3, FieldComplex<T> b3, FieldComplex<T> a4, FieldComplex<T> b4)
            

计算线性组合。

指定者:

linearCombination 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

a1 - 第一项的第一个因子

b1 - 第一项的第二个因子

a2 - 第二项的第一个因子

b2 - 第二项的第二个因子

a3 - 第三项的第一个因子

b3 - 第三项的第二个因子

a4 - 第四项的第一个因子

b4 - 第四项的第二个因子

返回:

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

另请参阅:

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

linearCombination

             public FieldComplex<T> linearCombination(double a1, FieldComplex<T> b1, double a2, FieldComplex<T> b2, double a3, FieldComplex<T> b3, double a4, FieldComplex<T> b4)
            

计算线性组合。

指定者:

linearCombination 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

a1 - 第一项的第一个因子

b1 - 第一项的第二个因子

a2 - 第二项的第一个因子

b2 - 第二项的第二个因子

a3 - 第三项的第一个因子

b3 - 第三项的第二个因子

a4 - 第四项的第一个因子

b4 - 第四项的第二个因子

返回:

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

另请参阅:

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

ceil

             public FieldComplex<T> ceil()
            

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

指定者:

ceil 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

ceil(this)

floor

             public FieldComplex<T> floor()
            

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

指定者:

floor 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

floor(this)

rint

             public FieldComplex<T> rint()
            

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

指定者:

rint 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

一个双精度数r，使得r是整数r - 0.5 ≤ this ≤ r + 0.5

remainder

             public FieldComplex<T> remainder(double a)
            

IEEE余数运算符。

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

指定者:

remainder 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

a - 运算符的右侧参数

返回:

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

remainder

             public FieldComplex<T> remainder(FieldComplex<T> a)
            

IEEE余数运算符。

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

指定者:

remainder 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

a - 运算符的右侧参数

返回:

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

sign

             public FieldComplex<T> sign()
            

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

指定者:

sign 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

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

copySign

             public FieldComplex<T> copySign(FieldComplex<T> z)
            

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

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

指定者:

copySign 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

z - 返回值的符号

返回:

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

copySign

             public FieldComplex<T> copySign(double r)
            

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

指定者:

copySign 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

参数:

r - 返回值的符号

返回:

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

toDegrees

             public FieldComplex<T> toDegrees()
            

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

指定者:

toDegrees 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

实例转换为度

toRadians

             public FieldComplex<T> toRadians()
            

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

指定者:

toRadians 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

实例转换为弧度

getPi

             public FieldComplex<T> getPi()
            

获取阿基米德常数 π。

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

指定者:

getPi 在接口中 CalculusFieldElement<T extends CalculusFieldElement<T>>

返回:

阿基米德常数 π