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

类 Vector2D

java.lang.Object
org.hipparchus.geometry.euclidean.twod.Vector2D
所有已实现的接口:
Serializable, Point<Euclidean2D>, Vector<Euclidean2D,Vector2D>, Blendable<Vector<Euclidean2D,Vector2D>>
public class Vector2D extends Object implements Vector<Euclidean2D,Vector2D>
该类表示一个二维向量。

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

另请参阅:

  • 字段详细资料

    • ZERO

      public static final Vector2D ZERO
      原点（坐标：0, 0）。

    • PLUS_I

      public static final Vector2D PLUS_I
      第一个规范向量（坐标：1, 0）。
      从以下版本开始:
      1.6

    • MINUS_I

      public static final Vector2D MINUS_I
      第一个规范向量的相反方向（坐标：-1, 0）。
      从以下版本开始:
      1.6

    • PLUS_J

      public static final Vector2D PLUS_J
      第二个规范向量（坐标：0, 1）。
      从以下版本开始:
      1.6

    • MINUS_J

      public static final Vector2D MINUS_J
      第二个规范向量的相反方向（坐标：0, -1）。
      从以下版本开始:
      1.6

    • NaN

      public static final Vector2D NaN
      所有坐标均设置为NaN的向量。

    • POSITIVE_INFINITY

      public static final Vector2D POSITIVE_INFINITY
      所有坐标均设置为正无穷的向量。

    • NEGATIVE_INFINITY

      public static final Vector2D NEGATIVE_INFINITY
      所有坐标均设置为负无穷的向量。

  • 构造器详细资料

    • Vector2D

      public Vector2D(double x, double y)
      简单构造函数。从其坐标构建向量
      参数:
      x - 横坐标
      y - 纵坐标
      另请参阅:

    • Vector2D

      public Vector2D(double[] v) throws MathIllegalArgumentException
      简单构造函数。从其坐标构建向量
      参数:
      v - 坐标数组
      抛出:
      MathIllegalArgumentException - 如果数组不具有2个元素
      另请参阅:

    • Vector2D

      public Vector2D(double a, Vector2D u)
      乘法构造函数。从另一个向量和一个比例因子构建向量。构建的向量将为a * u
      参数:
      a - 比例因子
      u - 基础（未缩放）向量

    • Vector2D

      public Vector2D(double a1, Vector2D u1, double a2, Vector2D u2)
      线性构造函数。从另外两个向量和相应的比例因子构建向量。构建的向量将为a1 * u1 + a2 * u2
      参数:
      a1 - 第一个比例因子
      u1 - 第一个基础（未缩放）向量
      a2 - 第二个比例因子
      u2 - 第二个基础（未缩放）向量

    • Vector2D

      public Vector2D(double a1, Vector2D u1, double a2, Vector2D u2, double a3, Vector2D u3)
      线性构造函数。从另外三个向量和相应的比例因子构建向量。构建的向量将为a1 * u1 + a2 * u2 + a3 * u3
      参数:
      a1 - 第一个比例因子
      u1 - 第一个基础（未缩放）向量
      a2 - 第二个比例因子
      u2 - 第二个基础（未缩放）向量
      a3 - 第三个比例因子
      u3 - 第三个基础（未缩放）向量

    • Vector2D

      public Vector2D(double a1, Vector2D u1, double a2, Vector2D u2, double a3, Vector2D u3, double a4, Vector2D u4)
      线性构造函数。从另外四个向量和相应的比例因子构建向量。构建的向量将为a1 * u1 + a2 * u2 + a3 * u3 + a4 * u4
      参数:
      a1 - 第一个比例因子
      u1 - 第一个基础（未缩放）向量
      a2 - 第二个比例因子
      u2 - 第二个基础（未缩放）向量

  • 方法详细资料

    • getX

      public double getX()
      Get the abscissa of the vector.
      返回:
      向量的横坐标
      另请参阅:

    • getY

      public double getY()
      获取向量的纵坐标。
      返回:
      向量的纵坐标
      另请参阅:

    • toArray

      public double[] toArray()
      将向量坐标作为二维数组返回。
      返回:
      向量坐标
      另请参阅:

    • getSpace

      public Space getSpace()
      获取点所属的空间。
      指定者:
      getSpace 在接口中 Point<Euclidean2D>
      返回:
      包含的空间

    • getZero

      public Vector2D getZero()
      获取向量空间的零向量或仿射空间的原点。
      指定者:
      getZero 在接口中 Vector<Euclidean2D,Vector2D>
      返回:
      向量空间的零向量或仿射空间的原点

    • getNorm1

      public double getNorm1()
      获取向量的L1范数。
      指定者:
      getNorm1 在接口中 Vector<Euclidean2D,Vector2D>
      返回:
      向量的L1范数

    • getNorm

      public double getNorm()
      获取向量的L2范数。
      指定者:
      getNorm 在接口中 Vector<Euclidean2D,Vector2D>
      返回:
      向量的欧几里德范数

    • getNormSq

      public double getNormSq()
      获取向量的范数的平方。
      指定者:
      getNormSq 在接口中 Vector<Euclidean2D,Vector2D>
      返回:
      向量的欧几里德范数的平方

    • getNormInf

      public double getNormInf()
      获取向量的L∞范数。
      指定者:
      getNormInf 在接口中 Vector<Euclidean2D,Vector2D>
      返回:
      向量的L∞范数

    • add

      public Vector2D add(Vector<Euclidean2D,Vector2D> v)
      将一个向量添加到实例中。
      指定者:
      add 在接口中 Vector<Euclidean2D,Vector2D>
      参数:
      v - 要添加的向量
      返回:
      一个新的向量

    • add

      public Vector2D add(double factor, Vector<Euclidean2D,Vector2D> v)
      将一个按比例缩放的向量添加到实例中。
      指定者:
      add 在接口中 Vector<Euclidean2D,Vector2D>
      参数:
      factor - 添加之前应用于v的比例因子
      v - 要添加的向量
      返回:
      一个新的向量

    • subtract

      public Vector2D subtract(Vector<Euclidean2D,Vector2D> p)
      从实例中减去一个向量。
      指定者:
      subtract 在接口中 Vector<Euclidean2D,Vector2D>
      参数:
      p - 要减去的向量
      返回:
      一个新的向量

    • subtract

      public Vector2D subtract(double factor, Vector<Euclidean2D,Vector2D> v)
      从实例中减去一个按比例缩放的向量。
      指定者:
      subtract 在接口中 Vector<Euclidean2D,Vector2D>
      参数:
      factor - 减去之前应用于v的比例因子
      v - 要减去的向量
      返回:
      一个新的向量

    • angle

      public static double angle(Vector2D v1, Vector2D v2) throws MathRuntimeException
      计算两个向量之间的角度分离。

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

      参数:
      v1 - 第一个向量
      v2 - 第二个向量
      返回:
      v1和v2之间的角度分离
      抛出:
      MathRuntimeException - 如果任一向量的范数为零

    • negate

      public Vector2D negate()
      获取实例的相反向量。
      指定者:
      negate 在接口中 Vector<Euclidean2D,Vector2D>
      返回:
      与实例相反的新向量

    • scalarMultiply

      public Vector2D scalarMultiply(double a)
      将实例乘以一个标量。
      指定者:
      scalarMultiply 在接口中 Vector<Euclidean2D,Vector2D>
      参数:
      a - 标量
      返回:
      一个新的向量

    • isNaN

      public boolean isNaN()
      如果此点的任何坐标为NaN，则返回true；否则返回false
      指定者:
      isNaN 在接口中 Point<Euclidean2D>
      返回:
      如果此点的任何坐标为NaN，则返回true；否则返回false

    • isInfinite

      public boolean isInfinite()
      如果此向量的任何坐标为无穷大且没有NaN，则返回true；否则返回false
      指定者:
      isInfinite 在接口中 Vector<Euclidean2D,Vector2D>
      返回:
      如果此向量的任何坐标为无穷大且没有NaN，则返回true；否则返回false

    • distance1

      public double distance1(Vector<Euclidean2D,Vector2D> p)
      根据L1范数计算实例与另一个向量之间的距离。

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

      指定者:
      distance1 在接口中 Vector<Euclidean2D,Vector2D>
      参数:
      p - 第二个向量
      返回:
      实例与p之间的距离，根据L1范数

    • distance

      public double distance(Point<Euclidean2D> p)
      计算实例与另一个点之间的距离。
      指定者:
      distance

    • distanceInf

      public double distanceInf(Vector<Euclidean2D,Vector2D> p)
      Compute the distance between the instance and another vector according to the L∞ norm.

      Calling this method is equivalent to calling: q.subtract(p).getNormInf() except that no intermediate vector is built

      指定者:
      distanceInf 在接口中 Vector<Euclidean2D,Vector2D>
      参数:
      p - 第二个向量
      返回:
      根据L∞范数计算实例和p之间的距离

    • distanceSq

      public double distanceSq(Vector<Euclidean2D,Vector2D> p)
      计算实例和另一个向量之间的距离的平方。

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

      指定者:
      distanceSq 在接口中 Vector<Euclidean2D,Vector2D>
      参数:
      p - 第二个向量
      返回:
      实例和p之间的距离的平方

    • dotProduct

      public double dotProduct(Vector<Euclidean2D,Vector2D> v)
      计算实例和另一个向量的点积。
      指定者:
      dotProduct 在接口中 Vector<Euclidean2D,Vector2D>
      参数:
      v - 第二个向量
      返回:
      点积this.v

    • crossProduct

      public double crossProduct(Vector2D p1, Vector2D p2)
      计算实例和给定点的叉积。

      叉积可用于确定点相对于由(p1, p2)形成的直线的位置，计算方法为：\[ P = (x_2 - x_1)(y_3 - y_1) - (y_2 - y_1)(x_3 - x_1) \] 其中\(p3 = (x_3, y_3)\)为此实例。

      如果结果为0，则点共线，即位于一条直线L上；如果为正，则此点位于(p1, p2)形成的直线左侧，否则位于右侧。

      参数:
      p1 - 直线的第一个点
      p2 - 直线的第二个点
      返回:
      叉积
      另请参阅:

    • distance1

      public static double distance1(Vector2D p1, Vector2D p2)
      根据L1范数计算两个向量之间的距离。

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

      参数:
      p1 - 第一个向量
      p2 - 第二个向量
      返回:
      根据L1范数计算p1和p2之间的距离
      从以下版本开始:
      1.6

    • distance

      public static double distance(Vector2D p1, Vector2D p2)
      根据L2范数计算两个向量之间的距离。

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

      参数:
      p1 - 第一个向量
      p2 - 第二个向量
      返回:
      根据L2范数计算p1和p2之间的距离

    • distanceInf

      public static double distanceInf(Vector2D p1, Vector2D p2)
      根据L∞范数计算两个向量之间的距离。

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

      参数:
      p1 - 第一个向量
      p2 - 第二个向量
      返回:
      根据L∞范数计算p1和p2之间的距离

    • distanceSq

      public static double distanceSq(Vector2D p1, Vector2D p2)
      计算两个向量之间的距离的平方。

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

      参数:
      p1 - 第一个向量
      p2 - 第二个向量
      返回:
      p1和p2之间的距离的平方

    • orientation

      public static double orientation(Vector2D p, Vector2D q, Vector2D r)
      计算三个点的方向。
      参数:
      p - 三个点中的第一个向量
      q - 三个点中的第二个向量
      r - 三个点中的第三个向量
      返回:
      如果(p, q, r)定义一个逆时针定向的三角形，则返回正值，如果(p, q, r)定义一个顺时针定向的三角形，则返回负值，如果(p, q, r)共线或某些点相等，则返回0
      从以下版本开始:
      1.2

    • equals

      public boolean equals(Object other)
      测试两个2D向量是否相等。

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

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

      覆盖:
      equals 在类中 Object
      参数:
      other - 要测试是否与此相等的对象
      返回:
      如果两个2D向量对象相等，则返回true，如果对象为null、不是Vector2D的实例或不等于此Vector2D实例，则返回false

    • equalsIeee754

      public boolean equalsIeee754(Object other)
      测试两个2D向量是否相等。

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

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

      参数:
      other - 要测试是否与此相等的对象
      返回:
      如果两个2D向量对象相等，则返回true，如果对象为null、不是Vector2D的实例或不等于此Vector2D实例，则返回false
      从以下版本开始:
      2.1

    • hashCode

      public int hashCode()
      获取2D向量的哈希码。

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

      覆盖:
      hashCode 在类中 Object
      返回:
      此对象的哈希码值

    • toString

      public String toString()
      获取此向量的字符串表示形式。
      覆盖:
      toString 在类中 Object
      返回:
      此向量的字符串表示形式

    • toString

      public String toString(NumberFormat format)
      获取此向量的字符串表示形式。
      指定者:
      toString 在接口中 Vector<Euclidean2D,Vector2D>
      参数:
      format - 用于组件的自定义格式
      返回:
      此向量的字符串表示形式