java.lang.Object

org.hipparchus.util.MathArrays

public class MathArrays extends Object

数组工具。

嵌套类概要

嵌套类

修饰符和类型

类

说明

static interface

MathArrays.Function

在数组或其部分上操作的实值函数。

static enum

MathArrays.OrderDirection

排序方向的规范。

static enum

MathArrays.Position

指示某些操作是在给定索引之前还是之后的规范。
方法概要

修饰符和类型

方法

说明

static <T extends FieldElement<T>> T[]

buildArray(Field<T> field, int length)

构建一个元素数组。

static <T extends FieldElement<T>> T[][]

buildArray(Field<T> field, int rows, int columns)

构建一个双维数组。

static <T extends FieldElement<T>> T[][][]

buildArray(Field<T> field, int l1, int l2, int l3)

构建一个三维数组。

static void

checkEqualLength(double[] a, double[] b)

检查两个数组是否具有相同的长度。

static boolean

checkEqualLength(double[] a, double[] b, boolean abort)

检查两个数组是否具有相同的长度。

static void

checkEqualLength(int[] a, int[] b)

检查两个数组是否具有相同的长度。

static boolean

checkEqualLength(int[] a, int[] b, boolean abort)

检查两个数组是否具有相同的长度。

static <T extends CalculusFieldElement<T>> void

checkEqualLength(T[] a, T[] b)

检查两个数组是否具有相同的长度。

static <T extends CalculusFieldElement<T>> boolean

checkEqualLength(T[] a, T[] b, boolean abort)

检查两个数组是否具有相同的长度。

static void

checkNonNegative(long[] in)

检查输入数组的所有条目是否都大于等于0。

static void

checkNonNegative(long[][] in)

检查输入数组的所有条目是否都大于等于0。

static void

checkNotNaN(double[] in)

检查输入数组的所有条目是否不是NaN。

static void

checkOrder(double[] val)

检查给定数组是否严格按升序排序。

static void

checkOrder(double[] val, MathArrays.OrderDirection dir, boolean strict)

检查给定数组是否已排序。

static boolean

checkOrder(double[] val, MathArrays.OrderDirection dir, boolean strict, boolean abort)

检查给定数组是否已排序。

static <T extends CalculusFieldElement<T>> void

checkOrder(T[] val)

检查给定数组是否严格按升序排序。

static <T extends CalculusFieldElement<T>> void

checkOrder(T[] val, MathArrays.OrderDirection dir, boolean strict)

检查给定数组是否已排序。

static <T extends CalculusFieldElement<T>> boolean

checkOrder(T[] val, MathArrays.OrderDirection dir, boolean strict, boolean abort)

检查给定数组是否已排序。

static void

checkPositive(double[] in)

检查输入数组的所有条目是否严格为正。

static void

checkRectangular(long[][] in)

如果输入数组不是矩形，则抛出MathIllegalArgumentException。

static double[]

concatenate(double[]... x)

连接一系列数组。

static double[]

convolve(double[] x, double[] h)

计算两个序列之间的卷积。

static double

cosAngle(double[] v1, double[] v2)

计算两个向量之间的夹角的余弦。

static double

distance(double[] p1, double[] p2)

计算两点之间的L₂（欧几里德）距离。

static double

distance(int[] p1, int[] p2)

计算两点之间的L₂（欧几里德）距离。

static double

distance1(double[] p1, double[] p2)

计算两点之间的L₁（绝对值之和）距离。

static int

distance1(int[] p1, int[] p2)

计算两点之间的L₁（绝对值之和）距离。

static double

distanceInf(double[] p1, double[] p2)

计算两点之间的L_∞（绝对值的最大值）距离。

static int

distanceInf(int[] p1, int[] p2)

计算两点之间的L_∞（绝对值的最大值）距离。

static double[]

ebeAdd(double[] a, double[] b)

创建一个数组，其内容将是参数的逐元素相加。

static double[]

ebeDivide(double[] a, double[] b)

创建一个数组，其内容将是第一个参数除以第二个参数的逐元素除法。

static double[]

ebeMultiply(double[] a, double[] b)

创建一个数组，其内容将是参数的逐元素乘法。

static double[]

ebeSubtract(double[] a, double[] b)

创建一个数组，其内容将是第二个参数从第一个参数中逐元素减法。

static boolean

equals(byte[] x, byte[] y)

如果两个参数都为null或具有相同的维度且所有元素相等，则返回true。

static boolean

equals(double[] x, double[] y)

如果两个参数都为null或具有相同的维度且所有元素根据Precision.equals(double,double)定义相等，则返回true。

static boolean

equals(float[] x, float[] y)

如果两个参数都为null或具有相同的维度且所有元素根据Precision.equals(float,float)定义相等，则返回true。

static boolean

equals(int[] x, int[] y)

如果两个参数都为null或具有相同的维度且所有元素相等，则返回true。

static boolean

equals(long[] x, long[] y)

如果两个参数都为null或具有相同的维度且所有元素相等，则返回true。

static boolean

equals(short[] x, short[] y)

如果两个参数都为null或具有相同的维度且所有元素相等，则返回true。

static boolean

equalsIncludingNaN(double[] x, double[] y)

