Examples of multiply()

• JSci.maths.Complex.multiply()
• ariba.util.core.ArithmeticOperations.multiply()
• calculator.CalculatorService.multiply()
• calculator.dosgi.CalculatorService.multiply()
• cc.redberry.core.number.Complex.multiply()
• cc.redberry.core.number.ComplexElement.multiply()
• cc.redberry.core.tensor.TensorNumber.multiply()
  Multiplies this number on specified number. @param t specified number to multiply this
• cc.redberry.core.transformations.factor.jasfactor.edu.jas.arith.BigInteger.multiply()
  BigInteger multiply. @param S BigInteger. @return this*S.
• codechicken.lib.render.uv.UV.multiply()
• codechicken.lib.vec.Vector3.multiply()
• cofh.repack.codechicken.lib.render.uv.UV.multiply()
• cofh.repack.codechicken.lib.vec.Vector3.multiply()
• com.ardor3d.math.Transform.multiply()
  Calculates the product of this transform with the given "transformBy" transform (P = this * T) and stores this in store. @param transformBy @param store the transform to store the result in for return. If null, a new transform object is created and returned. It is NOT safe for store to be the same object as transformBy or "this". @return the product @throws NullPointerException if transformBy is null.
• com.ardor3d.math.Vector3.multiply()
  Multiplies the values of this vector by the given scalar value and returns the result in store. @param scalar @param store the vector to store the result in for return. If null, a new vector object is created and returned. @return a new vector (this.x * scalar, this.y * scalar, this.z * scalar)
