程序包 org.hipparchus.geometry.euclidean.threed

类 Vector3D

java.lang.Object

org.hipparchus.geometry.euclidean.threed.Vector3D

所有已实现的接口:

Serializable, Point<Euclidean3D>, Vector<Euclidean3D,Vector3D>, Blendable<Vector<Euclidean3D,Vector3D>>

       public class Vector3D extends Object implements Serializable, Vector<Euclidean3D,Vector3D>
      

该类实现了三维空间中的向量。

此类的实例保证是不可变的。

另请参阅:

• 序列化表格

字段概要

字段

修饰符和类型	字段	说明
static final Vector3D	MINUS_I	第一个规范向量的相反向量（坐标：-1, 0, 0）。
static final Vector3D	MINUS_J	第二个规范向量的相反向量（坐标：0, -1, 0）。
static final Vector3D	MINUS_K	第三个规范向量的相反向量（坐标：0, 0, -1）。
static final Vector3D	NaN	所有坐标均设置为NaN的向量。
static final Vector3D	NEGATIVE_INFINITY	所有坐标均设置为负无穷的向量。
static final Vector3D	PLUS_I	第一个规范向量（坐标：1, 0, 0）。
static final Vector3D	PLUS_J	第二个规范向量（坐标：0, 1, 0）。
static final Vector3D	PLUS_K	第三个规范向量（坐标：0, 0, 1）。
static final Vector3D	POSITIVE_INFINITY	所有坐标均设置为正无穷的向量。
static final Vector3D	ZERO	空向量（坐标：0, 0, 0）。

构造器概要

构造器

构造器	说明
Vector3D(double[] v)	简单构造函数。
Vector3D(double alpha, double delta)	简单构造函数。
Vector3D(double x, double y, double z)	简单构造函数。
Vector3D(double a, Vector3D u)	乘法构造函数。从另一个向量和一个比例因子构建向量。
Vector3D(double a1, Vector3D u1, double a2, Vector3D u2)	线性构造函数。从两个其他向量和相应的比例因子构建向量。
Vector3D(double a1, Vector3D u1, double a2, Vector3D u2, double a3, Vector3D u3)	线性构造函数。从三个其他向量和相应的比例因子构建向量。
Vector3D(double a1, Vector3D u1, double a2, Vector3D u2, double a3, Vector3D u3, double a4, Vector3D u4)	线性构造函数。从四个其他向量和相应的比例因子构建向量。

方法概要

修饰符和类型	方法	说明
Vector3D	add(double factor, Vector<Euclidean3D,Vector3D> v)	将缩放的向量添加到实例。
Vector3D	add(Vector<Euclidean3D,Vector3D> v)	将向量添加到实例。
static double	angle(Vector3D v1, Vector3D v2)	计算两个向量之间的角距离。
static Vector3D	crossProduct(Vector3D v1, Vector3D v2)	计算两个向量的叉乘积。
Vector3D	crossProduct(Vector<Euclidean3D,Vector3D> v)	计算实例与另一个向量的叉乘积。
static double	distance(Vector3D v1, Vector3D v2)	根据L2范数计算两个向量之间的距离。
double	distance(Point<Euclidean3D> v)	计算实例与另一点之间的距离。
static double	distance1(Vector3D v1, Vector3D v2)	根据L1范数计算两个向量之间的距离。
double	distance1(Vector<Euclidean3D,Vector3D> v)	根据L1范数计算实例与另一个向量之间的距离。
static double	distanceInf(Vector3D v1, Vector3D v2)	根据L∞范数计算两个向量之间的距离。
double	distanceInf(Vector<Euclidean3D,Vector3D> v)	根据L∞范数计算实例与另一个向量之间的距离。
static double	distanceSq(Vector3D v1, Vector3D v2)	计算两个向量之间的距离的平方。
double	distanceSq(Vector<Euclidean3D,Vector3D> v)	计算实例与另一个向量之间的距离的平方。
static double	dotProduct(Vector3D v1, Vector3D v2)	计算两个向量的点积。
double	dotProduct(Vector<Euclidean3D,Vector3D> v)	计算实例与另一个向量的点积。
boolean	equals(Object other)	检查两个三维向量是否相等。
boolean	equalsIeee754(Object other)	检查两个三维向量是否相等。
double	getAlpha()	获取向量的方位角。
double	getDelta()	获取向量的仰角。
double	getNorm()	获取向量的L2范数。
double	getNorm1()	获取向量的L1范数。
double	getNormInf()	获取向量的L∞范数。
double	getNormSq()	获取向量的范数的平方。
Space	getSpace()	获取点所属的空间。
double	getX()	获取向量的横坐标。
double	getY()	获取向量的纵坐标。
double	getZ()	获取向量的高度。
Vector3D	getZero()	获取向量空间的零向量或仿射空间的原点。
int	hashCode()	获取三维向量的哈希码。
boolean	isInfinite()	如果此向量的任何坐标为无穷大且没有NaN，则返回true；否则返回false。
boolean	isNaN()	如果此点的任何坐标为NaN，则返回true；否则返回false。
Vector3D	negate()	获取实例的相反向量。
Vector3D	orthogonal()	获取与实例正交的向量。
Vector3D	scalarMultiply(double a)	将实例乘以标量。
Vector3D	subtract(double factor, Vector<Euclidean3D,Vector3D> v)	从实例中减去一个缩放的向量。
Vector3D	subtract(Vector<Euclidean3D,Vector3D> v)	从实例中减去一个向量。
double[]	toArray()	将向量坐标作为三维数组返回。
String	toString()	获取此向量的字符串表示形式。
String	toString(NumberFormat format)	获取此向量的字符串表示形式。

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

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