如果两个参数都为null或具有相同的维度且所有元素根据此方法定义相等，则返回true。

static boolean

equalsIncludingNaN(float[] x, float[] y)

如果两个参数都为null或具有相同的维度且所有元素根据此方法定义相等，则返回true。

static boolean

isMonotonic(double[] val, MathArrays.OrderDirection dir, boolean strict)

检查数组是否单调递增或递减。

static <T extends Comparable<? super T>> boolean

isMonotonic(T[] val, MathArrays.OrderDirection dir, boolean strict)

检查数组是否单调递增或递减。

static double

linearCombination(double[] a, double[] b)

准确计算线性组合。

static double

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

准确计算线性组合。

static double

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

准确计算线性组合。

static double

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

准确计算线性组合。

static int[]

natural(int n)

返回表示自然数n的数组。

static double[]

normalizeArray(double[] values, double normalizedSum)

将数组归一化，使其总和为指定值。

static double

safeNorm(double[] v)

返回笛卡尔范数（2-范数），处理溢出和下溢。

static double[]

scale(double val, double[] arr)

创建一个按比例缩放的数组副本。

static void

scaleInPlace(double val, double[] arr)

将数组的每个元素乘以一个值。

static int[]

sequence(int size, int start, int stride)

返回一个由size个整数组成的数组，从start开始，跳过stride个数字。

static void

shuffle(int[] list)

打乱给定数组的条目。

static void

shuffle(int[] list, int start, MathArrays.Position pos)

打乱给定数组的条目。

static void

shuffle(int[] list, int start, MathArrays.Position pos, RandomGenerator rng)

打乱给定数组的条目，使用Fisher–Yates算法。

static void

shuffle(int[] list, RandomGenerator rng)

打乱给定数组的条目。

static void

sortInPlace(double[] x, double[]... yList)

对数组进行升序排序，并在其他数组上执行相同的重新排序。

static void

sortInPlace(double[] x, MathArrays.OrderDirection dir, double[]... yList)

对数组进行排序，并在其他数组上执行相同的重新排序。

static double[]

unique(double[] data)

返回由data中唯一值组成的数组。

static boolean

verifyValues(double[] values, double[] weights, int begin, int length)

此方法用于验证开始和长度参数是否指定具有正长度的子数组，权重是否都为非负、非NaN、有限且不全为零。

static boolean

verifyValues(double[] values, double[] weights, int begin, int length, boolean allowEmpty)

此方法用于验证开始和长度参数是否指定具有正长度的子数组，权重是否都为非负、非NaN、有限且不全为零。

static boolean

verifyValues(double[] values, int begin, int length)

此方法用于验证输入参数是否指定具有正长度的子数组。

static boolean

verifyValues(double[] values, int begin, int length, boolean allowEmpty)

此方法用于验证输入参数是否指定具有正长度的子数组。

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

方法详细资料
- scale
  
  public static double[] scale(double val, double[] arr)
  
  创建一个按比例缩放的数组副本。
  
  参数:
  
  val - 标量。
  
  arr - 要缩放的数组。
  
  返回:
  
  数组的缩放副本，每个条目都乘以val。
- scaleInPlace
  
  public static void scaleInPlace(double val, double[] arr)
  
  将数组的每个元素乘以一个值。
  数组将在原地修改（不会创建副本）。
  
  参数:
  
  val - 标量
  
  arr - 要缩放的数组
- ebeAdd
  
  public static double[] ebeAdd(double[] a, double[] b) throws MathIllegalArgumentException
  
  创建一个数组，其内容将是参数的逐元素相加。
  
  参数:
  
  a - 加法的第一个项。
  
  b - 加法的第二个项。
  
  返回:
  
  一个新数组r，其中r[i] = a[i] + b[i]。
  
  抛出:
  
  MathIllegalArgumentException - 如果数组长度不同。
- ebeSubtract
  
  public static double[] ebeSubtract(double[] a, double[] b) throws MathIllegalArgumentException
  
  创建一个数组，其内容将是第二个参数从第一个参数中逐元素减法。
  
  参数:
  
  a - 第一个项。
  
  b - 要减去的元素。
  
  返回:
  
  一个新数组r，其中r[i] = a[i] - b[i]。
  
  抛出:
  
  MathIllegalArgumentException - 如果数组长度不同。
- ebeMultiply
  
  public static double[] ebeMultiply(double[] a, double[] b) throws MathIllegalArgumentException
  
  创建一个数组，其内容将是参数的逐元素乘法。
  
  参数:
  
  a - 乘法的第一个因子。
  
  b - 乘法的第二个因子。
  
  返回:
  
  一个新数组 r，其中 r[i] = a[i] * b[i]。
  
  抛出:
  
  MathIllegalArgumentException - 如果数组长度不同。
- ebeDivide
  
  public static double[] ebeDivide(double[] a, double[] b) throws MathIllegalArgumentException
  
  创建一个数组，其内容将是第一个参数除以第二个参数的逐元素除法。
  
  参数:
  
  a - 除法的分子。
  
  b - 除法的分母。
  
  返回:
  
  一个新数组 r，其中 r[i] = a[i] / b[i]。
  
  抛出:
  
  MathIllegalArgumentException - 如果数组长度不同。
