CPD Results
The following document contains the results of PMD's CPD 6.21.0.
Duplications
File | Line |
---|---|
org/hipparchus/util/OpenIntToDoubleHashMap.java | 178 |
org/hipparchus/util/OpenIntToFieldHashMap.java | 191 |
public double get(final int key) { final int hash = hashOf(key); int index = hash & mask; if (containsKey(key, index)) { return values[index]; } if (states[index] == FREE) { return missingEntries; } int j = index; for (int perturb = perturb(hash); states[index] != FREE; perturb >>= PERTURB_SHIFT) { j = probe(perturb, j); index = j & mask; if (containsKey(key, index)) { return values[index]; } } return missingEntries; } /** * Check if a value is associated with a key. * @param key key to check * @return true if a value is associated with key */ public boolean containsKey(final int key) { final int hash = hashOf(key); int index = hash & mask; if (containsKey(key, index)) { return true; } if (states[index] == FREE) { return false; } int j = index; for (int perturb = perturb(hash); states[index] != FREE; perturb >>= PERTURB_SHIFT) { j = probe(perturb, j); index = j & mask; if (containsKey(key, index)) { return true; } } return false; } /** * Get an iterator over map elements. * <p>The specialized iterators returned are fail-fast: they throw a * <code>ConcurrentModificationException</code> when they detect the map * has been modified during iteration.</p> * @return iterator over the map elements */ public Iterator iterator() { return new Iterator(); } /** * Perturb the hash for starting probing. * @param hash initial hash * @return perturbed hash */ private static int perturb(final int hash) { return hash & 0x7fffffff; } /** * Find the index at which a key should be inserted * @param key key to lookup * @return index at which key should be inserted */ private int findInsertionIndex(final int key) { return findInsertionIndex(keys, states, key, mask); } /** * Find the index at which a key should be inserted * @param keys keys table * @param states states table * @param key key to lookup * @param mask bit mask for hash values * @return index at which key should be inserted */ private static int findInsertionIndex(final int[] keys, final byte[] states, final int key, final int mask) { final int hash = hashOf(key); int index = hash & mask; if (states[index] == FREE) { return index; } else if (states[index] == FULL && keys[index] == key) { return changeIndexSign(index); } int perturb = perturb(hash); int j = index; if (states[index] == FULL) { while (true) { j = probe(perturb, j); index = j & mask; perturb >>= PERTURB_SHIFT; if (states[index] != FULL || keys[index] == key) { break; } } } if (states[index] == FREE) { return index; } else if (states[index] == FULL) { // due to the loop exit condition, // if (states[index] == FULL) then keys[index] == key return changeIndexSign(index); } final int firstRemoved = index; while (true) { j = probe(perturb, j); index = j & mask; if (states[index] == FREE) { return firstRemoved; } else if (states[index] == FULL && keys[index] == key) { return changeIndexSign(index); } perturb >>= PERTURB_SHIFT; } } /** * Compute next probe for collision resolution * @param perturb perturbed hash * @param j previous probe * @return next probe */ private static int probe(final int perturb, final int j) { return (j << 2) + j + perturb + 1; } /** * Change the index sign * @param index initial index * @return changed index */ private static int changeIndexSign(final int index) { return -index - 1; } /** * Get the number of elements stored in the map. * @return number of elements stored in the map */ public int size() { return size; } /** * Remove the value associated with a key. * @param key key to which the value is associated * @return removed value */ public double remove(final int key) { |
File | Line |
---|---|
org/hipparchus/linear/ArrayFieldVector.java | 873 |
org/hipparchus/linear/SparseFieldVector.java | 585 |
} } /** * Visits (but does not alter) all entries of this vector in default order * (increasing index). * * @param visitor the visitor to be used to process the entries of this * vector * @return the value returned by {@link FieldVectorPreservingVisitor#end()} * at the end of the walk */ public T walkInDefaultOrder(final FieldVectorPreservingVisitor<T> visitor) { final int dim = getDimension(); visitor.start(dim, 0, dim - 1); for (int i = 0; i < dim; i++) { visitor.visit(i, getEntry(i)); } return visitor.end(); } /** * Visits (but does not alter) some entries of this vector in default order * (increasing index). * * @param visitor visitor to be used to process the entries of this vector * @param start the index of the first entry to be visited * @param end the index of the last entry to be visited (inclusive) * @return the value returned by {@link FieldVectorPreservingVisitor#end()} * at the end of the walk * @throws MathIllegalArgumentException if {@code end < start}. * @throws MathIllegalArgumentException if the indices are not valid. */ public T walkInDefaultOrder(final FieldVectorPreservingVisitor<T> visitor, final int start, final int end) throws MathIllegalArgumentException { checkIndices(start, end); visitor.start(getDimension(), start, end); for (int i = start; i <= end; i++) { visitor.visit(i, getEntry(i)); } return visitor.end(); } /** * Visits (but does not alter) all entries of this vector in optimized * order. The order in which the entries are visited is selected so as to * lead to the most efficient implementation; it might depend on the * concrete implementation of this abstract class. * * @param visitor the visitor to be used to process the entries of this * vector * @return the value returned by {@link FieldVectorPreservingVisitor#end()} * at the end of the walk */ public T walkInOptimizedOrder(final FieldVectorPreservingVisitor<T> visitor) { return walkInDefaultOrder(visitor); } /** * Visits (but does not alter) some entries of this vector in optimized * order. The order in which the entries are visited is selected so as to * lead to the most efficient implementation; it might depend on the * concrete implementation of this abstract class. * * @param visitor visitor to be used to process the entries of this vector * @param start the index of the first entry to be visited * @param end the index of the last entry to be visited (inclusive) * @return the value returned by {@link FieldVectorPreservingVisitor#end()} * at the end of the walk * @throws MathIllegalArgumentException if {@code end < start}. * @throws MathIllegalArgumentException if the indices are not valid. */ public T walkInOptimizedOrder(final FieldVectorPreservingVisitor<T> visitor, final int start, final int end) throws MathIllegalArgumentException { return walkInDefaultOrder(visitor, start, end); } /** * Visits (and possibly alters) all entries of this vector in default order * (increasing index). * * @param visitor the visitor to be used to process and modify the entries * of this vector * @return the value returned by {@link FieldVectorChangingVisitor#end()} * at the end of the walk */ public T walkInDefaultOrder(final FieldVectorChangingVisitor<T> visitor) { final int dim = getDimension(); visitor.start(dim, 0, dim - 1); for (int i = 0; i < dim; i++) { setEntry(i, visitor.visit(i, getEntry(i))); } return visitor.end(); } /** * Visits (and possibly alters) some entries of this vector in default order * (increasing index). * * @param visitor visitor to be used to process the entries of this vector * @param start the index of the first entry to be visited * @param end the index of the last entry to be visited (inclusive) * @return the value returned by {@link FieldVectorChangingVisitor#end()} * at the end of the walk * @throws MathIllegalArgumentException if {@code end < start}. * @throws MathIllegalArgumentException if the indices are not valid. */ public T walkInDefaultOrder(final FieldVectorChangingVisitor<T> visitor, final int start, final int end) throws MathIllegalArgumentException { checkIndices(start, end); visitor.start(getDimension(), start, end); for (int i = start; i <= end; i++) { setEntry(i, visitor.visit(i, getEntry(i))); } return visitor.end(); } /** * Visits (and possibly alters) all entries of this vector in optimized * order. The order in which the entries are visited is selected so as to * lead to the most efficient implementation; it might depend on the * concrete implementation of this abstract class. * * @param visitor the visitor to be used to process the entries of this * vector * @return the value returned by {@link FieldVectorChangingVisitor#end()} * at the end of the walk */ public T walkInOptimizedOrder(final FieldVectorChangingVisitor<T> visitor) { return walkInDefaultOrder(visitor); } /** * Visits (and possibly change) some entries of this vector in optimized * order. The order in which the entries are visited is selected so as to * lead to the most efficient implementation; it might depend on the * concrete implementation of this abstract class. * * @param visitor visitor to be used to process the entries of this vector * @param start the index of the first entry to be visited * @param end the index of the last entry to be visited (inclusive) * @return the value returned by {@link FieldVectorChangingVisitor#end()} * at the end of the walk * @throws MathIllegalArgumentException if {@code end < start}. * @throws MathIllegalArgumentException if the indices are not valid. */ public T walkInOptimizedOrder(final FieldVectorChangingVisitor<T> visitor, final int start, final int end) throws MathIllegalArgumentException { return walkInDefaultOrder(visitor, start, end); } /** * Test for the equality of two vectors. * * @param other Object to test for equality. * @return {@code true} if two vector objects are equal, {@code false} * otherwise. */ @Override public boolean equals(Object other) { |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 938 |
org/hipparchus/linear/BlockRealMatrix.java | 966 |
final T[] outBlock = out.blocks[outIndex]; final int index = pBlock * blockColumns + qBlock; final int width = blockWidth(qBlock); final int heightExcess = iHeight + rowsShift - BLOCK_SIZE; final int widthExcess = jWidth + columnsShift - BLOCK_SIZE; if (heightExcess > 0) { // the submatrix block spans on two blocks rows from the original matrix if (widthExcess > 0) { // the submatrix block spans on two blocks columns from the original matrix final int width2 = blockWidth(qBlock + 1); copyBlockPart(blocks[index], width, rowsShift, BLOCK_SIZE, columnsShift, BLOCK_SIZE, outBlock, jWidth, 0, 0); copyBlockPart(blocks[index + 1], width2, rowsShift, BLOCK_SIZE, 0, widthExcess, outBlock, jWidth, 0, jWidth - widthExcess); copyBlockPart(blocks[index + blockColumns], width, 0, heightExcess, columnsShift, BLOCK_SIZE, outBlock, jWidth, iHeight - heightExcess, 0); copyBlockPart(blocks[index + blockColumns + 1], width2, 0, heightExcess, 0, widthExcess, outBlock, jWidth, iHeight - heightExcess, jWidth - widthExcess); } else { // the submatrix block spans on one block column from the original matrix copyBlockPart(blocks[index], width, rowsShift, BLOCK_SIZE, columnsShift, jWidth + columnsShift, outBlock, jWidth, 0, 0); copyBlockPart(blocks[index + blockColumns], width, 0, heightExcess, columnsShift, jWidth + columnsShift, outBlock, jWidth, iHeight - heightExcess, 0); } } else { // the submatrix block spans on one block row from the original matrix if (widthExcess > 0) { // the submatrix block spans on two blocks columns from the original matrix final int width2 = blockWidth(qBlock + 1); copyBlockPart(blocks[index], width, rowsShift, iHeight + rowsShift, columnsShift, BLOCK_SIZE, outBlock, jWidth, 0, 0); copyBlockPart(blocks[index + 1], width2, rowsShift, iHeight + rowsShift, 0, widthExcess, outBlock, jWidth, 0, jWidth - widthExcess); } else { // the submatrix block spans on one block column from the original matrix copyBlockPart(blocks[index], width, rowsShift, iHeight + rowsShift, columnsShift, jWidth + columnsShift, outBlock, jWidth, 0, 0); } } ++qBlock; } ++pBlock; } return out; } /** * Copy a part of a block into another one * <p>This method can be called only when the specified part fits in both * blocks, no verification is done here.</p> * @param srcBlock source block * @param srcWidth source block width ({@link #BLOCK_SIZE} or smaller) * @param srcStartRow start row in the source block * @param srcEndRow end row (exclusive) in the source block * @param srcStartColumn start column in the source block * @param srcEndColumn end column (exclusive) in the source block * @param dstBlock destination block * @param dstWidth destination block width ({@link #BLOCK_SIZE} or smaller) * @param dstStartRow start row in the destination block * @param dstStartColumn start column in the destination block */ private void copyBlockPart(final T[] srcBlock, final int srcWidth, |
File | Line |
---|---|
org/hipparchus/util/MathArrays.java | 1193 |
org/hipparchus/util/MathArrays.java | 1289 |
final double a3, final double b3) { // the code below is split in many additions/subtractions that may // appear redundant. However, they should NOT be simplified, as they // do use IEEE754 floating point arithmetic rounding properties. // The variables naming conventions are that xyzHigh contains the most significant // bits of xyz and xyzLow contains its least significant bits. So theoretically // xyz is the sum xyzHigh + xyzLow, but in many cases below, this sum cannot // be represented in only one double precision number so we preserve two numbers // to hold it as long as we can, combining the high and low order bits together // only at the end, after cancellation may have occurred on high order bits // split a1 and b1 as one 26 bits number and one 27 bits number final double a1High = Double.longBitsToDouble(Double.doubleToRawLongBits(a1) & ((-1L) << 27)); final double a1Low = a1 - a1High; final double b1High = Double.longBitsToDouble(Double.doubleToRawLongBits(b1) & ((-1L) << 27)); final double b1Low = b1 - b1High; // accurate multiplication a1 * b1 final double prod1High = a1 * b1; final double prod1Low = a1Low * b1Low - (((prod1High - a1High * b1High) - a1Low * b1High) - a1High * b1Low); // split a2 and b2 as one 26 bits number and one 27 bits number final double a2High = Double.longBitsToDouble(Double.doubleToRawLongBits(a2) & ((-1L) << 27)); final double a2Low = a2 - a2High; final double b2High = Double.longBitsToDouble(Double.doubleToRawLongBits(b2) & ((-1L) << 27)); final double b2Low = b2 - b2High; // accurate multiplication a2 * b2 final double prod2High = a2 * b2; final double prod2Low = a2Low * b2Low - (((prod2High - a2High * b2High) - a2Low * b2High) - a2High * b2Low); // split a3 and b3 as one 26 bits number and one 27 bits number final double a3High = Double.longBitsToDouble(Double.doubleToRawLongBits(a3) & ((-1L) << 27)); final double a3Low = a3 - a3High; final double b3High = Double.longBitsToDouble(Double.doubleToRawLongBits(b3) & ((-1L) << 27)); final double b3Low = b3 - b3High; // accurate multiplication a3 * b3 final double prod3High = a3 * b3; final double prod3Low = a3Low * b3Low - (((prod3High - a3High * b3High) - a3Low * b3High) - a3High * b3Low); // accurate addition a1 * b1 + a2 * b2 final double s12High = prod1High + prod2High; |
File | Line |
---|---|
org/hipparchus/util/OpenIntToDoubleHashMap.java | 445 |
org/hipparchus/util/OpenIntToFieldHashMap.java | 458 |
final byte[] newStates = new byte[newLength]; final int newMask = newLength - 1; for (int i = 0; i < oldLength; ++i) { if (oldStates[i] == FULL) { final int key = oldKeys[i]; final int index = findInsertionIndex(newKeys, newStates, key, newMask); newKeys[index] = key; newValues[index] = oldValues[i]; newStates[index] = FULL; } } mask = newMask; keys = newKeys; values = newValues; states = newStates; } /** * Check if tables should grow due to increased size. * @return true if tables should grow */ private boolean shouldGrowTable() { return size > (mask + 1) * LOAD_FACTOR; } /** * Compute the hash value of a key * @param key key to hash * @return hash value of the key */ private static int hashOf(final int key) { final int h = key ^ ((key >>> 20) ^ (key >>> 12)); return h ^ (h >>> 7) ^ (h >>> 4); } /** Iterator class for the map. */ public class Iterator { /** Reference modification count. */ private final int referenceCount; /** Index of current element. */ private int current; /** Index of next element. */ private int next; /** * Simple constructor. */ private Iterator() { // preserve the modification count of the map to detect concurrent modifications later referenceCount = count; // initialize current index next = -1; try { advance(); } catch (NoSuchElementException nsee) { // NOPMD // ignored } } /** * Check if there is a next element in the map. * @return true if there is a next element */ public boolean hasNext() { return next >= 0; } /** * Get the key of current entry. * @return key of current entry * @exception ConcurrentModificationException if the map is modified during iteration * @exception NoSuchElementException if there is no element left in the map */ public int key() throws ConcurrentModificationException, NoSuchElementException { if (referenceCount != count) { throw new ConcurrentModificationException(); } if (current < 0) { throw new NoSuchElementException(); } return keys[current]; } /** * Get the value of current entry. * @return value of current entry * @exception ConcurrentModificationException if the map is modified during iteration * @exception NoSuchElementException if there is no element left in the map */ public double value() |
File | Line |
---|---|
org/hipparchus/analysis/differentiation/DSCompiler.java | 2192 |
org/hipparchus/analysis/differentiation/DSCompiler.java | 2309 |
p[0] = field.getOne().negate(); final T x2 = x.multiply(x); final T f = x2.subtract(1).negate().reciprocal(); T coeff = f.sqrt(); function[1] = coeff.multiply(p[0]); for (int n = 2; n <= order; ++n) { // update and evaluate polynomial P_n(x) T v = field.getZero(); p[n - 1] = p[n - 2].multiply(n - 1); for (int k = n - 1; k >= 0; k -= 2) { v = v.multiply(x2).add(p[k]); if (k > 2) { p[k - 2] = p[k - 1].multiply(k - 1).add(p[k - 3].multiply(2 * n - k)); } else if (k == 2) { p[0] = p[1]; } } if ((n & 0x1) == 0) { v = v.multiply(x); } coeff = coeff.multiply(f); function[n] = coeff.multiply(v); } } // apply function composition compose(operand, operandOffset, function, result, resultOffset); } /** Compute arc sine of a derivative structure. * @param operand array holding the operand * @param operandOffset offset of the operand in its array * @param result array where result must be stored (for * arc sine the result array <em>cannot</em> be the input * array) * @param resultOffset offset of the result in its array */ public void asin(final double[] operand, final int operandOffset, |
File | Line |
---|---|
org/hipparchus/linear/BlockRealMatrix.java | 1677 |
org/hipparchus/linear/BlockRealMatrix.java | 1707 |
public double walkInRowOrder(final RealMatrixChangingVisitor visitor, final int startRow, final int endRow, final int startColumn, final int endColumn) throws MathIllegalArgumentException { MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn); visitor.start(rows, columns, startRow, endRow, startColumn, endColumn); for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) { final int p0 = iBlock * BLOCK_SIZE; final int pStart = FastMath.max(startRow, p0); final int pEnd = FastMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow); for (int p = pStart; p < pEnd; ++p) { for (int jBlock = startColumn / BLOCK_SIZE; jBlock < 1 + endColumn / BLOCK_SIZE; ++jBlock) { final int jWidth = blockWidth(jBlock); final int q0 = jBlock * BLOCK_SIZE; final int qStart = FastMath.max(startColumn, q0); final int qEnd = FastMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn); final double[] block = blocks[iBlock * blockColumns + jBlock]; int k = (p - p0) * jWidth + qStart - q0; for (int q = qStart; q < qEnd; ++q) { |
File | Line |
---|---|
org/hipparchus/linear/BlockRealMatrix.java | 1787 |
org/hipparchus/linear/BlockRealMatrix.java | 1818 |
public double walkInOptimizedOrder(final RealMatrixChangingVisitor visitor, final int startRow, final int endRow, final int startColumn, final int endColumn) throws MathIllegalArgumentException { MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn); visitor.start(rows, columns, startRow, endRow, startColumn, endColumn); for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) { final int p0 = iBlock * BLOCK_SIZE; final int pStart = FastMath.max(startRow, p0); final int pEnd = FastMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow); for (int jBlock = startColumn / BLOCK_SIZE; jBlock < 1 + endColumn / BLOCK_SIZE; ++jBlock) { final int jWidth = blockWidth(jBlock); final int q0 = jBlock * BLOCK_SIZE; final int qStart = FastMath.max(startColumn, q0); final int qEnd = FastMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn); final double[] block = blocks[iBlock * blockColumns + jBlock]; for (int p = pStart; p < pEnd; ++p) { int k = (p - p0) * jWidth + qStart - q0; for (int q = qStart; q < qEnd; ++q) { |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 1667 |
org/hipparchus/linear/BlockFieldMatrix.java | 1697 |
public T walkInRowOrder(final FieldMatrixChangingVisitor<T> visitor, final int startRow, final int endRow, final int startColumn, final int endColumn) throws MathIllegalArgumentException { checkSubMatrixIndex(startRow, endRow, startColumn, endColumn); visitor.start(rows, columns, startRow, endRow, startColumn, endColumn); for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) { final int p0 = iBlock * BLOCK_SIZE; final int pStart = FastMath.max(startRow, p0); final int pEnd = FastMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow); for (int p = pStart; p < pEnd; ++p) { for (int jBlock = startColumn / BLOCK_SIZE; jBlock < 1 + endColumn / BLOCK_SIZE; ++jBlock) { final int jWidth = blockWidth(jBlock); final int q0 = jBlock * BLOCK_SIZE; final int qStart = FastMath.max(startColumn, q0); final int qEnd = FastMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn); final T[] block = blocks[iBlock * blockColumns + jBlock]; int k = (p - p0) * jWidth + qStart - q0; for (int q = qStart; q < qEnd; ++q) { |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 1777 |
org/hipparchus/linear/BlockFieldMatrix.java | 1807 |
public T walkInOptimizedOrder(final FieldMatrixChangingVisitor<T> visitor, final int startRow, final int endRow, final int startColumn, final int endColumn) throws MathIllegalArgumentException { checkSubMatrixIndex(startRow, endRow, startColumn, endColumn); visitor.start(rows, columns, startRow, endRow, startColumn, endColumn); for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) { final int p0 = iBlock * BLOCK_SIZE; final int pStart = FastMath.max(startRow, p0); final int pEnd = FastMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow); for (int jBlock = startColumn / BLOCK_SIZE; jBlock < 1 + endColumn / BLOCK_SIZE; ++jBlock) { final int jWidth = blockWidth(jBlock); final int q0 = jBlock * BLOCK_SIZE; final int qStart = FastMath.max(startColumn, q0); final int qEnd = FastMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn); final T[] block = blocks[iBlock * blockColumns + jBlock]; for (int p = pStart; p < pEnd; ++p) { int k = (p - p0) * jWidth + qStart - q0; for (int q = qStart; q < qEnd; ++q) { |
File | Line |
---|---|
org/hipparchus/analysis/differentiation/DSCompiler.java | 2132 |
org/hipparchus/analysis/differentiation/DSCompiler.java | 2249 |
p[0] = -1; final double x2 = x * x; final double f = 1.0 / (1 - x2); double coeff = FastMath.sqrt(f); function[1] = coeff * p[0]; for (int n = 2; n <= order; ++n) { // update and evaluate polynomial P_n(x) double v = 0; p[n - 1] = (n - 1) * p[n - 2]; for (int k = n - 1; k >= 0; k -= 2) { v = v * x2 + p[k]; if (k > 2) { p[k - 2] = (k - 1) * p[k - 1] + (2 * n - k) * p[k - 3]; } else if (k == 2) { p[0] = p[1]; } } if ((n & 0x1) == 0) { v *= x; } coeff *= f; function[n] = coeff * v; } } // apply function composition compose(operand, operandOffset, function, result, resultOffset); } /** Compute arc cosine of a derivative structure. * @param operand array holding the operand * @param operandOffset offset of the operand in its array * @param result array where result must be stored (for * arc cosine the result array <em>cannot</em> be the input * array) * @param resultOffset offset of the result in its array * @param <T> the type of the function parameters and value */ public <T extends RealFieldElement<T>> void acos(final T[] operand, final int operandOffset, |
File | Line |
---|---|
org/hipparchus/linear/FieldLUDecomposition.java | 284 |
org/hipparchus/linear/FieldLUDecomposition.java | 330 |
b.getDimension(), m); } if (singular) { throw new MathIllegalArgumentException(LocalizedCoreFormats.SINGULAR_MATRIX); } // Apply permutations to b final T[] bp = MathArrays.buildArray(field, m); for (int row = 0; row < m; row++) { bp[row] = b.getEntry(pivot[row]); } // Solve LY = b for (int col = 0; col < m; col++) { final T bpCol = bp[col]; for (int i = col + 1; i < m; i++) { bp[i] = bp[i].subtract(bpCol.multiply(lu[i][col])); } } // Solve UX = Y for (int col = m - 1; col >= 0; col--) { bp[col] = bp[col].divide(lu[col][col]); final T bpCol = bp[col]; for (int i = 0; i < col; i++) { bp[i] = bp[i].subtract(bpCol.multiply(lu[i][col])); } } return new ArrayFieldVector<T>(field, bp, false); |
File | Line |
---|---|
org/hipparchus/random/Well44497a.java | 88 |
org/hipparchus/random/Well44497b.java | 87 |
public Well44497a(long seed) { super(K, seed); } /** {@inheritDoc} */ @Override public int nextInt() { final int indexRm1 = TABLE.getIndexPred(index); final int indexRm2 = TABLE.getIndexPred2(index); final int v0 = v[index]; final int vM1 = v[TABLE.getIndexM1(index)]; final int vM2 = v[TABLE.getIndexM2(index)]; final int vM3 = v[TABLE.getIndexM3(index)]; // the values below include the errata of the original article final int z0 = (0xFFFF8000 & v[indexRm1]) ^ (0x00007FFF & v[indexRm2]); final int z1 = (v0 ^ (v0 << 24)) ^ (vM1 ^ (vM1 >>> 30)); final int z2 = (vM2 ^ (vM2 << 10)) ^ (vM3 << 26); final int z3 = z1 ^ z2; final int z2Prime = ((z2 << 9) ^ (z2 >>> 23)) & 0xfbffffff; final int z2Second = ((z2 & 0x00020000) != 0) ? (z2Prime ^ 0xb729fcec) : z2Prime; |
File | Line |
---|---|
org/hipparchus/util/MathArrays.java | 1117 |
org/hipparchus/util/MathArrays.java | 1193 |
org/hipparchus/util/MathArrays.java | 1289 |
final double a2, final double b2) { // the code below is split in many additions/subtractions that may // appear redundant. However, they should NOT be simplified, as they // use IEEE754 floating point arithmetic rounding properties. // The variable naming conventions are that xyzHigh contains the most significant // bits of xyz and xyzLow contains its least significant bits. So theoretically // xyz is the sum xyzHigh + xyzLow, but in many cases below, this sum cannot // be represented in only one double precision number so we preserve two numbers // to hold it as long as we can, combining the high and low order bits together // only at the end, after cancellation may have occurred on high order bits // split a1 and b1 as one 26 bits number and one 27 bits number final double a1High = Double.longBitsToDouble(Double.doubleToRawLongBits(a1) & ((-1L) << 27)); final double a1Low = a1 - a1High; final double b1High = Double.longBitsToDouble(Double.doubleToRawLongBits(b1) & ((-1L) << 27)); final double b1Low = b1 - b1High; // accurate multiplication a1 * b1 final double prod1High = a1 * b1; final double prod1Low = a1Low * b1Low - (((prod1High - a1High * b1High) - a1Low * b1High) - a1High * b1Low); // split a2 and b2 as one 26 bits number and one 27 bits number final double a2High = Double.longBitsToDouble(Double.doubleToRawLongBits(a2) & ((-1L) << 27)); final double a2Low = a2 - a2High; final double b2High = Double.longBitsToDouble(Double.doubleToRawLongBits(b2) & ((-1L) << 27)); final double b2Low = b2 - b2High; // accurate multiplication a2 * b2 final double prod2High = a2 * b2; final double prod2Low = a2Low * b2Low - (((prod2High - a2High * b2High) - a2Low * b2High) - a2High * b2Low); // accurate addition a1 * b1 + a2 * b2 final double s12High = prod1High + prod2High; |
File | Line |
---|---|
org/hipparchus/analysis/differentiation/FieldGradient.java | 860 |
org/hipparchus/analysis/differentiation/FieldGradient.java | 884 |
public FieldGradient<T> linearCombination(final T[] a, final FieldGradient<T>[] b) { // extract values and first derivatives final Field<T> field = b[0].value.getField(); final int n = b.length; final T[] b0 = MathArrays.buildArray(field, n); final T[] b1 = MathArrays.buildArray(field, n); for (int i = 0; i < n; ++i) { b0[i] = b[i].value; } final FieldGradient<T> result = newInstance(b[0].value.linearCombination(a, b0)); for (int k = 0; k < grad.length; ++k) { for (int i = 0; i < n; ++i) { b1[i] = b[i].grad[k]; } result.grad[k] = b[0].value.linearCombination(a, b1); } return result; } /** {@inheritDoc} */ @Override public FieldGradient<T> linearCombination(final double[] a, final FieldGradient<T>[] b) { |
File | Line |
---|---|
org/hipparchus/analysis/differentiation/FieldUnivariateDerivative2.java | 737 |
org/hipparchus/analysis/differentiation/FieldUnivariateDerivative2.java | 796 |
public FieldUnivariateDerivative2<T> linearCombination(final T[] a, final FieldUnivariateDerivative2<T>[] b) { // extract values and derivatives final Field<T> field = b[0].f0.getField(); final int n = b.length; final T[] b0 = MathArrays.buildArray(field, n); final T[] b1 = MathArrays.buildArray(field, n); final T[] b2 = MathArrays.buildArray(field, n); for (int i = 0; i < n; ++i) { b0[i] = b[i].f0; b1[i] = b[i].f1; b2[i] = b[i].f2; } return new FieldUnivariateDerivative2<>(b[0].f0.linearCombination(a, b0), b[0].f0.linearCombination(a, b1), b[0].f0.linearCombination(a, b2)); } /** {@inheritDoc} */ @Override public FieldUnivariateDerivative2<T> linearCombination(final FieldUnivariateDerivative2<T>[] a, |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 1049 |
org/hipparchus/linear/BlockRealMatrix.java | 1077 |
for (final T[] subRow : subMatrix) { if (subRow.length != refLength) { throw new MathIllegalArgumentException(LocalizedCoreFormats.DIMENSIONS_MISMATCH, refLength, subRow.length); } } // compute blocks bounds final int blockStartRow = row / BLOCK_SIZE; final int blockEndRow = (endRow + BLOCK_SIZE) / BLOCK_SIZE; final int blockStartColumn = column / BLOCK_SIZE; final int blockEndColumn = (endColumn + BLOCK_SIZE) / BLOCK_SIZE; // perform copy block-wise, to ensure good cache behavior for (int iBlock = blockStartRow; iBlock < blockEndRow; ++iBlock) { final int iHeight = blockHeight(iBlock); final int firstRow = iBlock * BLOCK_SIZE; final int iStart = FastMath.max(row, firstRow); final int iEnd = FastMath.min(endRow + 1, firstRow + iHeight); for (int jBlock = blockStartColumn; jBlock < blockEndColumn; ++jBlock) { final int jWidth = blockWidth(jBlock); final int firstColumn = jBlock * BLOCK_SIZE; final int jStart = FastMath.max(column, firstColumn); final int jEnd = FastMath.min(endColumn + 1, firstColumn + jWidth); final int jLength = jEnd - jStart; // handle one block, row by row final T[] block = blocks[iBlock * blockColumns + jBlock]; |
File | Line |
---|---|
org/hipparchus/analysis/solvers/BracketingNthOrderBrentSolver.java | 301 |
org/hipparchus/analysis/solvers/FieldBracketingNthOrderBrentSolver.java | 363 |
return new Interval(nextX, nextY, nextX, nextY); } if ((nbPoints > 2) && (end - start != nbPoints)) { // we have been forced to ignore some points to keep bracketing, // they are probably too far from the root, drop them from now on nbPoints = end - start; System.arraycopy(x, start, x, 0, nbPoints); System.arraycopy(y, start, y, 0, nbPoints); signChangeIndex -= start; } else if (nbPoints == x.length) { // we have to drop one point in order to insert the new one nbPoints--; // keep the tightest bracketing interval as centered as possible if (signChangeIndex >= (x.length + 1) / 2) { // we drop the lowest point, we have to shift the arrays and the index System.arraycopy(x, 1, x, 0, nbPoints); System.arraycopy(y, 1, y, 0, nbPoints); --signChangeIndex; } } // insert the last computed point //(by construction, we know it lies inside the tightest bracketing interval) System.arraycopy(x, signChangeIndex, x, signChangeIndex + 1, nbPoints - signChangeIndex); x[signChangeIndex] = nextX; System.arraycopy(y, signChangeIndex, y, signChangeIndex + 1, nbPoints - signChangeIndex); y[signChangeIndex] = nextY; ++nbPoints; // update the bracketing interval if (nextY * yA <= 0) { |
File | Line |
---|---|
org/hipparchus/analysis/differentiation/FieldDerivativeStructure.java | 879 |
org/hipparchus/analysis/differentiation/FieldDerivativeStructure.java | 907 |
public FieldDerivativeStructure<T> linearCombination(final T[] a, final FieldDerivativeStructure<T>[] b) throws MathIllegalArgumentException { // compute an accurate value, taking care of cancellations final T[] bT = MathArrays.buildArray(factory.getValueField(), b.length); for (int i = 0; i < b.length; ++i) { bT[i] = b[i].getValue(); } final T accurateValue = bT[0].linearCombination(a, bT); // compute a simple value, with all partial derivatives FieldDerivativeStructure<T> simpleValue = b[0].getField().getZero(); for (int i = 0; i < a.length; ++i) { simpleValue = simpleValue.add(b[i].multiply(a[i])); } // create a result with accurate value and all derivatives (not necessarily as accurate as the value) final T[] all = simpleValue.getAllDerivatives(); all[0] = accurateValue; return factory.build(all); } /** {@inheritDoc} * @exception MathIllegalArgumentException if number of free parameters * or orders do not match */ @Override public FieldDerivativeStructure<T> linearCombination(final double[] a, final FieldDerivativeStructure<T>[] b) |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 1492 |
org/hipparchus/util/FastMathLiteralArrays.java | 2998 |
+8.218407798110846E307d, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, }; /** Exponential evaluated at integer values, * exp(x) = expIntTableA[x + EXP_INT_TABLE_MAX_INDEX] + expIntTableB[x+EXP_INT_TABLE_MAX_INDEX] */ private static final double[] EXP_INT_B = { |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 32 |
org/hipparchus/util/FastMathLiteralArrays.java | 1538 |
private static final double[] EXP_INT_A = { +0.0d, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/random/Well19937a.java | 89 |
org/hipparchus/random/Well19937c.java | 89 |
public Well19937a(long seed) { super(K, seed); } /** {@inheritDoc} */ @Override public int nextInt() { final int indexRm1 = TABLE.getIndexPred(index); final int indexRm2 = TABLE.getIndexPred2(index); final int v0 = v[index]; final int vM1 = v[TABLE.getIndexM1(index)]; final int vM2 = v[TABLE.getIndexM2(index)]; final int vM3 = v[TABLE.getIndexM3(index)]; final int z0 = (0x80000000 & v[indexRm1]) ^ (0x7FFFFFFF & v[indexRm2]); final int z1 = (v0 ^ (v0 << 25)) ^ (vM1 ^ (vM1 >>> 27)); final int z2 = (vM2 >>> 9) ^ (vM3 ^ (vM3 >>> 1)); final int z3 = z1 ^ z2; |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 1671 |
org/hipparchus/linear/BlockFieldMatrix.java | 1701 |
org/hipparchus/linear/BlockRealMatrix.java | 1681 |
org/hipparchus/linear/BlockRealMatrix.java | 1711 |
checkSubMatrixIndex(startRow, endRow, startColumn, endColumn); visitor.start(rows, columns, startRow, endRow, startColumn, endColumn); for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) { final int p0 = iBlock * BLOCK_SIZE; final int pStart = FastMath.max(startRow, p0); final int pEnd = FastMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow); for (int p = pStart; p < pEnd; ++p) { for (int jBlock = startColumn / BLOCK_SIZE; jBlock < 1 + endColumn / BLOCK_SIZE; ++jBlock) { final int jWidth = blockWidth(jBlock); final int q0 = jBlock * BLOCK_SIZE; final int qStart = FastMath.max(startColumn, q0); final int qEnd = FastMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn); final T[] block = blocks[iBlock * blockColumns + jBlock]; |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 327 |
org/hipparchus/linear/BlockFieldMatrix.java | 399 |
checkAdditionCompatible(m); final BlockFieldMatrix<T> out = new BlockFieldMatrix<>(getField(), rows, columns); // perform addition block-wise, to ensure good cache behavior int blockIndex = 0; for (int iBlock = 0; iBlock < out.blockRows; ++iBlock) { for (int jBlock = 0; jBlock < out.blockColumns; ++jBlock) { // perform addition on the current block final T[] outBlock = out.blocks[blockIndex]; final T[] tBlock = blocks[blockIndex]; final int pStart = iBlock * BLOCK_SIZE; final int pEnd = FastMath.min(pStart + BLOCK_SIZE, rows); final int qStart = jBlock * BLOCK_SIZE; final int qEnd = FastMath.min(qStart + BLOCK_SIZE, columns); int k = 0; for (int p = pStart; p < pEnd; ++p) { for (int q = qStart; q < qEnd; ++q) { outBlock[k] = tBlock[k].add(m.getEntry(p, q)); |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 33 |
org/hipparchus/util/FastMathLiteralArrays.java | 1492 |
org/hipparchus/util/FastMathLiteralArrays.java | 1539 |
org/hipparchus/util/FastMathLiteralArrays.java | 2998 |
+0.0d, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 33 |
org/hipparchus/util/FastMathLiteralArrays.java | 1493 |
org/hipparchus/util/FastMathLiteralArrays.java | 1540 |
org/hipparchus/util/FastMathLiteralArrays.java | 2999 |
+0.0d, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 34 |
org/hipparchus/util/FastMathLiteralArrays.java | 1492 |
org/hipparchus/util/FastMathLiteralArrays.java | 1539 |
org/hipparchus/util/FastMathLiteralArrays.java | 2998 |
Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/linear/BlockRealMatrix.java | 310 |
org/hipparchus/linear/BlockRealMatrix.java | 378 |
MatrixUtils.checkAdditionCompatible(this, m); final BlockRealMatrix out = new BlockRealMatrix(rows, columns); // perform addition block-wise, to ensure good cache behavior int blockIndex = 0; for (int iBlock = 0; iBlock < out.blockRows; ++iBlock) { final int pStart = iBlock * BLOCK_SIZE; final int pEnd = FastMath.min(pStart + BLOCK_SIZE, rows); for (int jBlock = 0; jBlock < out.blockColumns; ++jBlock) { // perform addition on the current block final double[] outBlock = out.blocks[blockIndex]; final double[] tBlock = blocks[blockIndex]; final int qStart = jBlock * BLOCK_SIZE; final int qEnd = FastMath.min(qStart + BLOCK_SIZE, columns); int k = 0; for (int p = pStart; p < pEnd; ++p) { for (int q = qStart; q < qEnd; ++q) { outBlock[k] = tBlock[k] + m.getEntry(p, q); |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 33 |
org/hipparchus/util/FastMathLiteralArrays.java | 1494 |
org/hipparchus/util/FastMathLiteralArrays.java | 1541 |
org/hipparchus/util/FastMathLiteralArrays.java | 3000 |
+0.0d, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 35 |
org/hipparchus/util/FastMathLiteralArrays.java | 1492 |
org/hipparchus/util/FastMathLiteralArrays.java | 1539 |
org/hipparchus/util/FastMathLiteralArrays.java | 2998 |
Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 1619 |
org/hipparchus/linear/BlockFieldMatrix.java | 1643 |
public T walkInRowOrder(final FieldMatrixChangingVisitor<T> visitor) { visitor.start(rows, columns, 0, rows - 1, 0, columns - 1); for (int iBlock = 0; iBlock < blockRows; ++iBlock) { final int pStart = iBlock * BLOCK_SIZE; final int pEnd = FastMath.min(pStart + BLOCK_SIZE, rows); for (int p = pStart; p < pEnd; ++p) { for (int jBlock = 0; jBlock < blockColumns; ++jBlock) { final int jWidth = blockWidth(jBlock); final int qStart = jBlock * BLOCK_SIZE; final int qEnd = FastMath.min(qStart + BLOCK_SIZE, columns); final T[] block = blocks[iBlock * blockColumns + jBlock]; int k = (p - pStart) * jWidth; for (int q = qStart; q < qEnd; ++q) { |
File | Line |
---|---|
org/hipparchus/analysis/differentiation/FieldUnivariateDerivative1.java | 657 |
org/hipparchus/analysis/differentiation/FieldUnivariateDerivative1.java | 704 |
public FieldUnivariateDerivative1<T> linearCombination(final T[] a, final FieldUnivariateDerivative1<T>[] b) { // extract values and first derivatives final Field<T> field = b[0].f0.getField(); final int n = b.length; final T[] b0 = MathArrays.buildArray(field, n); final T[] b1 = MathArrays.buildArray(field, n); for (int i = 0; i < n; ++i) { b0[i] = b[i].f0; b1[i] = b[i].f1; } return new FieldUnivariateDerivative1<>(b[0].f0.linearCombination(a, b0), b[0].f0.linearCombination(a, b1)); } /** {@inheritDoc} */ @Override public FieldUnivariateDerivative1<T> linearCombination(final FieldUnivariateDerivative1<T>[] a, |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 1781 |
org/hipparchus/linear/BlockFieldMatrix.java | 1811 |
org/hipparchus/linear/BlockRealMatrix.java | 1792 |
org/hipparchus/linear/BlockRealMatrix.java | 1823 |
checkSubMatrixIndex(startRow, endRow, startColumn, endColumn); visitor.start(rows, columns, startRow, endRow, startColumn, endColumn); for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) { final int p0 = iBlock * BLOCK_SIZE; final int pStart = FastMath.max(startRow, p0); final int pEnd = FastMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow); for (int jBlock = startColumn / BLOCK_SIZE; jBlock < 1 + endColumn / BLOCK_SIZE; ++jBlock) { final int jWidth = blockWidth(jBlock); final int q0 = jBlock * BLOCK_SIZE; final int qStart = FastMath.max(startColumn, q0); final int qEnd = FastMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn); final T[] block = blocks[iBlock * blockColumns + jBlock]; |
File | Line |
---|---|
org/hipparchus/linear/BlockRealMatrix.java | 1629 |
org/hipparchus/linear/BlockRealMatrix.java | 1653 |
public double walkInRowOrder(final RealMatrixChangingVisitor visitor) { visitor.start(rows, columns, 0, rows - 1, 0, columns - 1); for (int iBlock = 0; iBlock < blockRows; ++iBlock) { final int pStart = iBlock * BLOCK_SIZE; final int pEnd = FastMath.min(pStart + BLOCK_SIZE, rows); for (int p = pStart; p < pEnd; ++p) { for (int jBlock = 0; jBlock < blockColumns; ++jBlock) { final int jWidth = blockWidth(jBlock); final int qStart = jBlock * BLOCK_SIZE; final int qEnd = FastMath.min(qStart + BLOCK_SIZE, columns); final double[] block = blocks[iBlock * blockColumns + jBlock]; int k = (p - pStart) * jWidth; for (int q = qStart; q < qEnd; ++q) { |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 33 |
org/hipparchus/util/FastMathLiteralArrays.java | 1495 |
org/hipparchus/util/FastMathLiteralArrays.java | 1542 |
org/hipparchus/util/FastMathLiteralArrays.java | 3001 |
+0.0d, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 36 |
org/hipparchus/util/FastMathLiteralArrays.java | 1492 |
org/hipparchus/util/FastMathLiteralArrays.java | 1539 |
org/hipparchus/util/FastMathLiteralArrays.java | 2998 |
Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/analysis/differentiation/FieldGradient.java | 1024 |
org/hipparchus/analysis/differentiation/Gradient.java | 847 |
final FieldGradient<T> result = newInstance(a1.value.linearCombination(a1.value, b1.value, a2.value, b2.value, a3.value, b3.value, a4.value, b4.value)); for (int i = 0; i < b1.grad.length; ++i) { a[1] = a1.grad[i]; a[3] = a2.grad[i]; a[5] = a3.grad[i]; a[7] = a4.grad[i]; b[0] = b1.grad[i]; b[2] = b2.grad[i]; b[4] = b3.grad[i]; b[6] = b4.grad[i]; result.grad[i] = a1.value.linearCombination(a, b); |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 52 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 64 |
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 33 |
org/hipparchus/util/FastMathLiteralArrays.java | 1496 |
org/hipparchus/util/FastMathLiteralArrays.java | 1543 |
org/hipparchus/util/FastMathLiteralArrays.java | 3002 |
+0.0d, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 37 |
org/hipparchus/util/FastMathLiteralArrays.java | 1492 |
org/hipparchus/util/FastMathLiteralArrays.java | 1539 |
org/hipparchus/util/FastMathLiteralArrays.java | 2998 |
Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/util/OpenIntToDoubleHashMap.java | 138 |
org/hipparchus/util/OpenIntToFieldHashMap.java | 151 |
System.arraycopy(source.values, 0, values, 0, length); states = new byte[length]; System.arraycopy(source.states, 0, states, 0, length); missingEntries = source.missingEntries; size = source.size; mask = source.mask; count = source.count; } /** * Compute the capacity needed for a given size. * @param expectedSize expected size of the map * @return capacity to use for the specified size */ private static int computeCapacity(final int expectedSize) { if (expectedSize == 0) { return 1; } final int capacity = (int) FastMath.ceil(expectedSize / LOAD_FACTOR); final int powerOfTwo = Integer.highestOneBit(capacity); if (powerOfTwo == capacity) { return capacity; } return nextPowerOfTwo(capacity); } /** * Find the smallest power of two greater than the input value * @param i input value * @return smallest power of two greater than the input value */ private static int nextPowerOfTwo(final int i) { return Integer.highestOneBit(i) << 1; } /** * Get the stored value associated with the given key * @param key key associated with the data * @return data associated with the key */ public double get(final int key) { |
File | Line |
---|---|
org/hipparchus/util/OpenIntToDoubleHashMap.java | 352 |
org/hipparchus/util/OpenIntToFieldHashMap.java | 365 |
public double remove(final int key) { final int hash = hashOf(key); int index = hash & mask; if (containsKey(key, index)) { return doRemove(index); } if (states[index] == FREE) { return missingEntries; } int j = index; for (int perturb = perturb(hash); states[index] != FREE; perturb >>= PERTURB_SHIFT) { j = probe(perturb, j); index = j & mask; if (containsKey(key, index)) { return doRemove(index); } } return missingEntries; } /** * Check if the tables contain an element associated with specified key * at specified index. * @param key key to check * @param index index to check * @return true if an element is associated with key at index */ private boolean containsKey(final int key, final int index) { return (key != 0 || states[index] == FULL) && keys[index] == key; } /** * Remove an element at specified index. * @param index index of the element to remove * @return removed value */ private double doRemove(int index) { |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 33 |
org/hipparchus/util/FastMathLiteralArrays.java | 1497 |
org/hipparchus/util/FastMathLiteralArrays.java | 1544 |
org/hipparchus/util/FastMathLiteralArrays.java | 3003 |
+0.0d, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 38 |
org/hipparchus/util/FastMathLiteralArrays.java | 1492 |
org/hipparchus/util/FastMathLiteralArrays.java | 1539 |
org/hipparchus/util/FastMathLiteralArrays.java | 2998 |
Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 1727 |
org/hipparchus/linear/BlockFieldMatrix.java | 1752 |
public T walkInOptimizedOrder(final FieldMatrixChangingVisitor<T> visitor) { visitor.start(rows, columns, 0, rows - 1, 0, columns - 1); int blockIndex = 0; for (int iBlock = 0; iBlock < blockRows; ++iBlock) { final int pStart = iBlock * BLOCK_SIZE; final int pEnd = FastMath.min(pStart + BLOCK_SIZE, rows); for (int jBlock = 0; jBlock < blockColumns; ++jBlock) { final int qStart = jBlock * BLOCK_SIZE; final int qEnd = FastMath.min(qStart + BLOCK_SIZE, columns); final T[] block = blocks[blockIndex]; int k = 0; for (int p = pStart; p < pEnd; ++p) { for (int q = qStart; q < qEnd; ++q) { |
File | Line |
---|---|
org/hipparchus/linear/BlockRealMatrix.java | 493 |
org/hipparchus/linear/BlockRealMatrix.java | 680 |
final int qEnd = FastMath.min(qStart + BLOCK_SIZE, m.getColumnDimension()); // select current block final double[] outBlock = out.blocks[blockIndex]; // perform multiplication on current block for (int kBlock = 0; kBlock < blockColumns; ++kBlock) { final int kWidth = blockWidth(kBlock); final double[] tBlock = blocks[iBlock * blockColumns + kBlock]; final int rStart = kBlock * BLOCK_SIZE; int k = 0; for (int p = pStart; p < pEnd; ++p) { final int lStart = (p - pStart) * kWidth; final int lEnd = lStart + kWidth; for (int q = qStart; q < qEnd; ++q) { double sum = 0; int r = rStart; for (int l = lStart; l < lEnd; ++l) { sum += tBlock[l] * m.getEntry(r++, q); |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 33 |
org/hipparchus/util/FastMathLiteralArrays.java | 1498 |
org/hipparchus/util/FastMathLiteralArrays.java | 1545 |
org/hipparchus/util/FastMathLiteralArrays.java | 3004 |
+0.0d, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 39 |
org/hipparchus/util/FastMathLiteralArrays.java | 1492 |
org/hipparchus/util/FastMathLiteralArrays.java | 1539 |
org/hipparchus/util/FastMathLiteralArrays.java | 2998 |
Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/linear/BlockRealMatrix.java | 1737 |
org/hipparchus/linear/BlockRealMatrix.java | 1762 |
public double walkInOptimizedOrder(final RealMatrixChangingVisitor visitor) { visitor.start(rows, columns, 0, rows - 1, 0, columns - 1); int blockIndex = 0; for (int iBlock = 0; iBlock < blockRows; ++iBlock) { final int pStart = iBlock * BLOCK_SIZE; final int pEnd = FastMath.min(pStart + BLOCK_SIZE, rows); for (int jBlock = 0; jBlock < blockColumns; ++jBlock) { final int qStart = jBlock * BLOCK_SIZE; final int qEnd = FastMath.min(qStart + BLOCK_SIZE, columns); final double[] block = blocks[blockIndex]; int k = 0; for (int p = pStart; p < pEnd; ++p) { for (int q = qStart; q < qEnd; ++q) { |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 33 |
org/hipparchus/util/FastMathLiteralArrays.java | 1499 |
org/hipparchus/util/FastMathLiteralArrays.java | 1546 |
org/hipparchus/util/FastMathLiteralArrays.java | 3005 |
+0.0d, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 40 |
org/hipparchus/util/FastMathLiteralArrays.java | 1492 |
org/hipparchus/util/FastMathLiteralArrays.java | 1539 |
org/hipparchus/util/FastMathLiteralArrays.java | 2998 |
Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 1822 |
org/hipparchus/linear/BlockRealMatrix.java | 1834 |
final T[] block = blocks[iBlock * blockColumns + jBlock]; for (int p = pStart; p < pEnd; ++p) { int k = (p - p0) * jWidth + qStart - q0; for (int q = qStart; q < qEnd; ++q) { visitor.visit(p, q, block[k]); ++k; } } } } return visitor.end(); } /** * Get the height of a block. * @param blockRow row index (in block sense) of the block * @return height (number of rows) of the block */ private int blockHeight(final int blockRow) { return (blockRow == blockRows - 1) ? rows - blockRow * BLOCK_SIZE : BLOCK_SIZE; } /** * Get the width of a block. * @param blockColumn column index (in block sense) of the block * @return width (number of columns) of the block */ private int blockWidth(final int blockColumn) { return (blockColumn == blockColumns - 1) ? columns - blockColumn * BLOCK_SIZE : BLOCK_SIZE; } } |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/AkimaSplineInterpolator.java | 120 |
org/hipparchus/analysis/interpolation/AkimaSplineInterpolator.java | 202 |
firstDerivatives[i] = ((wP * differences[i - 1]) + (wM * differences[i])) / (wP + wM); } } firstDerivatives[0] = differentiateThreePoint(xvals, yvals, 0, 0, 1, 2); firstDerivatives[1] = differentiateThreePoint(xvals, yvals, 1, 0, 1, 2); firstDerivatives[xvals.length - 2] = differentiateThreePoint(xvals, yvals, xvals.length - 2, xvals.length - 3, xvals.length - 2, xvals.length - 1); firstDerivatives[xvals.length - 1] = differentiateThreePoint(xvals, yvals, xvals.length - 1, xvals.length - 3, xvals.length - 2, xvals.length - 1); return interpolateHermiteSorted(xvals, yvals, firstDerivatives); } |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 52 |
{ 2,-2,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 67 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 68 |
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 33 |
org/hipparchus/util/FastMathLiteralArrays.java | 1500 |
org/hipparchus/util/FastMathLiteralArrays.java | 1547 |
org/hipparchus/util/FastMathLiteralArrays.java | 3006 |
+0.0d, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 41 |
org/hipparchus/util/FastMathLiteralArrays.java | 1492 |
org/hipparchus/util/FastMathLiteralArrays.java | 1539 |
org/hipparchus/util/FastMathLiteralArrays.java | 2998 |
Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/util/OpenIntToDoubleHashMap.java | 544 |
org/hipparchus/util/OpenIntToFieldHashMap.java | 557 |
public double value() throws ConcurrentModificationException, NoSuchElementException { if (referenceCount != count) { throw new ConcurrentModificationException(); } if (current < 0) { throw new NoSuchElementException(); } return values[current]; } /** * Advance iterator one step further. * @exception ConcurrentModificationException if the map is modified during iteration * @exception NoSuchElementException if there is no element left in the map */ public void advance() throws ConcurrentModificationException, NoSuchElementException { if (referenceCount != count) { throw new ConcurrentModificationException(); } // advance on step current = next; // prepare next step try { while (states[++next] != FULL) { // NOPMD // nothing to do } } catch (ArrayIndexOutOfBoundsException e) { next = -2; if (current < 0) { throw new NoSuchElementException(); // NOPMD } } } } /** * Read a serialized object. * @param stream input stream * @throws IOException if object cannot be read * @throws ClassNotFoundException if the class corresponding * to the serialized object cannot be found */ private void readObject(final ObjectInputStream stream) throws IOException, ClassNotFoundException { stream.defaultReadObject(); count = 0; } |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 64 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 67 |
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/linear/MatrixUtils.java | 1030 |
org/hipparchus/linear/MatrixUtils.java | 1074 |
public static void solveLowerTriangularSystem(RealMatrix rm, RealVector b) throws MathIllegalArgumentException, MathRuntimeException { if ((rm == null) || (b == null) || ( rm.getRowDimension() != b.getDimension())) { throw new MathIllegalArgumentException(LocalizedCoreFormats.DIMENSIONS_MISMATCH, (rm == null) ? 0 : rm.getRowDimension(), (b == null) ? 0 : b.getDimension()); } if( rm.getColumnDimension() != rm.getRowDimension() ){ throw new MathIllegalArgumentException(LocalizedCoreFormats.NON_SQUARE_MATRIX, rm.getRowDimension(), rm.getColumnDimension()); } int rows = rm.getRowDimension(); for( int i = 0 ; i < rows ; i++ ){ |
File | Line |
---|---|
org/hipparchus/analysis/differentiation/DSCompiler.java | 2873 |
org/hipparchus/analysis/differentiation/DSCompiler.java | 2990 |
final T f = x2.subtract(1).reciprocal(); T coeff = f.sqrt(); function[1] = coeff.multiply(p[0]); for (int n = 2; n <= order; ++n) { // update and evaluate polynomial P_n(x) T v = field.getZero(); p[n - 1] = p[n - 2].multiply(1 - n); for (int k = n - 1; k >= 0; k -= 2) { v = v.multiply(x2).add(p[k]); if (k > 2) { p[k - 2] = p[k - 1].multiply(1 - k).add(p[k - 3].multiply(k - 2 * n)); |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 33 |
org/hipparchus/util/FastMathLiteralArrays.java | 1501 |
org/hipparchus/util/FastMathLiteralArrays.java | 1548 |
org/hipparchus/util/FastMathLiteralArrays.java | 3007 |
+0.0d, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 42 |
org/hipparchus/util/FastMathLiteralArrays.java | 1492 |
org/hipparchus/util/FastMathLiteralArrays.java | 1539 |
org/hipparchus/util/FastMathLiteralArrays.java | 2998 |
Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 762 |
org/hipparchus/linear/BlockRealMatrix.java | 727 |
final BlockFieldMatrix<T> out = new BlockFieldMatrix<>(getField(), columns, m.columns); // perform multiplication block-wise, to ensure good cache behavior int blockIndex = 0; for (int iBlock = 0; iBlock < out.blockRows; ++iBlock) { final int iHeight = out.blockHeight(iBlock); final int iHeight2 = iHeight + iHeight; final int iHeight3 = iHeight2 + iHeight; final int iHeight4 = iHeight3 + iHeight; final int pStart = iBlock * BLOCK_SIZE; final int pEnd = FastMath.min(pStart + BLOCK_SIZE, columns); for (int jBlock = 0; jBlock < out.blockColumns; ++jBlock) { final int jWidth = out.blockWidth(jBlock); final int jWidth2 = jWidth + jWidth; final int jWidth3 = jWidth2 + jWidth; final int jWidth4 = jWidth3 + jWidth; // select current block final T[] outBlock = out.blocks[blockIndex]; |
File | Line |
---|---|
org/hipparchus/util/FastMathCalc.java | 207 |
org/hipparchus/util/FastMathCalc.java | 252 |
static double slowCos(final double x, final double result[]) { final double xs[] = new double[2]; final double ys[] = new double[2]; final double facts[] = new double[2]; final double as[] = new double[2]; split(x, xs); ys[0] = ys[1] = 0.0; for (int i = FACT.length-1; i >= 0; i--) { splitMult(xs, ys, as); ys[0] = as[0]; ys[1] = as[1]; if ( (i & 1) != 0) { // skip odd entries |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 33 |
org/hipparchus/util/FastMathLiteralArrays.java | 1502 |
org/hipparchus/util/FastMathLiteralArrays.java | 1549 |
org/hipparchus/util/FastMathLiteralArrays.java | 3008 |
+0.0d, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 43 |
org/hipparchus/util/FastMathLiteralArrays.java | 1492 |
org/hipparchus/util/FastMathLiteralArrays.java | 1539 |
org/hipparchus/util/FastMathLiteralArrays.java | 2998 |
Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/analysis/differentiation/FieldGradient.java | 948 |
org/hipparchus/analysis/differentiation/Gradient.java | 804 |
final FieldGradient<T> result = newInstance(a1.value.linearCombination(a1.value, b1.value, a2.value, b2.value, a3.value, b3.value)); for (int i = 0; i < b1.grad.length; ++i) { a[1] = a1.grad[i]; a[3] = a2.grad[i]; a[5] = a3.grad[i]; b[0] = b1.grad[i]; b[2] = b2.grad[i]; b[4] = b3.grad[i]; result.grad[i] = a1.value.linearCombination(a, b); |
File | Line |
---|---|
org/hipparchus/analysis/differentiation/UnivariateDerivative1.java | 667 |
org/hipparchus/analysis/differentiation/UnivariateDerivative2.java | 761 |
return new UnivariateDerivative1(MathArrays.linearCombination(a1.f0, b1.f0, a2.f0, b2.f0, a3.f0, b3.f0, a4.f0, b4.f0), MathArrays.linearCombination(new double[] { a1.f0, a1.f1, a2.f0, a2.f1, a3.f0, a3.f1, a4.f0, a4.f1 }, new double[] { b1.f1, b1.f0, b2.f1, b2.f0, b3.f1, b3.f0, b4.f1, b4.f0 })); |
File | Line |
---|---|
org/hipparchus/util/FastMathCalc.java | 220 |
org/hipparchus/util/FastMathCalc.java | 264 |
if ( (i & 1) != 0) { // skip odd entries continue; } split(FACT[i], as); splitReciprocal(as, facts); if ( (i & 2) != 0 ) { // alternate terms are negative facts[0] = -facts[0]; facts[1] = -facts[1]; } splitAdd(ys, facts, as); ys[0] = as[0]; ys[1] = as[1]; } if (result != null) { result[0] = ys[0]; result[1] = ys[1]; } return ys[0] + ys[1]; } /** * For x between 0 and pi/4 compute sine using Taylor expansion: * sin(x) = x - x^3/3! + x^5/5! - x^7/7! ... * @param x number from which sine is requested * @param result placeholder where to put the result in extended precision * (may be null) * @return sin(x) */ static double slowSin(final double x, final double result[]) { |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 33 |
org/hipparchus/util/FastMathLiteralArrays.java | 1503 |
org/hipparchus/util/FastMathLiteralArrays.java | 1550 |
org/hipparchus/util/FastMathLiteralArrays.java | 3009 |
+0.0d, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 44 |
org/hipparchus/util/FastMathLiteralArrays.java | 1492 |
org/hipparchus/util/FastMathLiteralArrays.java | 1539 |
org/hipparchus/util/FastMathLiteralArrays.java | 2998 |
Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/analysis/differentiation/FieldGradient.java | 192 |
org/hipparchus/analysis/differentiation/Gradient.java | 163 |
public T getPartialDerivative(final int ... orders) throws MathIllegalArgumentException { // check the number of components if (orders.length != grad.length) { throw new MathIllegalArgumentException(LocalizedCoreFormats.DIMENSIONS_MISMATCH, orders.length, grad.length); } // check that either all derivation orders are set to 0, // or that only one is set to 1 and all other ones are set to 0 int selected = -1; for (int i = 0; i < orders.length; ++i) { if (orders[i] != 0) { if (selected >= 0 || orders[i] != 1) { throw new MathIllegalArgumentException(LocalizedCoreFormats.DERIVATION_ORDER_NOT_ALLOWED, orders[i]); } // found the component set to derivation order 1 selected = i; } } return (selected < 0) ? value : grad[selected]; } /** Get the partial derivative with respect to one parameter. * @param n index of the parameter (counting from 0) * @return partial derivative with respect to the n<sup>th</sup> parameter * @exception MathIllegalArgumentException if n is either negative or larger * or equal to {@link #getFreeParameters()} */ public T getPartialDerivative(final int n) throws MathIllegalArgumentException { |
File | Line |
---|---|
org/hipparchus/util/FastMathCalc.java | 207 |
org/hipparchus/util/FastMathCalc.java | 252 |
org/hipparchus/util/FastMathCalc.java | 296 |
static double slowCos(final double x, final double result[]) { final double xs[] = new double[2]; final double ys[] = new double[2]; final double facts[] = new double[2]; final double as[] = new double[2]; split(x, xs); ys[0] = ys[1] = 0.0; for (int i = FACT.length-1; i >= 0; i--) { splitMult(xs, ys, as); ys[0] = as[0]; ys[1] = as[1]; |
File | Line |
---|---|
org/hipparchus/analysis/differentiation/FieldGradient.java | 979 |
org/hipparchus/analysis/differentiation/FieldGradient.java | 995 |
final T a3, final FieldGradient<T> b3) { final FieldGradient<T> result = newInstance(b1.value.linearCombination(a1, b1.value, a2, b2.value, a3, b3.value)); for (int i = 0; i < b1.grad.length; ++i) { result.grad[i] = b1.value.linearCombination(a1, b1.grad[i], a2, b2.grad[i], a3, b3.grad[i]); } return result; } /** {@inheritDoc} */ @Override public FieldGradient<T> linearCombination(final double a1, final FieldGradient<T> b1, |
File | Line |
---|---|
org/hipparchus/linear/BlockRealMatrix.java | 1677 |
org/hipparchus/linear/BlockRealMatrix.java | 1787 |
public double walkInRowOrder(final RealMatrixChangingVisitor visitor, final int startRow, final int endRow, final int startColumn, final int endColumn) throws MathIllegalArgumentException { MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn); visitor.start(rows, columns, startRow, endRow, startColumn, endColumn); for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) { final int p0 = iBlock * BLOCK_SIZE; final int pStart = FastMath.max(startRow, p0); final int pEnd = FastMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow); for (int p = pStart; p < pEnd; ++p) { |
File | Line |
---|---|
org/hipparchus/linear/BlockRealMatrix.java | 1707 |
org/hipparchus/linear/BlockRealMatrix.java | 1818 |
public double walkInRowOrder(final RealMatrixPreservingVisitor visitor, final int startRow, final int endRow, final int startColumn, final int endColumn) throws MathIllegalArgumentException { MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn); visitor.start(rows, columns, startRow, endRow, startColumn, endColumn); for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) { final int p0 = iBlock * BLOCK_SIZE; final int pStart = FastMath.max(startRow, p0); final int pEnd = FastMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow); for (int p = pStart; p < pEnd; ++p) { |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 54 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 66 |
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 81 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 84 |
{ 0,0,0,0,0,0,0,0,-3,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 1103 |
org/hipparchus/linear/BlockRealMatrix.java | 1131 |
final T[] block = blocks[iBlock * blockColumns + jBlock]; final int available = outBlock.length - outIndex; if (jWidth > available) { System.arraycopy(block, iRow * jWidth, outBlock, outIndex, available); outBlock = out.blocks[++outBlockIndex]; System.arraycopy(block, iRow * jWidth, outBlock, 0, jWidth - available); outIndex = jWidth - available; } else { System.arraycopy(block, iRow * jWidth, outBlock, outIndex, jWidth); outIndex += jWidth; } } return out; } /** {@inheritDoc} */ @Override public void setRowMatrix(final int row, final FieldMatrix<T> matrix) |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 1667 |
org/hipparchus/linear/BlockFieldMatrix.java | 1777 |
public T walkInRowOrder(final FieldMatrixChangingVisitor<T> visitor, final int startRow, final int endRow, final int startColumn, final int endColumn) throws MathIllegalArgumentException { checkSubMatrixIndex(startRow, endRow, startColumn, endColumn); visitor.start(rows, columns, startRow, endRow, startColumn, endColumn); for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) { final int p0 = iBlock * BLOCK_SIZE; final int pStart = FastMath.max(startRow, p0); final int pEnd = FastMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow); for (int p = pStart; p < pEnd; ++p) { |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 1697 |
org/hipparchus/linear/BlockFieldMatrix.java | 1807 |
public T walkInRowOrder(final FieldMatrixPreservingVisitor<T> visitor, final int startRow, final int endRow, final int startColumn, final int endColumn) throws MathIllegalArgumentException { checkSubMatrixIndex(startRow, endRow, startColumn, endColumn); visitor.start(rows, columns, startRow, endRow, startColumn, endColumn); for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) { final int p0 = iBlock * BLOCK_SIZE; final int pStart = FastMath.max(startRow, p0); final int pEnd = FastMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow); for (int p = pStart; p < pEnd; ++p) { |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 52 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 64 |
{ 2,-2,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 64 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 68 |
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 67 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 68 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 1619 |
org/hipparchus/linear/BlockFieldMatrix.java | 1643 |
org/hipparchus/linear/BlockRealMatrix.java | 1629 |
org/hipparchus/linear/BlockRealMatrix.java | 1653 |
public T walkInRowOrder(final FieldMatrixChangingVisitor<T> visitor) { visitor.start(rows, columns, 0, rows - 1, 0, columns - 1); for (int iBlock = 0; iBlock < blockRows; ++iBlock) { final int pStart = iBlock * BLOCK_SIZE; final int pEnd = FastMath.min(pStart + BLOCK_SIZE, rows); for (int p = pStart; p < pEnd; ++p) { for (int jBlock = 0; jBlock < blockColumns; ++jBlock) { final int jWidth = blockWidth(jBlock); final int qStart = jBlock * BLOCK_SIZE; final int qEnd = FastMath.min(qStart + BLOCK_SIZE, columns); final T[] block = blocks[iBlock * blockColumns + jBlock]; |
File | Line |
---|---|
org/hipparchus/util/FastMath.java | 430 |
org/hipparchus/util/FastMath.java | 509 |
exp(x, 0.0, hiPrec); double ya = hiPrec[0] + hiPrec[1]; double yb = -(ya - hiPrec[0] - hiPrec[1]); double temp = ya * HEX_40000000; double yaa = ya + temp - temp; double yab = ya - yaa; // recip = 1/y double recip = 1.0/ya; temp = recip * HEX_40000000; double recipa = recip + temp - temp; double recipb = recip - recipa; // Correct for rounding in division recipb += (1.0 - yaa*recipa - yaa*recipb - yab*recipa - yab*recipb) * recip; // Account for yb recipb += -yb * recip * recip; |
File | Line |
---|---|
org/hipparchus/util/FastMath.java | 2384 |
org/hipparchus/util/FastMath.java | 2524 |
} if (xa != xa || xa == Double.POSITIVE_INFINITY) { return Double.NaN; } /* Perform any argument reduction */ double xb = 0; if (xa > 3294198.0) { // PI * (2**20) // Argument too big for CodyWaite reduction. Must use // PayneHanek. double reduceResults[] = new double[3]; reducePayneHanek(xa, reduceResults); quadrant = ((int) reduceResults[0]) & 3; xa = reduceResults[1]; xb = reduceResults[2]; } else if (xa > 1.5707963267948966) { final CodyWaite cw = new CodyWaite(xa); quadrant = cw.getK() & 3; xa = cw.getRemA(); xb = cw.getRemB(); } |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 33 |
org/hipparchus/util/FastMathLiteralArrays.java | 1504 |
org/hipparchus/util/FastMathLiteralArrays.java | 1551 |
org/hipparchus/util/FastMathLiteralArrays.java | 3010 |
+0.0d, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 45 |
org/hipparchus/util/FastMathLiteralArrays.java | 1492 |
org/hipparchus/util/FastMathLiteralArrays.java | 1539 |
org/hipparchus/util/FastMathLiteralArrays.java | 2998 |
Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
{ -3,3,0,0,0,0,0,0,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 2,-2,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 55 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 67 |
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 97 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 100 |
{ 0,0,0,0,0,0,0,0,2,0,0,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/dfp/DfpField.java | 584 |
org/hipparchus/dfp/DfpMath.java | 48 |
private Dfp[] split(final String a) { Dfp result[] = new Dfp[2]; boolean leading = true; int sp = 0; int sig = 0; StringBuilder builder1 = new StringBuilder(a.length()); for (int i = 0; i < a.length(); i++) { final char c = a.charAt(i); builder1.append(c); if (c >= '1' && c <= '9') { leading = false; } if (c == '.') { sig += (400 - sig) % 4; leading = false; } if (sig == (radixDigits / 2) * 4) { |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 163 |
org/hipparchus/linear/BlockRealMatrix.java | 159 |
} else { // reference existing array blocks = blockData; } int index = 0; for (int iBlock = 0; iBlock < blockRows; ++iBlock) { final int iHeight = blockHeight(iBlock); for (int jBlock = 0; jBlock < blockColumns; ++jBlock, ++index) { if (blockData[index].length != iHeight * blockWidth(jBlock)) { throw new MathIllegalArgumentException(LocalizedCoreFormats.DIMENSIONS_MISMATCH, blockData[index].length, iHeight * blockWidth(jBlock)); } if (copyArray) { blocks[index] = blockData[index].clone(); } } } } /** * Convert a data array from raw layout to blocks layout. * <p> * Raw layout is the straightforward layout where element at row i and * column j is in array element <code>rawData[i][j]</code>. Blocks layout * is the layout used in {@link BlockFieldMatrix} instances, where the matrix * is split in square blocks (except at right and bottom side where blocks may * be rectangular to fit matrix size) and each block is stored in a flattened * one-dimensional array. * </p> * <p> * This method creates an array in blocks layout from an input array in raw layout. * It can be used to provide the array argument of the {@link * #BlockFieldMatrix(int, int, FieldElement[][], boolean)} * constructor. * </p> * @param <T> Type of the field elements. * @param rawData Data array in raw layout. * @return a new data array containing the same entries but in blocks layout * @throws MathIllegalArgumentException if {@code rawData} is not rectangular * (not all rows have the same length). * @see #createBlocksLayout(Field, int, int) * @see #BlockFieldMatrix(int, int, FieldElement[][], boolean) */ public static <T extends FieldElement<T>> T[][] toBlocksLayout(final T[][] rawData) |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 1493 |
org/hipparchus/linear/BlockRealMatrix.java | 1508 |
final int qStart = jBlock * BLOCK_SIZE; final int qEnd = FastMath.min(qStart + BLOCK_SIZE, rows); int k = 0; for (int p = pStart; p < pEnd; ++p) { final int lInc = pEnd - pStart; int l = p - pStart; for (int q = qStart; q < qEnd; ++q) { outBlock[k] = tBlock[l]; ++k; l+= lInc; } } // go to next block ++blockIndex; } } return out; } /** {@inheritDoc} */ @Override public int getRowDimension() { return rows; } /** {@inheritDoc} */ @Override public int getColumnDimension() { return columns; } /** {@inheritDoc} */ @Override public T[] operate(final T[] v) throws MathIllegalArgumentException { |
File | Line |
---|---|
org/hipparchus/linear/BlockRealMatrix.java | 1677 |
org/hipparchus/linear/BlockRealMatrix.java | 1818 |
public double walkInRowOrder(final RealMatrixChangingVisitor visitor, final int startRow, final int endRow, final int startColumn, final int endColumn) throws MathIllegalArgumentException { MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn); visitor.start(rows, columns, startRow, endRow, startColumn, endColumn); for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) { final int p0 = iBlock * BLOCK_SIZE; final int pStart = FastMath.max(startRow, p0); final int pEnd = FastMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow); for (int p = pStart; p < pEnd; ++p) { |
File | Line |
---|---|
org/hipparchus/linear/BlockRealMatrix.java | 1707 |
org/hipparchus/linear/BlockRealMatrix.java | 1787 |
public double walkInRowOrder(final RealMatrixPreservingVisitor visitor, final int startRow, final int endRow, final int startColumn, final int endColumn) throws MathIllegalArgumentException { MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn); visitor.start(rows, columns, startRow, endRow, startColumn, endColumn); for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) { final int p0 = iBlock * BLOCK_SIZE; final int pStart = FastMath.max(startRow, p0); final int pEnd = FastMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow); for (int p = pStart; p < pEnd; ++p) { |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 52 |
{ 0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 52 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 64 |
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 52 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 67 |
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 53 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 65 |
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 53 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 64 |
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 65 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 68 |
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 67 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 68 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 70 |
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 68 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 1667 |
org/hipparchus/linear/BlockFieldMatrix.java | 1807 |
public T walkInRowOrder(final FieldMatrixChangingVisitor<T> visitor, final int startRow, final int endRow, final int startColumn, final int endColumn) throws MathIllegalArgumentException { checkSubMatrixIndex(startRow, endRow, startColumn, endColumn); visitor.start(rows, columns, startRow, endRow, startColumn, endColumn); for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) { final int p0 = iBlock * BLOCK_SIZE; final int pStart = FastMath.max(startRow, p0); final int pEnd = FastMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow); for (int p = pStart; p < pEnd; ++p) { |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 1697 |
org/hipparchus/linear/BlockFieldMatrix.java | 1777 |
public T walkInRowOrder(final FieldMatrixPreservingVisitor<T> visitor, final int startRow, final int endRow, final int startColumn, final int endColumn) throws MathIllegalArgumentException { checkSubMatrixIndex(startRow, endRow, startColumn, endColumn); visitor.start(rows, columns, startRow, endRow, startColumn, endColumn); for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) { final int p0 = iBlock * BLOCK_SIZE; final int pStart = FastMath.max(startRow, p0); final int pEnd = FastMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow); for (int p = pStart; p < pEnd; ++p) { |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
{ 0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 56 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 60 |
{ -3,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,-3,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 72 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 76 |
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-1,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/linear/ArrayFieldVector.java | 1088 |
org/hipparchus/linear/SparseFieldVector.java | 531 |
} /** * Checks that the indices of a subvector are valid. * * @param start the index of the first entry of the subvector * @param end the index of the last entry of the subvector (inclusive) * @throws MathIllegalArgumentException if {@code start} of {@code end} are not valid * @throws MathIllegalArgumentException if {@code end < start} */ private void checkIndices(final int start, final int end) throws MathIllegalArgumentException { final int dim = getDimension(); if ((start < 0) || (start >= dim)) { throw new MathIllegalArgumentException(LocalizedCoreFormats.INDEX, start, 0, dim - 1); } if ((end < 0) || (end >= dim)) { throw new MathIllegalArgumentException(LocalizedCoreFormats.INDEX, end, 0, dim - 1); } if (end < start) { throw new MathIllegalArgumentException(LocalizedCoreFormats.INITIAL_ROW_AFTER_FINAL_ROW, end, start, false); } } |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 920 |
org/hipparchus/linear/BlockRealMatrix.java | 948 |
new BlockFieldMatrix<>(getField(), endRow - startRow + 1, endColumn - startColumn + 1); // compute blocks shifts final int blockStartRow = startRow / BLOCK_SIZE; final int rowsShift = startRow % BLOCK_SIZE; final int blockStartColumn = startColumn / BLOCK_SIZE; final int columnsShift = startColumn % BLOCK_SIZE; // perform extraction block-wise, to ensure good cache behavior int pBlock = blockStartRow; for (int iBlock = 0; iBlock < out.blockRows; ++iBlock) { final int iHeight = out.blockHeight(iBlock); int qBlock = blockStartColumn; for (int jBlock = 0; jBlock < out.blockColumns; ++jBlock) { final int jWidth = out.blockWidth(jBlock); // handle one block of the output matrix final int outIndex = iBlock * out.blockColumns + jBlock; final T[] outBlock = out.blocks[outIndex]; |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 52 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 56 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 60 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 64 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 67 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 68 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 72 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 76 |
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 33 |
org/hipparchus/util/FastMathLiteralArrays.java | 1505 |
org/hipparchus/util/FastMathLiteralArrays.java | 1552 |
org/hipparchus/util/FastMathLiteralArrays.java | 3011 |
+0.0d, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 46 |
org/hipparchus/util/FastMathLiteralArrays.java | 1492 |
org/hipparchus/util/FastMathLiteralArrays.java | 1539 |
org/hipparchus/util/FastMathLiteralArrays.java | 2998 |
Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/linear/ArrayFieldVector.java | 1098 |
org/hipparchus/linear/RealVector.java | 204 |
org/hipparchus/linear/SparseFieldVector.java | 541 |
private void checkIndices(final int start, final int end) throws MathIllegalArgumentException { final int dim = getDimension(); if ((start < 0) || (start >= dim)) { throw new MathIllegalArgumentException(LocalizedCoreFormats.INDEX, start, 0, dim - 1); } if ((end < 0) || (end >= dim)) { throw new MathIllegalArgumentException(LocalizedCoreFormats.INDEX, end, 0, dim - 1); } if (end < start) { throw new MathIllegalArgumentException(LocalizedCoreFormats.INITIAL_ROW_AFTER_FINAL_ROW, end, start, false); } } |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 519 |
org/hipparchus/linear/BlockFieldMatrix.java | 714 |
final int qEnd = FastMath.min(qStart + BLOCK_SIZE, m.getColumnDimension()); // select current block final T[] outBlock = out.blocks[blockIndex]; // perform multiplication on current block for (int kBlock = 0; kBlock < blockColumns; ++kBlock) { final int kWidth = blockWidth(kBlock); final T[] tBlock = blocks[iBlock * blockColumns + kBlock]; final int rStart = kBlock * BLOCK_SIZE; int k = 0; for (int p = pStart; p < pEnd; ++p) { final int lStart = (p - pStart) * kWidth; final int lEnd = lStart + kWidth; for (int q = qStart; q < qEnd; ++q) { T sum = zero; |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 52 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 63 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 64 |
{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 227 |
org/hipparchus/linear/BlockFieldMatrix.java | 276 |
final T[][] blocks = MathArrays.buildArray(field, blockRows * blockColumns, -1); int blockIndex = 0; for (int iBlock = 0; iBlock < blockRows; ++iBlock) { final int pStart = iBlock * BLOCK_SIZE; final int pEnd = FastMath.min(pStart + BLOCK_SIZE, rows); final int iHeight = pEnd - pStart; for (int jBlock = 0; jBlock < blockColumns; ++jBlock) { final int qStart = jBlock * BLOCK_SIZE; final int qEnd = FastMath.min(qStart + BLOCK_SIZE, columns); final int jWidth = qEnd - qStart; |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/util/FastMath.java | 641 |
org/hipparchus/util/FastMath.java | 680 |
temp = da + yb; db += -(temp - da - yb); da = temp; temp = da * HEX_40000000; double daa = da + temp - temp; double dab = da - daa; // ratio = na/da double ratio = na/da; temp = ratio * HEX_40000000; double ratioa = ratio + temp - temp; double ratiob = ratio - ratioa; // Correct for rounding in division ratiob += (na - daa*ratioa - daa*ratiob - dab*ratioa - dab*ratiob) / da; // Account for nb ratiob += nb / da; // Account for db ratiob += -db * na / da / da; result = ratioa + ratiob; } |
File | Line |
---|---|
org/hipparchus/util/FieldTuple.java | 677 |
org/hipparchus/util/FieldTuple.java | 706 |
final FieldTuple<T> a3, final FieldTuple<T> b3) { final FieldTuple<T> result = new FieldTuple<>(field, MathArrays.buildArray(values[0].getField(), values.length)); for (int i = 0; i < values.length; ++i) { result.values[i] = a1.values[0].linearCombination(a1.values[i], b1.values[i], a2.values[i], b2.values[i], a3.values[i], b3.values[i]); |
File | Line |
---|---|
org/hipparchus/analysis/differentiation/FieldDerivativeStructure.java | 1131 |
org/hipparchus/analysis/differentiation/FieldDerivativeStructure.java | 1158 |
final T a4, final FieldDerivativeStructure<T> b4) throws MathIllegalArgumentException { factory.checkCompatibility(b1.factory); factory.checkCompatibility(b2.factory); factory.checkCompatibility(b3.factory); factory.checkCompatibility(b4.factory); final FieldDerivativeStructure<T> ds = factory.build(); factory.getCompiler().linearCombination(a1, b1.data, 0, a2, b2.data, 0, a3, b3.data, 0, a4, b4.data, 0, ds.data, 0); return ds; } |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/linear/Array2DRowFieldMatrix.java | 231 |
org/hipparchus/linear/Array2DRowFieldMatrix.java | 259 |
checkAdditionCompatible(m); final int rowCount = getRowDimension(); final int columnCount = getColumnDimension(); final T[][] outData = MathArrays.buildArray(getField(), rowCount, columnCount); for (int row = 0; row < rowCount; row++) { final T[] dataRow = data[row]; final T[] mRow = m.data[row]; final T[] outDataRow = outData[row]; for (int col = 0; col < columnCount; col++) { outDataRow[col] = dataRow[col].add(mRow[col]); |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 33 |
org/hipparchus/util/FastMathLiteralArrays.java | 1506 |
org/hipparchus/util/FastMathLiteralArrays.java | 1553 |
org/hipparchus/util/FastMathLiteralArrays.java | 3012 |
+0.0d, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 47 |
org/hipparchus/util/FastMathLiteralArrays.java | 1492 |
org/hipparchus/util/FastMathLiteralArrays.java | 1539 |
org/hipparchus/util/FastMathLiteralArrays.java | 2998 |
Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/linear/BlockFieldMatrix.java | 1160 |
org/hipparchus/linear/BlockRealMatrix.java | 1188 |
final T[] block = blocks[iBlock * blockColumns + jBlock]; final int available = mBlock.length - mIndex; if (jWidth > available) { System.arraycopy(mBlock, mIndex, block, iRow * jWidth, available); mBlock = matrix.blocks[++mBlockIndex]; System.arraycopy(mBlock, 0, block, iRow * jWidth, jWidth - available); mIndex = jWidth - available; } else { System.arraycopy(mBlock, mIndex, block, iRow * jWidth, jWidth); mIndex += jWidth; } } } /** {@inheritDoc} */ @Override public FieldMatrix<T> getColumnMatrix(final int column) |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/linear/BlockRealMatrix.java | 218 |
org/hipparchus/linear/BlockRealMatrix.java | 262 |
final double[][] blocks = new double[blockRows * blockColumns][]; int blockIndex = 0; for (int iBlock = 0; iBlock < blockRows; ++iBlock) { final int pStart = iBlock * BLOCK_SIZE; final int pEnd = FastMath.min(pStart + BLOCK_SIZE, rows); final int iHeight = pEnd - pStart; for (int jBlock = 0; jBlock < blockColumns; ++jBlock) { final int qStart = jBlock * BLOCK_SIZE; final int qEnd = FastMath.min(qStart + BLOCK_SIZE, columns); final int jWidth = qEnd - qStart; |
File | Line |
---|---|
org/hipparchus/analysis/differentiation/FieldUnivariateDerivative2.java | 919 |
org/hipparchus/analysis/differentiation/FieldUnivariateDerivative2.java | 935 |
final T a3, final FieldUnivariateDerivative2<T> b3) { return new FieldUnivariateDerivative2<>(b1.f0.linearCombination(a1, b1.f0, a2, b2.f0, a3, b3.f0), b1.f0.linearCombination(a1, b1.f1, a2, b2.f1, a3, b3.f1), b1.f0.linearCombination(a1, b1.f2, a2, b2.f2, a3, b3.f2)); } /** {@inheritDoc} */ @Override public FieldUnivariateDerivative2<T> linearCombination(final double a1, final FieldUnivariateDerivative2<T> b1, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/linear/Array2DRowRealMatrix.java | 169 |
org/hipparchus/linear/Array2DRowRealMatrix.java | 196 |
MatrixUtils.checkAdditionCompatible(this, m); final int rowCount = getRowDimension(); final int columnCount = getColumnDimension(); final double[][] outData = new double[rowCount][columnCount]; for (int row = 0; row < rowCount; row++) { final double[] dataRow = data[row]; final double[] mRow = m.data[row]; final double[] outDataRow = outData[row]; for (int col = 0; col < columnCount; col++) { outDataRow[col] = dataRow[col] + mRow[col]; |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 69 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 33 |
org/hipparchus/util/FastMathLiteralArrays.java | 1507 |
org/hipparchus/util/FastMathLiteralArrays.java | 1554 |
org/hipparchus/util/FastMathLiteralArrays.java | 3013 |
+0.0d, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/util/FastMathLiteralArrays.java | 48 |
org/hipparchus/util/FastMathLiteralArrays.java | 1492 |
org/hipparchus/util/FastMathLiteralArrays.java | 1539 |
org/hipparchus/util/FastMathLiteralArrays.java | 2998 |
Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |
File | Line |
---|---|
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 48 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 49 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 50 |
org/hipparchus/analysis/interpolation/TricubicInterpolatingFunction.java | 51 |
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, |