Hipparchus::CoreCPD 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 },
|
|