- distance1
  
  public static double distance1(double[] p1, double[] p2) throws MathIllegalArgumentException
  
  计算两点之间的L₁（绝对值之和）距离。
  
  参数:
  
  p1 - 第一个点
  
  p2 - 第二个点
  
  返回:
  
  两点之间的L₁距离
  
  抛出:
  
  MathIllegalArgumentException - 如果数组长度不同。
- distance1
  
  public static int distance1(int[] p1, int[] p2) throws MathIllegalArgumentException
  
  计算两点之间的L₁（绝对值之和）距离。
  
  参数:
  
  p1 - 第一个点
  
  p2 - 第二个点
  
  返回:
  
  两点之间的L₁距离
  
  抛出:
  
  MathIllegalArgumentException - 如果数组长度不同。
- distance
  
  public static double distance(double[] p1, double[] p2) throws MathIllegalArgumentException
  
  计算两点之间的L₂（欧几里德）距离。
  
  参数:
  
  p1 - 第一个点
  
  p2 - 第二个点
  
  返回:
  
  两点之间的L₂距离
  
  抛出:
  
  MathIllegalArgumentException - 如果数组长度不同。
- cosAngle
  
  public static double cosAngle(double[] v1, double[] v2)
  
  计算两个向量之间的夹角的余弦值。
  
  参数:
  
  v1 - 第一个向量的笛卡尔坐标。
  
  v2 - 第二个向量的笛卡尔坐标。
  
  返回:
  
  两个向量之间夹角的余弦值。
- distance
  
  public static double distance(int[] p1, int[] p2) throws MathIllegalArgumentException
  
  计算两点之间的L₂（欧几里德）距离。
  
  参数:
  
  p1 - 第一个点
  
  p2 - 第二个点
  
  返回:
  
  两点之间的L₂距离
  
  抛出:
  
  MathIllegalArgumentException - 如果数组长度不同。
- distanceInf
  
  public static double distanceInf(double[] p1, double[] p2) throws MathIllegalArgumentException
  
  计算两点之间的L_∞（绝对值最大值）距离。
  
  参数:
  
  p1 - 第一个点
  
  p2 - 第二个点
  
  返回:
  
  两点之间的L_∞距离
  
  抛出:
  
  MathIllegalArgumentException - 如果数组长度不同。
- distanceInf
  
  public static int distanceInf(int[] p1, int[] p2) throws MathIllegalArgumentException
  
  计算两点之间的L_∞（绝对值最大值）距离。
  
  参数:
  
  p1 - 第一个点
  
  p2 - 第二个点
  
  返回:
  
  两点之间的L_∞距离
  
  抛出:
  
  MathIllegalArgumentException - 如果数组长度不同。
- isMonotonic
  
  public static <T extends Comparable<? super T>> boolean isMonotonic(T[] val, MathArrays.OrderDirection dir, boolean strict)
  
  检查数组是否单调递增或递减。
  
  类型参数:
  
  T - 指定数组中元素的类型
  
  参数:
  
  val - 值。
  
  dir - 排序方向。
  
  strict - 是否严格排序。
  
  返回:
  
  如果排序则返回true，否则返回false。
- isMonotonic
  
  public static boolean isMonotonic(double[] val, MathArrays.OrderDirection dir, boolean strict)
  
  检查数组是否单调递增或递减。
  
  参数:
  
  val - 值。
  
  dir - 排序方向。
  
  strict - 是否严格排序。
  
  返回:
  
  如果排序则返回true，否则返回false。
- checkEqualLength
  
  public static boolean checkEqualLength(double[] a, double[] b, boolean abort)
  
  检查两个数组是否具有相同的长度。
  
  参数:
  
  a - 数组。
  
  b - 数组。
  
  abort - 如果检查失败是否抛出异常。
  
  返回:
  
  如果数组具有相同的长度则返回true。
  
  抛出:
  
  MathIllegalArgumentException - 如果长度不同且abort为true。
- checkEqualLength
  
  public static void checkEqualLength(double[] a, double[] b)
  
  检查两个数组是否具有相同的长度。
  
  参数:
  
  a - 数组。
  
  b - 数组。
  
  抛出:
  
  MathIllegalArgumentException - 如果长度不同。
- checkEqualLength
  
  public static <T extends CalculusFieldElement<T>> boolean checkEqualLength(T[] a, T[] b, boolean abort)
  
  检查两个数组是否具有相同的长度。
  
  类型参数:
  
  T - 字段元素的类型
  
  参数:
  
  a - 数组。
  
  b - 数组。
  
  abort - 如果检查失败是否抛出异常。
  
  返回:
  
  如果数组具有相同的长度则返回true。
  
  抛出:
  
  MathIllegalArgumentException - 如果长度不同且abort为true。
  
  从以下版本开始:
  
  1.5
- checkEqualLength
  
  public static <T extends CalculusFieldElement<T>> void checkEqualLength(T[] a, T[] b)
  
  检查两个数组是否具有相同的长度。
  
  类型参数:
  
  T - 字段元素的类型
  
  参数:
  
  a - 数组。
  
  b - 数组。
  
  抛出:
  
  MathIllegalArgumentException - 如果长度不同。
  
  从以下版本开始:
  
  1.5
