程序包 org.hipparchus.linear

类 RealVector

java.lang.Object
org.hipparchus.linear.RealVector
直接已知子类:
ArrayRealVector, RealVectorAbstractTest.RealVectorTestImpl, SparseRealVector
public abstract class RealVector extends Object
定义具有基本代数运算的实向量的类。

向量元素索引是基于0的 -- 例如，getEntry(0) 返回向量的第一个元素。

map 和 mapToSelf 方法对向量进行逐元素操作，即它们依次对每个元素执行相同的操作（添加标量，应用函数...）。map 版本创建一个新的向量来保存结果，并不更改实例。 mapToSelf 版本使用实例本身来存储结果，因此此方法会更改实例。在所有情况下，方法都会返回结果向量，允许使用 流畅API 风格，例如：

   RealVector result = v.mapAddToSelf(3.4).mapToSelf(new Tan()).mapToSelf(new Power(2.3));

  • 构造器详细资料

    • RealVector

      public RealVector()
      空构造函数。

      此构造函数并非绝对必要，但它可以防止在 JDK 18 及更高版本中出现虚假的 javadoc 警告。

      从以下版本开始:
      3.0

  • 方法详细资料

    • getDimension

      public abstract int getDimension()
      返回向量的大小。
      返回:
      此向量的大小。

    • getEntry

      public abstract double getEntry(int index) throws MathIllegalArgumentException
      返回指定索引处的条目。
      参数:
      index - 要获取条目的索引位置。
      返回:
      索引为 index 的向量条目。
      抛出:
      MathIllegalArgumentException - 如果索引无效。
      另请参阅:

    • setEntry

      public abstract void setEntry(int index, double value) throws MathIllegalArgumentException
      设置单个元素。
      参数:
      index - 元素索引。
      value - 元素的新值。
      抛出:
      MathIllegalArgumentException - 如果索引无效。
      另请参阅:

    • addToEntry

      public void addToEntry(int index, double increment) throws MathIllegalArgumentException
      更改指定索引处的条目。
      参数:
      index - 要设置条目的索引位置。
      increment - 要添加到向量条目的值。
      抛出:
      MathIllegalArgumentException - 如果索引无效。

    • append

      public abstract RealVector append(RealVector v)
      通过将一个向量追加到此向量来构造一个新向量。
      参数:
      v - 要追加到此向量的向量。
      返回:
      一个新向量。

    • append

      public abstract RealVector append(double d)
      通过将一个 double 追加到此向量来构造一个新向量。
      参数:
      d - 要追加的 double。
      返回:
      一个新向量。

    • getSubVector

      public abstract RealVector getSubVector(int index, int n) throws MathIllegalArgumentException
      从连续元素中获取子向量。
      参数:
      index - 第一个元素的索引。
      n - 要检索的元素数量。
      返回:
      包含n个元素的向量。
      抛出:
      MathIllegalArgumentException - 如果索引无效。
      MathIllegalArgumentException - 如果元素数量不是正数。

    • setSubVector

      public abstract void setSubVector(int index, RealVector v) throws MathIllegalArgumentException
      设置一系列连续元素。
      参数:
      index - 要设置的第一个元素的索引。
      v - 包含要设置的值的向量。
      抛出:
      MathIllegalArgumentException - 如果索引无效。

    • isNaN

      public abstract boolean isNaN()
      检查此向量的任何坐标是否为NaN。
      返回:
      如果此向量的任何坐标为NaN，则返回true，否则返回false。

    • isInfinite

      public abstract boolean isInfinite()
      检查此向量的任何坐标是否为无穷大且没有NaN。
      返回:
      如果此向量的任何坐标为无穷大且没有NaN，则返回true，否则返回false。

    • checkVectorDimensions

      protected void checkVectorDimensions(RealVector v) throws MathIllegalArgumentException
      检查实例和指定向量是否具有相同的维度。
      参数:
      v - 用于与实例比较的向量。
      抛出:
      MathIllegalArgumentException - 如果向量的维度不相同。

    • checkVectorDimensions

      protected void checkVectorDimensions(int n) throws MathIllegalArgumentException
      检查实例维度是否等于某个预期值。
      参数:
      n - 预期的维度。
      抛出:
      MathIllegalArgumentException - 如果维度与向量大小不一致。

    • checkIndex

      protected void checkIndex(int index) throws MathIllegalArgumentException
      检查索引是否有效。
      参数:
      index - 要检查的索引。
      抛出:
      MathIllegalArgumentException - 如果index无效。

    • checkIndices

      protected void checkIndices(int start, int end) throws MathIllegalArgumentException
      检查子向量的索引是否有效。
      参数:
      start - 子向量第一个条目的索引
      end - 子向量最后一个条目的索引（包括）
      抛出:
      MathIllegalArgumentException - 如果start或end无效
      MathIllegalArgumentException - 如果end < start

    • add

      public RealVector add(RealVector v) throws MathIllegalArgumentException
      计算此向量与v的和。返回一个新向量。不更改实例数据。
      参数:
      v - 要相加的向量。
      返回:
      this + v。
      抛出:
      MathIllegalArgumentException - 如果v与this向量的大小不同。

    • subtract

      public RealVector subtract(RealVector v) throws MathIllegalArgumentException
      从此向量中减去v。返回一个新向量。不更改实例数据。
      参数:
      v - 要减去的向量。
      返回:
      this - v。
      抛出:
      MathIllegalArgumentException - 如果v与this向量的大小不同。

    • mapAdd

      public RealVector mapAdd(double d)
      向每个条目添加一个值。返回一个新向量。不更改实例数据。
      参数:
      d - 要添加到每个条目的值。
      返回:
      this + d。

    • mapAddToSelf

      public RealVector mapAddToSelf(double d)
      向每个条目添加一个值。实例在原地更改。
      参数:
      d - 要添加到每个条目的值。
      返回:
      this。

    • copy

      public abstract RealVector copy()
      返回此向量的（深层）副本。
      返回:
      一个向量副本。

    • dotProduct

      public double dotProduct(RealVector v) throws MathIllegalArgumentException
      计算此向量与v的点积。
      参数:
      v - 要计算点积的向量
      返回:
      此实例与v之间的标量点积。
      抛出:
      MathIllegalArgumentException - 如果v与this向量的大小不同。

    • cosine

      public double cosine(RealVector v) throws MathIllegalArgumentException, MathRuntimeException
      计算此向量与参数之间的角度的余弦值。
      参数:
      v - 向量。
      返回:
      此向量与v之间的角度的余弦值。
      抛出:
      MathRuntimeException - 如果this或v是零向量
      MathIllegalArgumentException - 如果this和v的维度不匹配

    • ebeDivide

      public abstract RealVector ebeDivide(RealVector v) throws MathIllegalArgumentException
      逐元素除法。
      参数:
      v - 必须将实例元素除以的向量。
      返回:
      包含所有i的this[i] / v[i]的向量。
      抛出:
      MathIllegalArgumentException - 如果v与this向量的大小不同。

    • ebeMultiply

      public abstract RealVector ebeMultiply(RealVector v) throws MathIllegalArgumentException
      逐元素乘法。
      参数:
      v - 必须将实例元素乘以的向量
      返回:
      包含所有i的this[i] * v[i]的向量。
      抛出:
      MathIllegalArgumentException - 如果v与this向量的大小不同。

    • getDistance

      public double getDistance(RealVector v) throws MathIllegalArgumentException
      两个向量之间的距离。

      此方法计算与L2范数一致的距离，即元素差的平方和的平方根，或欧几里德距离。

      参数:
      v - 请求距离的向量。
      返回:
      两个向量之间的距离。
      抛出:
      MathIllegalArgumentException - 如果v与this向量的大小不同。
      另请参阅:

    • getNorm

      public double getNorm()
      返回向量的L2范数。

      L2范数是平方元素和的平方根。

      返回:
      范数。
      另请参阅:

    • getL1Norm

      public double getL1Norm()
      返回向量的L1范数。

      L1范数是元素的绝对值之和。

      返回:
      范数。
      另请参阅:

    • getLInfNorm

      public double getLInfNorm()
      返回向量的L∞范数。

      L∞范数是元素的绝对值的最大值。

      返回:
      范数。
      另请参阅:

    • getL1Distance

      public double getL1Distance(RealVector v) throws MathIllegalArgumentException
      两个向量之间的距离。

      此方法计算与L1范数一致的距离，即元素差的绝对值之和。

      参数:
      v - 请求距离的向量。
      返回:
      两个向量之间的距离。
      抛出:
      MathIllegalArgumentException - 如果v与this向量的大小不同。

    • getLInfDistance

      public double getLInfDistance(RealVector v) throws MathIllegalArgumentException
      两个向量之间的距离。

      此方法计算与L∞范数一致的距离，即元素差的绝对值的最大值。

      参数:
      v - 请求距离的向量。
      返回:
      两个向量之间的距离。
      抛出:
      MathIllegalArgumentException - 如果v与this向量的大小不同。
      另请参阅:

    • getMinIndex

      public int getMinIndex()
      获取最小条目的索引。
      返回:
      最小条目的索引，如果向量长度为0或所有条目为NaN，则返回-1。

    • getMinValue

      public double getMinValue()
      获取最小条目的值。
      返回:
      最小条目的值，如果所有条目为NaN，则返回NaN。

    • getMaxIndex

      public int getMaxIndex()
      获取最大条目的索引。
      返回:
      最大条目的索引，如果向量长度为0或所有条目为NaN，则返回-1。

    • getMaxValue

      public double getMaxValue()
      获取最大条目的值。
      返回:
      最大条目的值，如果所有条目为NaN，则返回NaN。

    • mapMultiply

      public RealVector mapMultiply(double d)
      将每个条目乘以参数。返回一个新向量。不更改实例数据。
      参数:
      d - 乘法因子。
      返回:
      this * d。

    • mapMultiplyToSelf

      public RealVector mapMultiplyToSelf(double d)
      将每个条目相乘。在原地更改实例。
      参数:
      d - 乘法因子。
      返回:
      this。

    • mapSubtract

      public RealVector mapSubtract(double d)
      从每个条目中减去一个值。返回一个新向量。不更改实例数据。
      参数:
      d - 要减去的值。
      返回:
      this - d。

    • mapSubtractToSelf

      public RealVector mapSubtractToSelf(double d)
      从每个条目中减去一个值。在原地更改实例。
      参数:
      d - 要减去的值。
      返回:
      this。

    • mapDivide

      public RealVector mapDivide(double d)
      将每个条目除以参数。返回一个新向量。不更改实例数据。
      参数:
      d - 要除以的值。
      返回:
      this / d。

    • mapDivideToSelf

      public RealVector mapDivideToSelf(double d)
      将每个条目除以参数。在原地更改实例。
      参数:
      d - 要除以的值。
      返回:
      this。

    • outerProduct

      public RealMatrix outerProduct(RealVector v)
      计算外积。
      参数:
      v - 用于计算外积的向量。
      返回:
      此实例与v之间的矩阵外积。

    • projection

      public RealVector projection(RealVector v) throws MathIllegalArgumentException, MathRuntimeException
      找到此向量在另一个向量上的正交投影。
      参数:
      v - 要投影到的向量。
      返回:
      实例在v上的投影。
      抛出:
      MathIllegalArgumentException - 如果v与this向量的大小不同。
      MathRuntimeException - 如果this或v是空向量。

    • set

      public void set(double value)
      将所有元素设置为单个值。
      参数:
      value - 要为所有元素设置的单个值。

    • toArray

      public double[] toArray()
      将向量转换为double数组。数组与此向量数据独立：元素被复制。
      返回:
      包含向量元素副本的数组。

    • unitVector

      public RealVector unitVector() throws MathRuntimeException
      创建一个指向此向量方向的单位向量。此方法不会更改实例。
      返回:
      指向此向量方向的单位向量。
      抛出:
      MathRuntimeException - 如果范数为零。

    • unitize

      public void unitize() throws MathRuntimeException
      将此向量转换为单位向量。此方法会更改实例本身。
      抛出:
      MathRuntimeException - 如果范数为零。

    • sparseIterator

      public Iterator<RealVector.Entry> sparseIterator()
      创建一个稀疏迭代器，可以省略一些条目。省略的条目可以是精确的零（对于稠密实现）或未存储的条目（对于真实稀疏向量）。不保证迭代顺序。

      注意：派生类需要返回一个Iterator，只要Iterator.hasNext()返回true，就返回非空的RealVector.Entry对象。

      返回:
      一个稀疏迭代器。

    • iterator

      public Iterator<RealVector.Entry> iterator()
      通用稠密迭代器。迭代按照向量索引递增的顺序进行。

      注意：派生类需要返回一个Iterator，只要Iterator.hasNext()返回true，就返回非空的RealVector.Entry对象。

      返回:
      一个稠密迭代器。

    • map

      public RealVector map(UnivariateFunction function)
      作为实现如下： 
        return copy().mapToSelf(function);
      返回一个新向量。不更改实例数据。
      参数:
      function - 应用于每个条目的函数。
      返回:
      一个新向量。

    • mapToSelf

      public RealVector mapToSelf(UnivariateFunction function)
      作为实现如下： 
        Entry e = null;
  for(Iterator<Entry> it = iterator(); it.hasNext(); e = it.next()) {
      e.setValue(function.value(e.getValue()));
  }
      此方法会就地修改此向量的条目。
      参数:
      function - 应用于每个条目的函数。
      返回:
      对此向量的引用。

    • combine

      public RealVector combine(double a, double b, RealVector y) throws MathIllegalArgumentException
      返回表示a * this + b * y的线性组合this和y的新向量。返回一个新向量。不更改实例数据。
      参数:
      a - this的系数。
      b - y的系数。
      y - 与this进行线性组合的向量。
      返回:
      包含a * this[i] + b * y[i]的向量，对所有i。
      抛出:
      MathIllegalArgumentException - 如果y与this向量的大小不同。

    • combineToSelf

      public RealVector combineToSelf(double a, double b, RealVector y) throws MathIllegalArgumentException
      更新this为this和y的线性组合。
      参数:
      a - this的权重。
      b - y的权重。
      y - 与this进行线性组合的向量。
      返回:
      this，其中组件等于a * this[i] + b * y[i]，对所有i。
      抛出:
      MathIllegalArgumentException - 如果y与this向量的大小不同。

    • walkInDefaultOrder

      public double walkInDefaultOrder(RealVectorPreservingVisitor visitor)
      访问（但不更改）此向量的所有条目，默认顺序（索引递增）。
      参数:
      visitor - 用于处理此向量条目的访问者
      返回:
      在遍历结束时由RealVectorPreservingVisitor.end()返回的值

    • walkInDefaultOrder

      public double walkInDefaultOrder(RealVectorPreservingVisitor visitor, int start, int end) throws MathIllegalArgumentException
      访问（但不更改）此向量的一些条目，默认顺序（索引递增）。
      参数:
      visitor - 用于处理此向量条目的访问者
      start - 要访问的第一个条目的索引
      end - 要访问的最后一个条目的索引（包括）
      返回:
      在遍历结束时由RealVectorPreservingVisitor.end()返回的值
      抛出:
      MathIllegalArgumentException - 如果end < start。
      MathIllegalArgumentException - 如果索引无效。

    • walkInOptimizedOrder

      public double walkInOptimizedOrder(RealVectorPreservingVisitor visitor)
      访问（但不更改）此向量的所有条目，优化顺序。选择访问条目的顺序以实现最有效的实现；可能取决于此抽象类的具体实现。
      参数:
      visitor - 用于处理此向量条目的访问者
      返回:
      在遍历结束时由RealVectorPreservingVisitor.end()返回的值

    • walkInOptimizedOrder

      public double walkInOptimizedOrder(RealVectorPreservingVisitor visitor, int start, int end) throws MathIllegalArgumentException
      访问（但不更改）此向量的一些条目，优化顺序。选择访问条目的顺序以实现最有效的实现；可能取决于此抽象类的具体实现。
      参数:
      visitor - 用于处理此向量条目的访问者
      start - 要访问的第一个条目的索引
      end - 要访问的最后一个条目的索引（包括）
      返回:
      在遍历结束时由RealVectorPreservingVisitor.end()返回的值
      抛出:
      MathIllegalArgumentException - 如果end < start。
      MathIllegalArgumentException - 如果索引无效。

    • walkInDefaultOrder

      public double walkInDefaultOrder(RealVectorChangingVisitor visitor)
      访问（并可能更改）此向量的所有条目，按默认顺序（索引递增）。
      参数:
      visitor - 用于处理和修改此向量条目的访问者
      返回:
      在遍历结束时由RealVectorChangingVisitor.end()返回的值

    • walkInDefaultOrder

      public double walkInDefaultOrder(RealVectorChangingVisitor visitor, int start, int end) throws MathIllegalArgumentException
      访问（并可能更改）此向量的一些条目，按默认顺序（索引递增）。
      参数:
      visitor - 用于处理此向量条目的访问者
      start - 要访问的第一个条目的索引
      end - 要访问的最后一个条目的索引（包括）
      返回:
      在遍历结束时由RealVectorChangingVisitor.end()返回的值
      抛出:
      MathIllegalArgumentException - 如果end < start。
      MathIllegalArgumentException - 如果索引无效。

    • walkInOptimizedOrder

      public double walkInOptimizedOrder(RealVectorChangingVisitor visitor)
      按优化顺序访问（并可能更改）此向量的所有条目。选择访问条目的顺序以实现最有效的实现；这可能取决于此抽象类的具体实现。
      参数:
      visitor - 用于处理此向量条目的访问者
      返回:
      在遍历结束时由RealVectorChangingVisitor.end()返回的值

    • walkInOptimizedOrder

      public double walkInOptimizedOrder(RealVectorChangingVisitor visitor, int start, int end) throws MathIllegalArgumentException
      按优化顺序访问（并可能更改）此向量的一些条目。选择访问条目的顺序以实现最有效的实现；这可能取决于此抽象类的具体实现。
      参数:
      visitor - 用于处理此向量条目的访问者
      start - 要访问的第一个条目的索引
      end - 要访问的最后一个条目的索引（包括）
      返回:
      在遍历结束时由RealVectorChangingVisitor.end()返回的值
      抛出:
      MathIllegalArgumentException - 如果end < start。
      MathIllegalArgumentException - 如果索引无效。

    • equals

      public boolean equals(Object other) throws MathRuntimeException

      测试两个实向量是否相等。如果两个实向量的所有坐标完全相同，并且没有NaN，则认为两个实向量相等。将NaN坐标视为全局影响向量并相互相等 - 即，如果实向量的任一（或全部）坐标等于NaN，则该实向量等于所有坐标均为NaN的向量。

      此方法必须被RealVector的具体子类覆盖（当前实现会抛出异常）。

      覆盖:
      equals 在类中 Object
      参数:
      other - 要测试是否相等的对象。
      返回:
      如果两个向量对象相等，则返回true，如果other为null、不是RealVector的实例或与此RealVector实例不相等，则返回false。
      抛出:
      MathRuntimeException - 如果未覆盖此方法。

    • hashCode

      public int hashCode() throws MathRuntimeException
      此方法必须被RealVector的具体子类覆盖（当前实现会抛出异常）。
      覆盖:
      hashCode 在类中 Object
      抛出:
      MathRuntimeException - 如果未覆盖此方法。

    • unmodifiableRealVector

      public static RealVector unmodifiableRealVector(RealVector v)
      返回指定向量的不可修改视图。返回的向量具有只读访问权限。尝试修改它将导致MathRuntimeException。但是，返回的向量不是不可变的，因为对v的任何修改也将更改返回的视图。例如，在以下代码片段中 
           RealVector v = new ArrayRealVector(2);
     RealVector w = RealVector.unmodifiableRealVector(v);
     v.setEntry(0, 1.2);
     v.setEntry(1, -3.4);
      更改将在v的w视图中看到。
      参数:
      v - 要返回不可修改视图的向量。
      返回:
      v的不可修改视图。