从接口继承的方法 org.hipparchus.geometry.Vector

blendArithmeticallyWith, normalize

字段详细资料

ZERO

             public static final Vector3D ZERO
            

空向量（坐标：0, 0, 0）。

PLUS_I

             public static final Vector3D PLUS_I
            

第一个规范向量（坐标：1, 0, 0）。

MINUS_I

             public static final Vector3D MINUS_I
            

第一个规范向量的相反向量（坐标：-1, 0, 0）。

PLUS_J

             public static final Vector3D PLUS_J
            

第二个规范向量（坐标：0, 1, 0）。

MINUS_J

             public static final Vector3D MINUS_J
            

第二个规范向量的相反向量（坐标：0, -1, 0）。

PLUS_K

             public static final Vector3D PLUS_K
            

第三个规范向量（坐标：0, 0, 1）。

MINUS_K

             public static final Vector3D MINUS_K
            

第三个规范向量的相反向量（坐标：0, 0, -1）。

NaN

             public static final Vector3D NaN
            

所有坐标均设置为NaN的向量。

POSITIVE_INFINITY

             public static final Vector3D POSITIVE_INFINITY
            

所有坐标均设置为正无穷的向量。

NEGATIVE_INFINITY

             public static final Vector3D NEGATIVE_INFINITY
            

所有坐标均设置为负无穷的向量。

构造器详细资料

Vector3D

             public Vector3D(double x, double y, double z)
            

简单构造函数。根据其坐标构建向量

参数:

x - 横坐标

y - 纵坐标

z - 高度

另请参阅:

• getX()
• getY()
• getZ()

Vector3D

             public Vector3D(double[] v) throws MathIllegalArgumentException
            

简单构造函数。根据其坐标构建向量

参数:

v - 坐标数组

抛出:

MathIllegalArgumentException - 如果数组不具有3个元素

另请参阅:

• toArray()

Vector3D

             public Vector3D(double alpha, double delta)
            

简单构造函数。根据方位角坐标构建向量

参数:

alpha - 绕Z轴的方位角（α）（0为+X，π/2为+Y，π为-X，3π/2为-Y）

delta - （XY）平面上的仰角（δ），范围从-π/2到+π/2

另请参阅:

• getAlpha()
• getDelta()

Vector3D

             public Vector3D(double a, Vector3D u)
            

乘法构造函数。从另一个向量和一个比例因子构建向量。构建的向量将为a * u

参数:

a - 比例因子

u - 基础（未缩放）向量

Vector3D

             public Vector3D(double a1, Vector3D u1, double a2, Vector3D u2)
            

线性构造函数。从两个其他向量和相应的比例因子构建向量。构建的向量将为a1 * u1 + a2 * u2

参数:

a1 - 第一个比例因子