- checkEqualLength
  
  public static boolean checkEqualLength(int[] a, int[] b, boolean abort)
  
  检查两个数组是否具有相同的长度。
  
  参数:
  
  a - 数组。
  
  b - 数组。
  
  abort - 如果检查失败是否抛出异常。
  
  返回:
  
  如果数组具有相同的长度则返回true。
  
  抛出:
  
  MathIllegalArgumentException - 如果长度不同且abort为true。
- checkEqualLength
  
  public static void checkEqualLength(int[] a, int[] b)
  
  检查两个数组是否具有相同的长度。
  
  参数:
  
  a - 数组。
  
  b - 数组。
  
  抛出:
  
  MathIllegalArgumentException - 如果长度不同。
- checkOrder
  
  public static boolean checkOrder(double[] val, MathArrays.OrderDirection dir, boolean strict, boolean abort) throws MathIllegalArgumentException
  
  检查给定数组是否已排序。
  
  参数:
  
  val - 值。
  
  dir - 排序方向。
  
  strict - 是否严格排序。
  
  abort - 如果检查失败是否抛出异常。
  
  返回:
  
  如果数组已排序则返回true。
  
  抛出:
  
  MathIllegalArgumentException - 如果数组未排序且abort为true。
- checkOrder
  
  public static void checkOrder(double[] val, MathArrays.OrderDirection dir, boolean strict) throws MathIllegalArgumentException
  
  检查给定数组是否已排序。
  
  参数:
  
  val - 值。
  
  dir - 排序方向。
  
  strict - 是否严格排序。
  
  抛出:
  
  MathIllegalArgumentException - 如果数组未排序。
- checkOrder
  
  public static void checkOrder(double[] val) throws MathIllegalArgumentException
  
  检查给定数组是否严格递增排序。
  
  参数:
  
  val - 值。
  
  抛出:
  
  MathIllegalArgumentException - 如果数组未排序。
- checkOrder
  
  public static <T extends CalculusFieldElement<T>> boolean checkOrder(T[] val, MathArrays.OrderDirection dir, boolean strict, boolean abort) throws MathIllegalArgumentException
  
  检查给定数组是否已排序。
  
  类型参数:
  
  T - 字段元素的类型
  
  参数:
  
  val - 值。
  
  dir - 排序方向。
  
  strict - 是否严格排序。
  
  abort - 如果检查失败是否抛出异常。
  
  返回:
  
  如果数组已排序则返回true。
  
  抛出:
  
  MathIllegalArgumentException - 如果数组未排序且abort为true。
  
  从以下版本开始:
  
  1.5
- checkOrder
  
  public static <T extends CalculusFieldElement<T>> void checkOrder(T[] val, MathArrays.OrderDirection dir, boolean strict) throws MathIllegalArgumentException
  
  检查给定数组是否已排序。
  
  类型参数:
  
  T - 字段元素的类型
  
  参数:
  
  val - 值。
  
  dir - 排序方向。
  
  strict - 是否严格排序。
  
  抛出:
  
  MathIllegalArgumentException - 如果数组未排序。
  
  从以下版本开始:
  
  1.5
- checkOrder
  
  public static <T extends CalculusFieldElement<T>> void checkOrder(T[] val) throws MathIllegalArgumentException
  
  检查给定数组是否严格
  
  类型参数:
  
  T - 字段元素的类型
  
  参数:
  
  val - 值。
  
  抛出:
  
  MathIllegalArgumentException - 如果数组未排序。
  
  从以下版本开始:
  
  1.5
- checkRectangular
  
  public static void checkRectangular(long[][] in) throws MathIllegalArgumentException, NullArgumentException
  
  如果输入数组不是矩形的话，会抛出MathIllegalArgumentException异常。
  
  参数:
  
  in - 要测试的数组
  
  抛出:
  
  NullArgumentException - 如果输入数组为null
  
  MathIllegalArgumentException - 如果输入数组不是矩形的
- checkPositive
  
  public static void checkPositive(double[] in) throws MathIllegalArgumentException
  
  检查输入数组的所有条目是否严格为正。
  
  参数:
  
  in - 要测试的数组
  
  抛出:
  
  MathIllegalArgumentException - 如果数组的任何条目不是严格为正。
- checkNotNaN
  
  public static void checkNotNaN(double[] in) throws MathIllegalArgumentException
  
  检查输入数组的任何条目是否为NaN。
  
  参数:
  
  in - 要测试的数组。
  
  抛出:
  
  MathIllegalArgumentException - 如果有条目为NaN。
- checkNonNegative
  
  public static void checkNonNegative(long[] in) throws MathIllegalArgumentException
  
  检查输入数组的所有条目是否>= 0。
  
  参数:
  
  in - 要测试的数组
  
  抛出:
  
  MathIllegalArgumentException - 如果任何数组条目小于0。
- checkNonNegative
  
  public static void checkNonNegative(long[][] in) throws MathIllegalArgumentException
  
  检查输入数组的所有条目是否>= 0。
  
  参数:
  
  in - 要测试的数组
  
  抛出:
  
  MathIllegalArgumentException - 如果任何数组条目小于0。
