Java FastMath.min方法代码示例

import org.apache.commons.math.util.FastMath; //导入方法依赖的package包/类
/** {@inheritDoc} */
@Override
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) {
                    block[k] = visitor.visit(p, q, block[k]);
                    ++k;
                }
            }
            ++blockIndex;
        }
    }
    return visitor.end();
}
 

import org.apache.commons.math.util.FastMath; //导入方法依赖的package包/类
/** {@inheritDoc} */
public RealMatrix getR() {

    if (cachedR == null) {

        // R is supposed to be m x n
        final int n = qrt.length;
        final int m = qrt[0].length;
        cachedR = MatrixUtils.createRealMatrix(m, n);

        // copy the diagonal from rDiag and the upper triangle of qr
        for (int row = FastMath.min(m, n) - 1; row >= 0; row--) {
            cachedR.setEntry(row, row, rDiag[row]);
            for (int col = row + 1; col < n; col++) {
                cachedR.setEntry(row, col, qrt[col][row]);
            }
        }
    }

    // return the cached matrix
    return cachedR;
}
 

import org.apache.commons.math.util.FastMath; //导入方法依赖的package包/类
/** {@inheritDoc} */
@Override
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) {
                    block[k] = visitor.visit(p, q, block[k]);
                    ++k;
                }
            }
            ++blockIndex;
        }
    }
    return visitor.end();
}
 

import org.apache.commons.math.util.FastMath; //导入方法依赖的package包/类
/**
 * Verifies that probability computations are consistent
 */
public void testConsistency() throws Exception {
    for (int i=1; i < cumulativeTestPoints.length; i++) {

        // check that cdf(x, x) = 0
        TestUtils.assertEquals(0d,
           distribution.cumulativeProbability
             (cumulativeTestPoints[i], cumulativeTestPoints[i]), tolerance);

        // check that P(a < X < b) = P(X < b) - P(X < a)
        double upper = FastMath.max(cumulativeTestPoints[i], cumulativeTestPoints[i -1]);
        double lower = FastMath.min(cumulativeTestPoints[i], cumulativeTestPoints[i -1]);
        double diff = distribution.cumulativeProbability(upper) -
            distribution.cumulativeProbability(lower);
        double direct = distribution.cumulativeProbability(lower, upper);
        TestUtils.assertEquals("Inconsistent cumulative probabilities for ("
                + lower + "," + upper + ")", diff, direct, tolerance);
    }
}
 

import org.apache.commons.math.util.FastMath; //导入方法依赖的package包/类
/**
 * Calculate how much energy will grow when a user is hurt.
 * 
 * @param beingAttackedUser
 * @param hurt
 * @return
 */
public static int calculateEnergy(Battle battle, BattleUser attackUser, 
		BattleUser beingAttackedUser, int hurt) {
	
	int blood = beingAttackedUser.getUser().getBlood();
	double ratio = hurt * 1.0 / blood;
	int totalEnergy = GameDataManager.getInstance().getGameDataAsInt(GameDataKey.USER_DEFAULT_ENERGY, 100);
	int finalEnergy = finalEnergy = FastMath.min((int)(ratio * totalEnergy), totalEnergy);

	return finalEnergy;
}
 

import org.apache.commons.math.util.FastMath; //导入方法依赖的package包/类
/**
 * Multiply the instance by a polynomial.
 *
 * @param p Polynomial to multiply by.
 * @return a new polynomial.
 */
public PolynomialFunction multiply(final PolynomialFunction p) {
    double[] newCoefficients = new double[coefficients.length + p.coefficients.length - 1];

    for (int i = 0; i < newCoefficients.length; ++i) {
        newCoefficients[i] = 0.0;
        for (int j = FastMath.max(0, i + 1 - p.coefficients.length);
             j < FastMath.min(coefficients.length, i + 1);
             ++j) {
            newCoefficients[i] += coefficients[j] * p.coefficients[i-j];
        }
    }

    return new PolynomialFunction(newCoefficients);
}
 

import org.apache.commons.math.util.FastMath; //导入方法依赖的package包/类
/** {@inheritDoc} */
@Override
public double[] operate(final double[] v) {
    if (v.length != columns) {
        throw new DimensionMismatchException(v.length, columns);
    }
    final double[] out = new double[rows];

    // perform multiplication block-wise, to ensure good cache behavior
    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 double[] block  = blocks[iBlock * blockColumns + jBlock];
            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) {
                double sum = 0;
                int q = qStart;
                while (q < qEnd - 3) {
                    sum += block[k]     * v[q]     +
                           block[k + 1] * v[q + 1] +
                           block[k + 2] * v[q + 2] +
                           block[k + 3] * v[q + 3];
                    k += 4;
                    q += 4;
                }
                while (q < qEnd) {
                    sum += block[k++] * v[q++];
                }
                out[p] += sum;
            }
        }
    }

    return out;
}
 