u1 - 第一个基础（未缩放）向量

a2 - 第二个比例因子

u2 - 第二个基础（未缩放）向量

Vector3D

             public Vector3D(double a1, Vector3D u1, double a2, Vector3D u2, double a3, Vector3D u3)
            

线性构造函数。从三个

参数:

a1 - 第一个比例因子

u1 - 第一个基础（未缩放）向量

a2 - 第二个比例因子

u2 - 第二个基础（未缩放）向量

a3 - 第三个比例因子

u3 - 第三个基础（未缩放）向量

Vector3D

             public Vector3D(double a1, Vector3D u1, double a2, Vector3D u2, double a3, Vector3D u3, double a4, Vector3D u4)
            

线性构造函数 从其他四个向量和相应的比例因子构建一个向量。构建的向量将为 a1 * u1 + a2 * u2 + a3 * u3 + a4 * u4

参数:

a1 - 第一个比例因子

u1 - 第一个基础（未缩放）向量

a2 - 第二个比例因子

u2 - 第二个基础（未缩放）向量

a3 - 第三个比例因子

u3 - 第三个基础（未缩放）向量

a4 - 第四个比例因子

u4 - 第四个基础（未缩放）向量

方法详细资料

getX

             public double getX()
            

获取向量的横坐标。

返回:

向量的横坐标

另请参阅:

• Vector3D(double, double, double)

getY

             public double getY()
            

获取向量的纵坐标。

返回:

向量的纵坐标

另请参阅:

• Vector3D(double, double, double)

getZ

             public double getZ()
            

获取向量的高度。

返回:

向量的高度

另请参阅:

• Vector3D(double, double, double)

toArray

             public double[] toArray()
            

将向量坐标作为三维数组返回。

返回:

向量坐标

另请参阅:

• Vector3D(double[])

getSpace

             public Space getSpace()
            

获取点所属的空间。

指定者:

getSpace 在接口中 Point<Euclidean3D>

返回:

包含的空间

getZero

             public Vector3D getZero()
            

获取向量空间的零向量或仿射空间的原点。

指定者:

getZero 在接口中 Vector<Euclidean3D,Vector3D>

返回:

向量空间的零向量或仿射空间的原点

getNorm1

             public double getNorm1()
            

获取向量的 L₁ 范数。

指定者:

getNorm1 在接口中 Vector<Euclidean3D,Vector3D>

返回:

向量的 L₁ 范数

getNorm

             public double getNorm()
            

获取向量的 L₂ 范数。

指定者:

getNorm 在接口中 Vector<Euclidean3D,Vector3D>

返回:

向量的欧几里德范数

getNormSq

             public double getNormSq()
            

获取向量的范数的平方。

指定者:

getNormSq 在接口中 Vector<Euclidean3D,Vector3D>

返回:

向量的欧几里德范数的平方

getNormInf

             public double getNormInf()
            

获取向量的 L_∞ 范数。

指定者:

getNormInf 在接口中 Vector<Euclidean3D,Vector3D>

返回:

向量的 L_∞ 范数

getAlpha

             public double getAlpha()
            

获取向量的方位角。

返回:

向量的方位角（α），介于 -π 和 +π 之间

另请参阅:

• Vector3D(double, double)

getDelta

             public double getDelta()
            

获取向量的仰角。

返回:

向量的仰角（δ），介于 -π/2 和 +π/2 之间

另请参阅:

• Vector3D(double, double)

add

             public Vector3D add(Vector<Euclidean3D,Vector3D> v)
            

将一个向量添加到实例中。

指定者:

add 在接口中 Vector<Euclidean3D,Vector3D>

参数:

v - 要添加的向量

返回:

一个新的向量

add

             public Vector3D add(double factor, Vector<Euclidean3D,Vector3D> v)
            

将一个经过缩放的向量添加到实例中。

指定者:

add 在接口中 Vector<Euclidean3D,Vector3D>

参数:

factor - 添加之前应用于 v 的比例因子

v - 要添加的向量

返回:

一个新的向量

subtract

             public Vector3D subtract(Vector<Euclidean3D,Vector3D> v)
            

从实例中减去一个向量。

指定者:

subtract 在接口中 Vector<Euclidean3D,Vector3D>