- safeNorm
  
  public static double safeNorm(double[] v)
  返回笛卡尔范数（2-范数），处理溢出和下溢。这是minpack enorm子例程的翻译。
  MINPACK的重新分发政策可在此处找到，为方便起见，下面是重现的。
  
  Minpack版权声明（1999）芝加哥大学。保留所有权利
  
  允许以源代码和二进制形式重新分发和使用，无论是否经过修改，只要满足以下条件：
  
  源代码的重新分发必须保留上述版权声明、此条件列表和以下免责声明。
  
  以二进制形式重新分发必须在文档和/或其他提供的材料中复制上述版权声明、此条件列表和以下免责声明。
  
  重新分发包含的最终用户文档（如果有）必须包括以下声明：本产品包括由芝加哥大学开发的软件，作为阿贡国家实验室的运营商。或者，如果适用，此声明可以出现在软件本身中，如果和通常出现第三方声明的地方。
  
  免责声明。本软件按“原样”提供，不附带任何形式的保证。版权持有人、美国、美国能源部及其雇员：（1）不承诺任何明示或暗示的保证，包括但不限于对适销性、特定用途的适用性、所有权或非侵权的任何暗示保证，（2）不承担任何法律责任或责任，对于软件的准确性、完整性或有用性，（3）不保证使用软件不会侵犯私人所有权权利，（4）不保证软件将无中断地运行，它是无错误的或任何错误将被纠正。
  
  责任限制。在任何情况下，版权持有人、美国、美国能源部或其雇员：不对任何间接、附带、后果性、特殊或惩罚性的任何种类或性质的损害承担责任，包括但不限于利润损失或数据损失，无论出于任何原因，无论此类责任是基于合同、侵权（包括疏忽或严格责任）还是其他方面，即使已经警告过可能发生此类损失或损害。
  参数:
  
  v - 双精度向量。
  
  返回:
  
  向量的2-范数。
- sortInPlace
  
  public static void sortInPlace(double[] x, double[]... yList) throws MathIllegalArgumentException, NullArgumentException
  
  在原地按升序对数组进行排序，并对其他数组执行相同的重新排序。例如，如果x = [3, 1, 2], y = [1, 2, 3]和z = [0, 5, 7]，那么sortInPlace(x, y, z)将更新x为[1, 2, 3]，y为[2, 3, 1]，z为[5, 7, 0]。
  
  参数:
  
  x - 要排序并用作其他数组排列的模式的数组。
  
  yList - 其排列将遵循在x上执行的排列的数组集。
  
  抛出:
  
  MathIllegalArgumentException - 如果任何y的大小与x不同。
  
  NullArgumentException - 如果x或任何y为null。
- sortInPlace
  
  public static void sortInPlace(double[] x, MathArrays.OrderDirection dir, double[]... yList) throws MathIllegalArgumentException, NullArgumentException
  
  在原地对数组进行排序，并对其他数组执行相同的重新排序。此方法与其他sortInPlace方法相同，但允许在dir参数中提供排序顺序。
  
  参数:
  
  x - 要排序并用作其他数组排列的模式的数组。
  
  dir - 排序方向。
  
  yList - 其排列将遵循在x上执行的排列的数组集。
  
  抛出:
  
  MathIllegalArgumentException - 如果任何y的大小与x不同。
  
  NullArgumentException - 如果x或任何y为null
- linearCombination
  
  public static double linearCombination(double[] a, double[] b) throws MathIllegalArgumentException
  
  准确计算线性组合。此方法通过使用特定的乘法和加法算法来保持精度并减少抵消效应，计算高精度的乘积和的总和i b_i。
  它基于2005年发表在SIAM J. Sci. Comput.上的论文准确求和和点积，作者为Takeshi Ogita、Siegfried M. Rump和Shin'ichi Oishi。
  
  参数:
  
  a - 因子。
  
  b - 因子。
  
  返回:
  
  Σ_i a_i b_i。
  
  抛出:
  
  MathIllegalArgumentException - 如果数组维度不匹配
- linearCombination
  
  public static double linearCombination(double a1, double b1, double a2, double b2)
  
  准确计算线性组合。
  此方法计算a₁×b₁ + a₂×b₂的高精度值。它通过使用特定的乘法和加法算法来保持精度并减少抵消效应。它基于2005年发表在SIAM J. Sci. Comput.上的论文准确求和和点积，作者为Takeshi Ogita、Siegfried M. Rump和Shin'ichi Oishi。
  参数:
  
  a1 - 第一项的第一个因子
  
  b1 - 第一项的第二个因子
  
  a2 - 第二项的第一个因子
  
  b2 - 第二项的第二个因子
  
  返回:
  
  a₁×b₁ + a₂×b₂
  
  另请参阅:
  
  linearCombination(double, double, double, double, double, double)
  
  linearCombination(double, double, double, double, double, double, double, double)