import org.apache.commons.math.util.FastMath; //导入方法依赖的package包/类
/** {@inheritDoc} */
@Override
public T[][] getData() {

    final T[][] data = buildArray(getField(), getRowDimension(), getColumnDimension());
    final int lastColumns = columns - (blockColumns - 1) * BLOCK_SIZE;

    for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
        final int pStart = iBlock * BLOCK_SIZE;
        final int pEnd   = FastMath.min(pStart + BLOCK_SIZE, rows);
        int regularPos   = 0;
        int lastPos      = 0;
        for (int p = pStart; p < pEnd; ++p) {
            final T[] dataP = data[p];
            int blockIndex = iBlock * blockColumns;
            int dataPos    = 0;
            for (int jBlock = 0; jBlock < blockColumns - 1; ++jBlock) {
                System.arraycopy(blocks[blockIndex++], regularPos, dataP, dataPos, BLOCK_SIZE);
                dataPos += BLOCK_SIZE;
            }
            System.arraycopy(blocks[blockIndex], lastPos, dataP, dataPos, lastColumns);
            regularPos += BLOCK_SIZE;
            lastPos    += lastColumns;
        }
    }

    return data;
}
 

import org.apache.commons.math.util.FastMath; //导入方法依赖的package包/类
/** {@inheritDoc} */
@Override
public BlockRealMatrix add(final RealMatrix m) {
    try {
        return add((BlockRealMatrix) m);
    } catch (ClassCastException cce) {
        // safety check
        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) {
            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 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] + m.getEntry(p, q);
                        ++k;
                    }
                }
                // go to next block
                ++blockIndex;
            }
        }

        return out;
    }
}
 