• com.ardor3d.math.type.ReadOnlyTransform.multiply()
• com.emitrom.lienzo.client.core.types.Transform.multiply()
  Same as {@link #concatenate(Transform)} @param transform @return this Transform
• com.forgeessentials.util.vector.Vector2.multiply()
• com.ibm.icu.math.BigDecimal.multiply()
  Returns a plain BigDecimal whose value is this*rhs, using fixed point arithmetic.

  The same as {@link #add(BigDecimal,MathContext)}, where the BigDecimal is rhs, and the context is new MathContext(0, MathContext.PLAIN).

  The length of the decimal part (the scale) of the result will be the sum of the scales of the operands, if they were formatted without exponential notation. @param rhs The BigDecimal for the right hand side ofthe multiplication. @return A BigDecimal whose value isthis*rhs, using fixed point arithmetic. @stable ICU 2.0

• com.ngt.jopenmetaverse.shared.types.Vector3.multiply()
• com.opengamma.analytics.math.function.DoubleFunction1D.multiply()
  For a DoubleFunction1D $g(x)$, multiplying by a function $f(x)$ returns the function $h(x) = f(x) g(x)$. @param f The function to multiply by, not null @return A function $h(x) = f(x) g(x)$
• com.opengamma.analytics.math.matrix.ColtMatrixAlgebra.multiply()
  {@inheritDoc}The following combinations of input matrices m1 and m2 are allowed:

  • m1 = 2-D matrix, m2 = 2-D matrix, returns $\mathbf{C} = \mathbf{AB}$
  • m1 = 2-D matrix, m2 = 1-D matrix, returns $\mathbf{C} = \mathbf{A}b$
• com.opengamma.analytics.math.matrix.CommonsMatrixAlgebra.multiply()
  {@inheritDoc}The following combinations of input matrices m1 and m2 are allowed:

  • m1 = 2-D matrix, m2 = 2-D matrix, returns $\mathbf{C} = \mathbf{AB}$
  • m1 = 2-D matrix, m2 = 1-D matrix, returns $\mathbf{C} = \mathbf{A}b$
• com.opengamma.analytics.math.matrix.MatrixAlgebra.multiply()
  Multiplies two matrices. @param m1 The first matrix, not null. @param m2 The second matrix, not null. @return The product of the two matrices.
• com.opengamma.analytics.math.matrix.OGMatrixAlgebra.multiply()
  {@inheritDoc}The following combinations of input matrices m1 and m2 are allowed:

  • m1 = 2-D matrix, m2 = 2-D matrix, returns $\mathbf{C} = \mathbf{AB}$
  • m1 = 2-D matrix, m2 = 1-D matrix, returns $\mathbf{C} = \mathbf{A}b$
  • m1 = 1-D matrix, m2 = 2-D matrix, returns $\mathbf{C} = a^T\mathbf{B}$
• com.opengamma.timeseries.date.localdate.LocalDateDoubleTimeSeries.multiply()
• com.sk89q.craftbook.util.Vector.multiply()
  Multiplies two points. @param other @return New point
• com.sk89q.worldedit.Vector.multiply()
  Multiply this vector by another vector on each component. @param other the other vector @return a new vector
• com.sk89q.worldedit.Vector2D.multiply()
  Multiply this vector by another vector on each component. @param other the other vector @return a new vector
• com.thecrouchmode.vector.Matrix4f.multiply()
• com.thecrouchmode.vector.Quaternion.multiply()
• com.vividsolutions.jts.math.Vector2D.multiply()
  Multiplies the vector by a scalar value. @param d the value to multiply by @return a new vector with the value v * d
• com.zaranux.client.crypto.util.BigInteger.multiply()
• de.abg.jreichert.junit4runner.Multiplier.multiply()
• de.jungblut.math.DoubleMatrix.multiply()
• de.jungblut.math.DoubleVector.multiply()
• de.tuhrig.thofu.types.LObject.multiply()
  Basic arithmetic operation. A subtype can override this method if suitable. If not, the standard implementation will throw a LException. @param object to operate @return result depending on the subtype implementation
• engine.geometry.Vector.multiply()
• fj.data.Natural.multiply()
  Multiply a natural number by another. @param n A natural number to multiply by this one. @return The product of the two numbers.
• java.math.BigDecimal.multiply()
  Returns a {@code BigDecimal} whose value is (this ×multiplicand), and whose scale is {@code (this.scale() +multiplicand.scale())}. @param multiplicand value to be multiplied by this {@code BigDecimal}. @return {@code this * multiplicand}
• java.math.BigInteger.multiply()
  Returns a BigInteger whose value is {@code (this * val)}. @param val value to be multiplied by this BigInteger. @return {@code this * val}
• javax.xml.datatype.Duration.multiply()

  Computes a new duration whose value is factor times longer than the value of this duration.

  This method is provided for the convenience. It is functionally equivalent to the following code:

   multiply(new BigDecimal(String.valueOf(factor))) 

  @param factor Factor times longer of new Duration to create. @return New Duration that is factortimes longer than this Duration. @see #multiply(BigDecimal)
• jinngine.math.Matrix3.multiply()
  Multiply this matrix by a scalar, return the resulting matrix @param s @return
• jinngine.math.Matrix4.multiply()
• jinngine.math.Vector3.multiply()
  Multiply this vector by a provided scalar creating a resultant vector which is returned. this vector is not modified. @param s multiplication coeficient @return resultant vector
• jmathexpr.arithmetic.ANumber.multiply()
• jmathexpr.arithmetic.natural.NaturalNumber.multiply()
• jscicalc.expression.Product.multiply()
  Multiply a Complex by this. @param z The complex to multiply by @return The product
• kodkod.ast.IntExpression.multiply()
  Returns an IntExpression that represents the product of this and the given int node. The effect of this method is the same as calling this.compose(MULTIPLY, intExpr). @return this.compose(MULTIPLY, intExpr)
• kodkod.engine.bool.Int.multiply()
  Returns an Int that represents the product between this and the given Int. @requires this.factory = other.factory @return an Int that represents the product between this and the given Int @throws UnsupportedOperationException - this.encoding does not support multiplication
• lipstone.joshua.parser.types.BigDec.multiply()
  Multiplies two BigDec objects. Equivalent to this * number. @param number the BigDec to multiply by @return this * number @throws UndefinedResultException
• mikera.arrayz.INDArray.multiply()
  Multiplies all elements by the equivalent elements in a second array, i.e. performs elementwise multiplication. If matrix-style multiplication is required, use innerProduct instead.
• mikera.matrixx.AMatrix.multiply()
• mikera.matrixx.Matrix.multiply()
• mikera.vectorz.AVector.multiply()
  Multiplies the vector by a constant factor @param factor Factor by which to multiply each component of the vector
• net.rim.device.api.math.Matrix4f.multiply()
• org.apache.camel.example.server.Multiplier.multiply()
  Multiplies the given number by a pre-defined constant. @param originalNumber The number to be multiplied @return The result of the multiplication
• org.apache.commons.math.fraction.BigFraction.multiply()

  Multiplies the value of this fraction by the passed BigInteger, returning the result in reduced form.

  @param bg the {@code BigInteger} to multiply by. @return a {@code BigFraction} instance with the resulting values. @throws NullPointerException if {@code bg} is {@code null}.
• org.apache.commons.math.linear.RealMatrix.multiply()
  Returns the result of postmultiplying this by m. @param m matrix to postmultiply by @return this * m @throws IllegalArgumentException if columnDimension(this) != rowDimension(m)
• org.apache.commons.math.linear.RealMatrixImpl.multiply()
  {@inheritDoc}
• org.apache.commons.math3.analysis.differentiation.DerivativeStructure.multiply()
  {@inheritDoc}
• org.apache.commons.math3.analysis.polynomials.PolynomialFunction.multiply()
  Multiply the instance by a polynomial. @param p Polynomial to multiply by. @return a new polynomial.
• org.apache.commons.math3.complex.Complex.multiply()
  Returns a {@code Complex} whose value is {@code this * factor}. Implements preliminary checks for {@code NaN} and infinity followed bythe definitional formula:

    (a + bi)(c + di) = (ac - bd) + (ad + bc)i  

  Returns {@link #NaN} if either {@code this} or {@code factor} has one ormore {@code NaN} parts.
  Returns {@link #INF} if neither {@code this} nor {@code factor} has oneor more {@code NaN} parts and if either {@code this} or {@code factor}has one or more infinite parts (same result is returned regardless of the sign of the components).
  Returns finite values in components of the result per the definitional formula in all remaining cases. @param factor value to be multiplied by this {@code Complex}. @return {@code this * factor}. @throws NullArgumentException if {@code factor} is {@code null}.
• org.apache.commons.math3.dfp.Dfp.multiply()
  Multiply this by x. @param x multiplicand @return product of this and x
• org.apache.commons.math3.fraction.BigFraction.multiply()

  Multiplies the value of this fraction by the passed BigInteger, returning the result in reduced form.

  @param bg the {@code BigInteger} to multiply by. @return a {@code BigFraction} instance with the resulting values. @throws NullArgumentException if {@code bg} is {@code null}.
• org.apache.commons.math3.linear.Array2DRowRealMatrix.multiply()
  Postmultiplying this matrix by {@code m}. @param m Matrix to postmultiply by. @return {@code this} * m. @throws DimensionMismatchException if the number of columns of thismatrix is not equal to the number of rows of {@code m}.
• org.apache.commons.math3.linear.RealMatrix.multiply()
  Returns the result of postmultiplying this by m. @param m matrix to postmultiply by @return this * m @throws IllegalArgumentException if columnDimension(this) != rowDimension(m)
• org.apache.examples.Calculator.multiply()
• org.apache.fop.area.CTM.multiply()
  Multiply new passed CTM with this one and generate a new result CTM. @param premult The CTM to multiply with this one. The new one will bethe first multiplicand. @return CTM The result of multiplying premult * this.
• org.apache.geronimo.calculator.Calculator.multiply()
  @param arg1 @param arg0 @return returns int
• org.apache.hama.commons.math.DoubleMatrix.multiply()
  Multiplies this matrix (each element) with the given scalar and returns a new matrix.
• org.apache.myfaces.tobago.layout.Measure.multiply()
• org.apache.pdfbox.util.Matrix.multiply()
  This will take the current matrix and multipy it with a matrix that is passed in. @param b The matrix to multiply by. @return The result of the two multiplied matrices.
• org.apache.sis.internal.util.DoubleDouble.multiply()
  Multiplies this {@code DoubleDouble} by an other double-double value.This is a convenience method for: {@preformat javamultiply(other.value, other.error);} @param other The other value to multiply by this value.
• org.apfloat.Apcomplex.multiply()
• org.bouncycastle.math.ec.ECFieldElement.multiply()
• org.bouncycastle.pqc.math.linearalgebra.GF2Vector.multiply()
  Multiply this vector with a permutation. @param p the permutation @return this*p = p*this
• org.broadleafcommerce.common.money.Money.multiply()
• org.bukkit.util.Vector.multiply()
  Multiplies the vector by another. @param vec The other vector @return the same vector
• org.cmj.flowy.simulation.math.Vector2.multiply()
  Multiply this vector by a scalar. @param scale The scalar to multiply by.
• org.earth3d.jearth.math.Point3D.multiply()
• org.eclipse.swt.graphics.Transform.multiply()
  Modifies the receiver such that the matrix it represents becomes the the result of multiplying the matrix it previously represented by the argument. @param matrix the matrix to multiply the receiver by @exception SWTException

  • ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed

  @exception IllegalArgumentException

  • ERROR_NULL_ARGUMENT - if the parameter is null
  • ERROR_INVALID_ARGUMENT - if the parameter has been disposed
• org.fenixedu.academic.util.Money.multiply()
• org.geotools.math.Complex.multiply()
  Multiplies a complex number by a scalar. This method computes the following:

   this = c * s 

• org.geotools.referencing.operation.matrix.XMatrix.multiply()
  Sets the value of this matrix to the result of multiplying itself with the specified matrix. In other words, performs {@code this} = {@code this} × {@code matrix}. In the context of coordinate transformations, this is equivalent to {@linkplain java.awt.geom.AffineTransform#concatenate AffineTransform.concatenate}: first transforms by the supplied transform and then transform the result by the original transform. @param matrix The matrix to multiply to this matrix.
• org.gephi.layout.plugin.force.ForceVector.multiply()
• org.grouplens.lenskit.vectors.MutableSparseVector.multiply()
  Multiply the vector by a scalar. This multiples every element in the vector by {@var s}. @param s The scalar to rescale the vector by.
• org.h2.value.ValueTime.multiply()
• org.hsqldb.types.Type.multiply()
• org.jamesii.core.math.complex.Complex.multiply()
  Multiplies this number by a real number. @param d The real number to multiply with. @return The product of this number and d.
• org.jamesii.core.math.complex.ComplexArray1D.multiply()
  Multiplies two numbers from the array, writing the result back in another position. @param result The index to write the result to. @param op1 The index of the first factor. @param op2 The index of the second factor.
• org.jboss.ejb3.test.common.proxy.Multipliable.multiply()
  Returns the product of the specified arguments
• org.jemmy.Vector.multiply()
  @param multiplier @return self
• org.joda.time.LocalDate.multiply()
• org.olat.ims.qti.container.Variable.multiply()
• org.opengis.filter.FilterFactory.multiply()
  Computes the numeric product of their first and second operand.
• org.pdfbox.util.Matrix.multiply()
  This will take the current matrix and multipy it with a matrix that is passed in. @param b The matrix to multiply by. @return The result of the two multiplied matrices.
• org.spongycastle.math.ec.ECPoint.multiply()
• ptolemy.data.ComplexToken.multiply()
• ptolemy.data.ScalarToken.multiply()
  Return a new token whose value is the value of this token multiplied by the value of the argument token. Type conversion also occurs here, so that the operation is performed at the least type necessary to ensure precision. The returned type is the same as the type chosen for the operation, which is the higher of the type of this token and the argument type. Subclasses should implement the protected _multiply() method to perform the correct type-specific operation. @param rightArgument The token to multiply this token by. @return A new token containing the result. @exception IllegalActionException If the argument token andthis token are of incomparable types, or the operation does not make sense for the given types.
• ptolemy.data.Token.multiply()
  Return a new token whose value is the value of this token multiplied by the value of the argument token. @param rightArgument The token to multiply this token by. @return A new token containing the result.If either this token or the argument token is a nil token, then {@link #NIL} is returned. @exception IllegalActionException If the argument token andthis token are of incomparable types, or the operation does not make sense for the given types.
• ptolemy.math.Fraction.multiply()
  Multiply this fraction by the given fraction. @return The answer as another fraction in lowest terms.
• sk.fiit.jim.math.Vector3D.multiply()
• thaumcraft.codechicken.lib.vec.Vector3.multiply()
• vazkii.botania.common.core.helper.Vector3.multiply()

Examples of org.apache.myfaces.tobago.layout.Measure.multiply()

Examples of org.apache.pdfbox.util.Matrix.multiply()

Examples of org.apache.sis.internal.util.DoubleDouble.multiply()

Examples of org.apfloat.Apcomplex.multiply()

Examples of org.bouncycastle.math.ec.ECFieldElement.multiply()

Examples of org.bouncycastle.pqc.math.linearalgebra.GF2Vector.multiply()

Examples of org.broadleafcommerce.common.money.Money.multiply()

Examples of org.bukkit.util.Vector.multiply()

Examples of org.cmj.flowy.simulation.math.Vector2.multiply()

Examples of org.earth3d.jearth.math.Point3D.multiply()