- linearCombination
  
  public static double linearCombination(double a1, double b1, double a2, double b2, double a3, double b3)
  
  准确计算线性组合。
  此方法计算a₁×b₁ + a₂×b₂ + a₃×b₃的高精度值。它通过使用特定的乘法和加法算法来保持精度并减少抵消效应。它基于2005年发表在SIAM J. Sci. Comput.上的论文准确求和和点积，作者为Takeshi Ogita、Siegfried M. Rump和Shin'ichi Oishi。
  参数:
  
  a1 - 第一项的第一个因子
  
  b1 - 第一项的第二个因子
  
  a2 - 第二项的第一个因子
  
  b2 - 第二项的第二个因子
  
  a3 - 第三项的第一个因子
  
  b3 - 第三项的第二个因子
  
  返回:
  
  a₁×b₁ + a₂×b₂ + a₃×b₃
  
  另请参阅:
  
  linearCombination(double, double, double, double)
  
  linearCombination(double, double, double, double, double, double, double, double)
- linearCombination
  
  public static double linearCombination(double a1, double b1, double a2, double b2, double a3, double b3, double a4, double b4)
  
  Compute a linear combination accurately.
  This method computes a₁×b₁ + a₂×b₂ + a₃×b₃ + a₄×b₄ to high accuracy. It does so by using specific multiplication and addition algorithms to preserve accuracy and reduce cancellation effects. It is based on the 2005 paper Accurate Sum and Dot Product by Takeshi Ogita, Siegfried M. Rump, and Shin'ichi Oishi published in SIAM J. Sci. Comput.
  参数:
  
  a1 - first factor of the first term
  
  b1 - second factor of the first term
  
  a2 - first factor of the second term
  
  b2 - second factor of the second term
  
  a3 - first factor of the third term
  
  b3 - second factor of the third term
  
  a4 - first factor of the third term
  
  b4 - second factor of the third term
  
  返回:
  
  a₁×b₁ + a₂×b₂ + a₃×b₃ + a₄×b₄
  
  另请参阅:
  
  linearCombination(double, double, double, double)
  
  linearCombination(double, double, double, double, double, double)
- equals
  
  public static boolean equals(float[] x, float[] y)
  
  Returns true iff both arguments are null or have same dimensions and all their elements are equal as defined by Precision.equals(float,float).
  
  参数:
  
  x - first array
  
  y - second array
  
  返回:
  
  true if the values are both null or have same dimension and equal elements.
- equalsIncludingNaN
  
  public static boolean equalsIncludingNaN(float[] x, float[] y)
  
  Returns true iff both arguments are null or have same dimensions and all their elements are equal as defined by this method.
  
  参数:
  
  x - first array
  
  y - second array
  
  返回:
  
  true if the values are both null or have same dimension and equal elements
- equals
  
  public static boolean equals(double[] x, double[] y)
  
  Returns true iff both arguments are null or have same dimensions and all their elements are equal as defined by Precision.equals(double,double).
  
  参数:
  
  x - First array.
  
  y - Second array.
  
  返回:
  
  true if the values are both null or have same dimension and equal elements.
- equalsIncludingNaN
  
  public static boolean equalsIncludingNaN(double[] x, double[] y)
  
  Returns true iff both arguments are null or have same dimensions and all their elements are equal as defined by this method.
  
  参数:
  
  x - First array.
  
  y - Second array.
  
  返回:
  
  true if the values are both null or have same dimension and equal elements.
- equals
  
  public static boolean equals(long[] x, long[] y)
  
  Returns true if both arguments are null or have same dimensions and all their elements are equals.
  
  参数:
  
  x - First array.
  
  y - Second array.
  
  返回:
  
  true if the values are both null or have same dimension and equal elements.
- equals
  
  public static boolean equals(int[] x, int[] y)
  
  Returns true if both arguments are null or have same dimensions and all their elements are equals.
  
  参数:
  
  x - First array.
  
  y - Second array.
  
  返回:
  
  true if the values are both null or have same dimension and equal elements.
- equals
  
  public static boolean equals(byte[] x, byte[] y)
  
  Returns true if both arguments are null or have same dimensions and all their elements are equals.
  
  参数:
  
  x - First array.
  
  y - Second array.
  
  返回:
  
  true if the values are both null or have same dimension and equal elements.
- equals
  
  public static boolean equals(short[] x, short[] y)
  
  Returns true if both arguments are null or have same dimensions and all their elements are equals.
  
  参数:
  
  x - First array.
  
  y - Second array.
  
  返回:
  
  true if the values are both null or have same dimension and equal elements.
- normalizeArray
  
  public static double[] normalizeArray(double[] values, double normalizedSum) throws MathIllegalArgumentException, MathRuntimeException
  Normalizes an array to make it sum to a specified value. Returns the result of the transformation
  x ↦ x * normalizedSum / sum
  applied to each non-NaN element x of the input array, where sum is the sum of the non-NaN entries in the input array.
  Throws IllegalArgumentException if normalizedSum is infinite or NaN and ArithmeticException if the input array contains any infinite elements or sums to 0.
  
  Ignores (i.e., copies unchanged to the output array) NaNs in the input array. The input array is unchanged by this method.
  参数:
  
  values - Input array to be normalized
  
  normalizedSum - Target sum for the normalized array
  
  返回:
  
  the normalized array
  
  抛出:
  
  MathRuntimeException - if the input array contains infinite elements or sums to zero
  
  MathIllegalArgumentException - if the target sum is infinite or NaN
- buildArray
  
  public static <T extends FieldElement<T>> T[] buildArray(Field<T> field, int length)
  
  Build an array of elements.
  Arrays are filled with field.getZero()
  
  类型参数:
  
  T - the type of the field elements
  
  参数:
  
  field - field to which array elements belong
  
  length - of the array
  
  返回:
  
  a new array