import org.apache.commons.math.util.FastMath; //导入方法依赖的package包/类
/** {@inheritDoc} */
@Override
public BlockRealMatrix transpose() {
    final int nRows = getRowDimension();
    final int nCols = getColumnDimension();
    final BlockRealMatrix out = new BlockRealMatrix(nCols, nRows);

    // perform transpose block-wise, to ensure good cache behavior
    int blockIndex = 0;
    for (int iBlock = 0; iBlock < blockColumns; ++iBlock) {
        for (int jBlock = 0; jBlock < blockRows; ++jBlock) {
            // transpose current block
            final double[] outBlock = out.blocks[blockIndex];
            final double[] tBlock = blocks[jBlock * blockColumns + iBlock];
            final int pStart = iBlock * BLOCK_SIZE;
            final int pEnd = FastMath.min(pStart + BLOCK_SIZE, columns);
            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;
}
 

import org.apache.commons.math.util.FastMath; //导入方法依赖的package包/类
public static RealMatrix createDiagonalMatrix(final double[] diagonal,
                                              final int rows, final int columns) {
    final double[][] dData = new double[rows][columns];
    for (int i = 0; i < FastMath.min(rows, columns); ++i) {
        dData[i][i] = diagonal[i];
    }
    return MatrixUtils.createRealMatrix(dData);
}
 

import org.apache.commons.math.util.FastMath; //导入方法依赖的package包/类
/** {@inheritDoc} */
@Override
public double[][] getData() {
    final double[][] data = new double[getRowDimension()][getColumnDimension()];
    final int lastColumns = columns - (blockColumns - 1) * BLOCK_SIZE;

    for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
        final int pStart = iBlock * BLOCK_SIZE;
        final int pEnd = FastMath.min(pStart + BLOCK_SIZE, rows);
        int regularPos = 0;
        int lastPos = 0;
        for (int p = pStart; p < pEnd; ++p) {
            final double[] dataP = data[p];
            int blockIndex = iBlock * blockColumns;
            int dataPos = 0;
            for (int jBlock = 0; jBlock < blockColumns - 1; ++jBlock) {
                System.arraycopy(blocks[blockIndex++], regularPos, dataP, dataPos, BLOCK_SIZE);
                dataPos += BLOCK_SIZE;
            }
            System.arraycopy(blocks[blockIndex], lastPos, dataP, dataPos, lastColumns);
            regularPos += BLOCK_SIZE;
            lastPos    += lastColumns;
        }
    }

    return data;
}
 

import org.apache.commons.math.util.FastMath; //导入方法依赖的package包/类
/** {@inheritDoc} */
public double[] solve(double[] b) {
    final int n = qrt.length;
    final int m = qrt[0].length;
    if (b.length != m) {
        throw new DimensionMismatchException(b.length, m);
    }
    if (!isNonSingular()) {
        throw new SingularMatrixException();
    }

    final double[] x = new double[n];
    final double[] y = b.clone();

    // apply Householder transforms to solve Q.y = b
    for (int minor = 0; minor < FastMath.min(m, n); minor++) {

        final double[] qrtMinor = qrt[minor];
        double dotProduct = 0;
        for (int row = minor; row < m; row++) {
            dotProduct += y[row] * qrtMinor[row];
        }
        dotProduct /= rDiag[minor] * qrtMinor[minor];

        for (int row = minor; row < m; row++) {
            y[row] += dotProduct * qrtMinor[row];
        }
    }

    // solve triangular system R.x = y
    for (int row = rDiag.length - 1; row >= 0; --row) {
        y[row] /= rDiag[row];
        final double yRow   = y[row];
        final double[] qrtRow = qrt[row];
        x[row] = yRow;
        for (int i = 0; i < row; i++) {
            y[i] -= yRow * qrtRow[i];
        }
    }

    return x;
}
 

import org.apache.commons.math.util.FastMath; //导入方法依赖的package包/类
/**
 * Returns the result of postmultiplying this by {@code m}.
 *
 * @param m Matrix to postmultiply by.
 * @return {@code this} * m.
 * @throws MatrixDimensionMismatchException if the matrices are not
 * compatible.
 */
public BlockRealMatrix multiply(BlockRealMatrix m) {
    // safety check
    MatrixUtils.checkMultiplicationCompatible(this, m);

    final BlockRealMatrix out = new BlockRealMatrix(rows, m.columns);

    // perform multiplication 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) {
            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 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 double[] mBlock = m.blocks[kBlock * m.blockColumns + jBlock];
                int k = 0;
                for (int p = pStart; p < pEnd; ++p) {
                    final int lStart = (p - pStart) * kWidth;
                    final int lEnd = lStart + kWidth;
                    for (int nStart = 0; nStart < jWidth; ++nStart) {
                        double sum = 0;
                        int l = lStart;
                        int n = nStart;
                        while (l < lEnd - 3) {
                            sum += tBlock[l] * mBlock[n] +
                                   tBlock[l + 1] * mBlock[n + jWidth] +
                                   tBlock[l + 2] * mBlock[n + jWidth2] +
                                   tBlock[l + 3] * mBlock[n + jWidth3];
                            l += 4;
                            n += jWidth4;
                        }
                        while (l < lEnd) {
                            sum += tBlock[l++] * mBlock[n];
                            n += jWidth;
                        }
                        outBlock[k] += sum;
                        ++k;
                    }
                }
            }
            // go to next block
            ++blockIndex;
        }
    }

    return out;
}
 

import org.apache.commons.math.util.FastMath; //导入方法依赖的package包/类
/**
 * Returns the result of postmultiplying this by m.
 *
 * @param m    matrix to postmultiply by
 * @return     this * m
 * @throws     IllegalArgumentException
 *             if columnDimension(this) != rowDimension(m)
 */
public BlockFieldMatrix<T> multiply(BlockFieldMatrix<T> m) {

    // safety check
    checkMultiplicationCompatible(m);

    final BlockFieldMatrix<T> out = new BlockFieldMatrix<T>(getField(), rows, m.columns);
    final T zero = getField().getZero();

    // perform multiplication 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) {
            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];

            // 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 T[] mBlock = m.blocks[kBlock * m.blockColumns + jBlock];
                int k = 0;
                for (int p = pStart; p < pEnd; ++p) {
                    final int lStart = (p - pStart) * kWidth;
                    final int lEnd   = lStart + kWidth;
                    for (int nStart = 0; nStart < jWidth; ++nStart) {
                        T sum = zero;
                        int l = lStart;
                        int n = nStart;
                        while (l < lEnd - 3) {
                            sum = sum.
                                  add(tBlock[l].multiply(mBlock[n])).
                                  add(tBlock[l + 1].multiply(mBlock[n + jWidth])).
                                  add(tBlock[l + 2].multiply(mBlock[n + jWidth2])).
                                  add(tBlock[l + 3].multiply(mBlock[n + jWidth3]));
                            l += 4;
                            n += jWidth4;
                        }
                        while (l < lEnd) {
                            sum = sum.add(tBlock[l++].multiply(mBlock[n]));
                            n += jWidth;
                        }
                        outBlock[k] = outBlock[k].add(sum);
                        ++k;
                    }
                }
            }

            // go to next block
            ++blockIndex;
        }
    }

    return out;
}