参数:

v - 要减去的向量

返回:

一个新的向量

subtract

             public Vector3D subtract(double factor, Vector<Euclidean3D,Vector3D> v)
            

从实例中减去一个经过缩放的向量。

指定者:

subtract 在接口中 Vector<Euclidean3D,Vector3D>

参数:

factor - 减去之前应用于 v 的比例因子

v - 要减去的向量

返回:

一个新的向量

orthogonal

             public Vector3D orthogonal() throws MathRuntimeException
            

获取与实例正交的向量。

有无限多个与实例正交的归一化向量。此方法几乎任意地选择其中一个。当需要计算一个轴与预定义方向中的一个轴对齐的参考框架时，这是有用的。以下示例显示了如何构建一个框架，其中 k 轴与已知向量 u 对齐：

   Vector3D k = u.normalize();
   Vector3D i = k.orthogonal();
   Vector3D j = Vector3D.crossProduct(k, i);
 

返回:

一个新的与实例正交的归一化向量

抛出:

MathRuntimeException - 如果实例的范数为零

angle

             public static double angle(Vector3D v1, Vector3D v2) throws MathRuntimeException
            

计算两个向量之间的角分离。

此方法使用点积计算两个向量之间的角分离，用于相距较远的向量，使用叉积用于几乎对齐的向量。这样可以在所有情况下获得良好的精度，即使对于非常接近的向量也是如此。

参数:

v1 - 第一个向量

v2 - 第二个向量

返回:

v1 和 v2 之间的角分离

抛出:

MathRuntimeException - 如果任一向量的范数为零

negate

             public Vector3D negate()
            

获取实例的相反向量。

指定者:

negate</

scalarMultiply

             public Vector3D scalarMultiply(double a)
            

Multiply the instance by a scalar.

指定者:

scalarMultiply 在接口中 Vector<Euclidean3D,Vector3D>

参数:

a - scalar

返回:

a new vector

isNaN

             public boolean isNaN()
            

如果此点的任何坐标为NaN，则返回true；否则返回false

指定者:

isNaN 在接口中 Point<Euclidean3D>

返回:

如果此点的任何坐标为NaN，则返回true；否则返回false

isInfinite

             public boolean isInfinite()
            

如果此向量的任何坐标为无穷大且没有NaN，则返回true；否则返回false

指定者:

isInfinite 在接口中 Vector<Euclidean3D,Vector3D>

返回:

如果此向量的任何坐标为无穷大且没有NaN，则返回true；否则返回false

equals

             public boolean equals(Object other)
            

测试两个3D向量是否相等。

如果两个3D向量的所有坐标完全相同，并且没有Double.NaN，则认为这两个3D向量相等。

NaN坐标被认为全局影响向量并相互相等 - 即，如果3D向量的任何一个（或全部）坐标等于Double.NaN，则该3D向量等于NaN。

覆盖:

equals 在类中 Object

参数:

other - 要测试是否与此相等的对象

返回:

如果两个3D向量对象相等，则返回true；如果对象为null、不是Vector3D的实例或不等于此Vector3D实例，则返回false

equalsIeee754

             public boolean equalsIeee754(Object other)
            

测试两个3D向量是否相等。

如果两个3D向量的所有坐标完全相同，并且没有NaN，则认为这两个3D向量相等。

根据IEEE754处理，如果任一向量的任何坐标为NaN，则认为这两个向量不同。这意味着Vector3D.NaN.equals(Vector3D.NaN)返回false，尽管实例与自身进行了检查。

参数:

other - 要测试是否与此相等的对象

返回:

如果两个3D向量对象相等，则返回true；如果对象为null、不是Vector3D的实例或不等于此Vector3D实例，则返回false

从以下版本开始:

2.1

hashCode

             public int hashCode()
            

获取3D向量的哈希码。

所有NaN值具有相同的哈希码。

覆盖:

hashCode 在类中 Object

返回:

此对象的哈希码值

dotProduct

             public double dotProduct(Vector<Euclidean3D,Vector3D> v)
            

计算此实例和另一个向量的点积。

该实现使用特定的乘法和加法算法来保持精度并减少抵消效应。即使对于几乎正交的向量，它也应该非常精确。

指定者:

dotProduct 在接口中 Vector<Euclidean3D,Vector3D>

参数:

v - 第二个向量

返回:

点积 this.v

另请参阅:

• MathArrays.linearCombination(double, double, double, double, double, double)

crossProduct

             public Vector3D crossProduct(Vector<Euclidean3D,Vector3D> v)
            

计算此实例与另一个向量的叉积。

参数:

v - 其他向量

返回:

叉积 this ^ v 作为新的Vector3D

distance1

             public double distance1(Vector<Euclidean3D,Vector3D> v)
            

根据L₁范数计算此实例和另一个向量之间的距离。

调用此方法等效于调用：q.subtract(p).getNorm1()，只是不会构建中间向量

指定者:

distance1 在接口中 Vector<Euclidean3D,Vector3D>

参数:

v - 第二个向量

返回:

根据L₁范数计算此实例和p之间的距离

distance

             public double distance(Point<Euclidean3D> v)
            

计算此实例与另一个点之间的距离。

指定者:

distance 在接口中 Point<Euclidean3D>

参数:

v - 第二个点

返回:

此实例与p之间的距离

distanceInf

             public double distanceInf(Vector<Euclidean3D,Vector3D> v)
            

根据L_∞范数计算此实例和另一个向量之间的距离。

调用此方法等效于调用：q.subtract(p).getNormInf()，只是不会构建中间向量

指定者:

distanceInf 在接口中 Vector<Euclidean3D,Vector3D>

参数:

v - 第二个向量

返回:

根据L_∞范数计算此实例和p之间的距离

distanceSq

             public double distanceSq(Vector<Euclidean3D,Vector3D> v)
            

计算此实例与另一个向量之间的距离的平方。

调用此方法等效于调用：q.subtract(p).getNormSq()，只是不会构建中间向量

指定者:

distanceSq 在接口中 Vector<Euclidean3D,Vector3D>

参数:

v - 第二个向量

返回:

此实例与p之间的距离的平方

dotProduct

             public static double dotProduct(Vector3D v1, Vector3D v2)
            

计算两个向量的点积。

参数:

v1 - 第一个向量

v2 - 第二个向量

返回:

点积 v1.v2

crossProduct

             public static Vector3D crossProduct(Vector3D v1, Vector3D v2)
            

计算两个向量的叉积。

参数:

v1 - 第一个向量

v2 - 第二个向量

返回:

叉积 v1 ^ v2 作为新的Vector

distance1

             public static double distance1(Vector3D v1, Vector3D v2)
            

根据L₁范数计算两个向量之间的距离。

调用此方法等效于调用：v1.subtract(v2).getNorm1()，只是不会构建中间向量

参数:

v1 - 第一个向量

v2 - 第二个向量

返回:

根据L₁范数计算v1和v2之间的距离

distance

             public static double distance(Vector3D v1, Vector3D v2)
            

根据L₂范数计算两个向量之间的距离。

调用此方法等效于调用：v1.subtract(v2).getNorm()，只是不会构建中间向量

参数:

v1 - 第一个向量

v2 - 第二个向量

返回:

根据L₂范数计算v1和v2之间的距离

distanceInf

             public static double distanceInf(Vector3D v1, Vector3D v2)
            

根据L_∞范数计算两个向量之间的距离。

调用此方法等效于调用：v1.subtract(v2).getNormInf()，只是不会构建中间向量

参数:

v1 - 第一个向量

v2 - 第二个向量

返回:

根据L_∞范数计算v1和v2之间的距离

distanceSq

             public static double distanceSq(Vector3D v1, Vector3D v2)
            

计算两个向量之间的距离的平方。

调用此方法等效于调用：v1.subtract(v2).getNormSq()，只是不会构建中间向量

参数:

v1 - 第一个向量

v2 - 第二个向量

返回:

v1和v2之间的距禮的平方

toString

             public String toString()
            

获取此向量的字符串表示形式。

覆盖:

toString 在类中 Object

返回:

此向量的字符串表示形式

toString

             public String toString(NumberFormat format)
            

获取此向量的字符串表示形式。

指定者:

toString 在接口中 Vector<Euclidean3D,Vector3D>

参数:

format - 组件的自定义格式

返回:

此向量的字符串表示形式