- buildArray
  
  public static <T extends FieldElement<T>> T[][] buildArray(Field<T> field, int rows, int columns)
  
  Build a double dimension array of elements.
  Arrays are filled with field.getZero()
  
  类型参数:
  
  T - the type of the field elements
  
  参数:
  
  field - field to which array elements belong
  
  rows - number of rows in the array
  
  columns - number of columns (may be negative to build partial arrays in the same way new Field[rows][] works)
  
  返回:
  
  a new array
- buildArray
  
  public static <T extends FieldElement<T>> T[][][] buildArray(Field<T> field, int l1, int l2, int l3)
  
  Build a triple dimension array of elements.
  Arrays are filled with field.getZero()
  
  类型参数:
  
  T - the type of the field elements
  
  参数:
  
  field - field to which array elements belong
  
  l1 - number of elements along first dimension
  
  l2 - number of elements along second dimension
  
  l3 - number of elements along third dimension (may be negative to build partial arrays in the same way new Field[l1][l2][] works)
  
  返回:
  
  a new array
  
  从以下版本开始:
  
  1.4
- convolve
  
  public static double[] convolve(double[] x, double[] h) throws MathIllegalArgumentException, NullArgumentException
  
  Calculates the convolution between two sequences.
  The solution is obtained via straightforward computation of the convolution sum (and not via FFT). Whenever the computation needs an element that would be located at an index outside the input arrays, the value is assumed to be zero.
  
  参数:
  
  x - First sequence. Typically, this sequence will represent an input signal to a system.
  
  h - Second sequence. Typically, this sequence will represent the impulse response of the system.
  
  返回:
  
  the convolution of x and h. This array's length will be x.length + h.length - 1.
  
  抛出:
  
  NullArgumentException - if either x or h is null.
  
  MathIllegalArgumentException - if either x or h is empty.
- shuffle
  
  public static void shuffle(int[] list, int start, MathArrays.Position pos)
  
  Shuffle the entries of the given array. The start and pos parameters select which portion of the array is randomized and which is left untouched.
  参数:
  
  list - Array whose entries will be shuffled (in-place).
  
  start - Index at which shuffling begins.
  
  pos - Shuffling is performed for index positions between start and either the end (if MathArrays.Position.TAIL) or the beginning (if MathArrays.Position.HEAD) of the array.
  
  另请参阅:
  
  shuffle(int[],int,Position,RandomGenerator)
- shuffle
  
  public static void shuffle(int[] list, int start, MathArrays.Position pos, RandomGenerator rng)
  
  Shuffle the entries of the given array, using the Fisher–Yates algorithm. The start and pos parameters select which portion of the array is randomized and which is left untouched.
  
  参数:
  
  list - Array whose entries will be shuffled (in-place).
  
  start - Index at which shuffling begins.
  
  pos - Shuffling is performed for index positions between start and either the end (if MathArrays.Position.TAIL) or the beginning (if MathArrays.Position.HEAD) of the array.
  
  rng - Random number generator.
- shuffle
  
  public static void shuffle(int[] list, RandomGenerator rng)
  
  Shuffle the entries of the given array.
  参数:
  
  list - 要洗牌的数组（原地操作）。
  
  rng - 随机数生成器。
  
  另请参阅:
  
  shuffle(int[],int,Position,RandomGenerator)
- shuffle
  
  public static void shuffle(int[] list)
  
  洗牌给定数组的条目。
  参数:
  
  list - 要洗牌的数组（原地操作）。
  
  另请参阅:
  
  shuffle(int[],int,Position,RandomGenerator)
- natural
  
  public static int[] natural(int n)
  
  返回表示自然数 n 的数组。
  
  参数:
  
  n - 自然数。
  
  返回:
  
  一个数组，其条目为 0, 1, ..., n-1。如果 n == 0，则返回的数组为空。
- sequence
  
  public static int[] sequence(int size, int start, int stride)
  
  返回从 start 开始，跳过 stride 个数字的 size 个整数的数组。
  
  参数:
  
  size - 自然数。
  
  start - 自然数。
  
  stride - 自然数。
  
  返回:
  
  一个数组，其条目为 start, start + stride, ..., start + (size - 1) * stride。如果 size == 0，则返回的数组为空。
- verifyValues
  
  public static boolean verifyValues(double[] values, int begin, int length) throws MathIllegalArgumentException
  此方法用于验证输入参数是否指定了长度为正的子数组。
  
  如果参数指定了长度为正的子数组，则返回 true
  
  如果数组为 null 或索引无效，则抛出 MathIllegalArgumentException
  
  如果数组非空，但 length 为 0，则返回 false
  参数:
  
  values - 输入数组
  
  begin - 要包含的第一个数组元素的索引
  
  length - 要包含的元素数
  
  返回:
  
  如果参数有效且指定了长度为正的子数组，则返回 true
  
  抛出:
  
  MathIllegalArgumentException - 如果索引无效或数组为 null
- verifyValues
  
  public static boolean verifyValues(double[] values, int begin, int length, boolean allowEmpty) throws MathIllegalArgumentException
  此方法用于验证输入参数是否指定了长度为正的子数组。
  
  如果参数指定了非负长度的子数组，则返回 true
  
  如果数组为 null 或索引无效，则抛出 IllegalArgumentException
  
  如果数组非空，但 length 为 0 除非 allowEmpty 为 true，否则返回 false
  参数:
  
  values - 输入数组
  
  begin - 要包含的第一个数组元素的索引
  
  length - 要包含的元素数
  
  allowEmpty - 如果为 true，则允许零长度数组通过
  
  返回:
  
  如果参数有效，则返回 true
  
  抛出:
  
  MathIllegalArgumentException - 如果索引无效或数组为 null
- verifyValues
  
  public static boolean verifyValues(double[] values, double[] weights, int begin, int length) throws MathIllegalArgumentException
  此方法用于验证开始和长度参数是否指定了长度为正的子数组，并且权重均为非负、非 NaN、有限且不全为零。
  
  如果参数指定了长度为正的子数组且权重数组包含合法值，则返回 true
  
  如果以下任一情况为真，则抛出 IllegalArgumentException：
  
  值数组为 null
  
  权重数组为 null
  
  权重数组的长度与值数组不同
  
  权重数组包含一个或多个无穷大值
  
  权重数组包含一个或多个 NaN 值
  
  权重数组包含负值
  
  开始和长度参数未确定有效数组
  
  如果数组非空，但 length 为 0，则返回 false
  参数:
  
  values - 输入数组
  
  weights - 权重数组
  
  begin - 要包含的第一个数组元素的索引
  
  length - 要包含的元素数
  
  返回:
  
  如果参数有效且指定了长度为正的子数组，则返回 true
  
  抛出:
  
  MathIllegalArgumentException - 如果索引无效或数组为 null
- verifyValues
  
  public static boolean verifyValues(double[] values, double[] weights, int begin, int length, boolean allowEmpty) throws MathIllegalArgumentException
  此方法用于验证开始和长度参数是否指定了长度为正的子数组，并且权重均为非负、非 NaN、有限且不全为零。
  
  如果参数指定了非负长度的子数组且权重数组包含合法值，则返回 true
  
  如果以下任一情况为真，则抛出 MathIllegalArgumentException：
  
  值数组为 null
  
  权重数组为 null
  
  权重数组的长度与值数组不同
  
  权重数组包含一个或多个无穷大值
  
  权重数组包含一个或多个 NaN 值
  
  权重数组包含负值
  
  开始和长度参数未确定有效数组
  
  如果数组非空，但 length 为 0 除非 allowEmpty 为 true，否则返回 false
  参数:
  
  values - 输入数组。
  
  weights - 权重数组。
  
  begin - 要包含的第一个数组元素的索引。
  
  length - 要包含的元素数。
  
  allowEmpty - 如果为 true，则允许零长度数组通过。
  
  返回:
  
  如果参数有效，则返回 true。
  
  抛出:
  
  NullArgumentException - 如果数组中有任何一个为 null
  
  MathIllegalArgumentException - 如果数组索引无效、权重数组包含 NaN、无穷大或负元素，或没有正权重
- concatenate
  
  public static double[] concatenate(double[]... x)
  
  连接一系列数组。返回的数组由输入数组的条目按其在参数列表中出现的顺序连接而成。空数组会导致 NullPointerException；允许零长度数组（对输出数组不产生影响）。
  
  参数:
  
  x - 要连接的 double[] 数组列表
  
  返回:
  
  由参数数组的条目组成的新数组
  
  抛出:
  
  NullPointerException - 如果任何数组为 null
- unique
  
  public static double[] unique(double[] data)
  
  返回 data 中唯一值组成的数组。返回的数组按降序排序。允许空数组，但 null 数组会导致 NullPointerException。允许无穷大。允许 NaN 值，排序顺序为最大 - 即，如果 data 中有 NaN 值，则输出数组的第一个元素将是 Double.NaN，即使数组还包含 Double.POSITIVE_INFINITY。
  
  参数:
  
  data - 要扫描的数组
  
  返回:
  
  包含输入数组中值的降序列表
  
  抛出:
  
  NullPointerException - 如果 data 为 null

类 MathArrays

嵌套类概要

方法概要

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

方法详细资料

scale

scaleInPlace

ebeAdd

ebeSubtract

ebeMultiply

ebeDivide

distance1

distance1

distance

cosAngle

distance

distanceInf

distanceInf

isMonotonic

isMonotonic

checkEqualLength

checkEqualLength

checkEqualLength

checkEqualLength

checkEqualLength

checkEqualLength

checkOrder

checkOrder

checkOrder

checkOrder

checkOrder

checkOrder

checkRectangular

checkPositive

checkNotNaN

checkNonNegative

checkNonNegative

safeNorm

sortInPlace

sortInPlace

linearCombination

linearCombination

linearCombination

linearCombination

equals

equalsIncludingNaN

equals

equalsIncludingNaN

equals

equals

equals

equals

normalizeArray

buildArray

buildArray

buildArray

convolve

shuffle

shuffle

shuffle

shuffle

natural

sequence

verifyValues

verifyValues

verifyValues

verifyValues

concatenate

unique