List of plus() Examples

Examples of plus()

Jama.Matrix.plus()
C = A + B @param B another matrix @return A + B
ai.domain.interval.IntervalExpressionSemantics.plus()
aspect.util.Vector3.plus()
Find the sum of this Vector3 and another Vector3. @param v the other Vector3 @return the sum of the two vectors
ca.eandb.jmist.framework.color.Color.plus()
Adds this color to another.
ca.eandb.jmist.math.Point3.plus()
Returns this point translated according to the specified vector. @param v The vector to translate this point by. @return The value of this point translated by v.
ca.eandb.jmist.math.Vector3.plus()
Computes the sum of two vectors. @param v The vector to add to this vector. @return The sum of this vector and v.
colonies.src.Point.plus()
com.avaje.ebeaninternal.server.lib.sql.PooledConnectionStatistics.LoadValues.plus()
com.cedarsoft.business.Money.plus()
Adds the given amount @param money the amount that is added @return the sum
com.cedarsoft.business.MutableMoney.plus()
com.google.opengse.parser.Chset.plus()
com.mockturtlesolutions.snifflib.datatypes.DblMatrix.plus()
com.olabini.jescov.CoverageData.plus()
com.opengamma.analytics.financial.forex.method.MultipleCurrencyInterestRateCurveSensitivity.plus()
Create a new multiple currency sensitivity by adding the sensitivity associated to a given currency. If the currency is not yet present in the existing sensitivity a new map is created with the extra entry. If the currency is already present, the associated sensitivities are added (in the sense of {@link InterestRateCurveSensitivity}) and a new map is created with all the other existing entries and the entry with the currency and the sum sensitivity. @param ccy The currency. Not null. @param sensitivity The sensitivity associated to the currency. Not null. @return The new multiple currency sensitivity.
com.opengamma.analytics.financial.interestrate.InterestRateCurveSensitivity.plus()
Create a copy of the sensitivity and add a given sensitivity to it. @param other The sensitivity to add. @return The total sensitivity.
com.opengamma.analytics.financial.interestrate.PresentValueSABRSensitivityDataBundle.plus()
Return the sum of to sensitivities in a new one. The original sensitivities are unchanged. @param other The other SABR sensitivity. @return The sum sensitivity.
com.opengamma.analytics.financial.provider.sensitivity.inflation.InflationSensitivity.plus()
Create a copy of the sensitivity and add a given sensitivity to it. @param other The sensitivity to add. @return The total sensitivity.
com.opengamma.analytics.financial.provider.sensitivity.inflation.MultipleCurrencyInflationSensitivity.plus()
Create a new multiple currency sensitivity by adding the sensitivity associated to a given currency. If the currency is not yet present in the existing sensitivity a new map is created with the extra entry. If the currency is already present, the associated sensitivities are added (in the sense of {@link InterestRateCurveSensitivity}) and a new map is created with all the other existing entries and the entry with the currency and the sum sensitivity. @param ccy The currency. Not null. @param sensitivity The sensitivity associated to the currency. Not null. @return The new multiple currency sensitivity.
com.opengamma.analytics.financial.provider.sensitivity.multicurve.MulticurveSensitivity.plus()
Create a copy of the sensitivity and add a given sensitivity to it. @param other The sensitivity to add. @return The total sensitivity.
com.opengamma.analytics.financial.provider.sensitivity.multicurve.MultipleCurrencyMulticurveSensitivity.plus()
Create a new multiple currency sensitivity by adding the sensitivity associated to a given currency. If the currency is not yet present in the existing sensitivity a new map is created with the extra entry. If the currency is already present, the associated sensitivities are added (in the sense of {@link InterestRateCurveSensitivity}) and a new map is created with all the other existing entries and the entry with the currency and the sum sensitivity. @param ccy The currency. Not null. @param sensitivity The sensitivity associated to the currency. Not null. @return The new multiple currency sensitivity.
com.opengamma.analytics.financial.provider.sensitivity.multicurve.MultipleCurrencyParameterSensitivity.plus()
Create a copy of the sensitivity and add a given named sensitivity to it. If the name / currency pair is in the map, the two sensitivity matrices are added. Otherwise, a new entry is put into the map @param nameCcy The name and the currency, not null @param sensitivity The sensitivity to add, not null @return The total sensitivity.
com.opengamma.analytics.financial.provider.sensitivity.multicurve.SimpleParameterSensitivity.plus()
Create a copy of the sensitivity and add a given named sensitivity to it. If the name / currency pair is in the map, the two sensitivity matrices are added. Otherwise, a new entry is put into the map @param name The name. Not null. @param sensitivity The sensitivity to add, not null @return The total sensitivity.
com.opengamma.util.money.CurrencyAmount.plus()
Returns a copy of this {@code CurrencyAmount} with the specified amount added.
This adds the specified amount to this monetary amount, returning a new object. The addition simply uses standard {@code double} arithmetic.
This instance is immutable and unaffected by this method. @param amountToAdd the amount to add, in the same currency, not null @return an amount based on this with the specified amount added, not null @throws IllegalArgumentException if the currencies are not equal
com.opengamma.util.money.MultipleCurrencyAmount.plus()
Returns a copy of this {@code MultipleCurrencyAmount} with the specified amount added.
This adds the specified amount to this monetary amount, returning a new object. If the currency is already present, the amount is added to the existing amount. If the currency is not yet present, the currency-amount is added to the map. The addition simply uses standard {@code double} arithmetic.
This instance is immutable and unaffected by this method. @param currencyAmountToAdd the amount to add, in the same currency, not null @return an amount based on this with the specified amount added, not null
com.sun.codemodel.JVar.plus()
de.lmu.ifi.dbs.elki.math.linearalgebra.Vector.plus()
Returns a new vector which is the result of this vector plus the specified vector. @param v the vector to be added @return the resulting vector
edu.cmu.sphinx.fst.semiring.Semiring.plus()
Semiring's plus operation
edu.mit.csail.sdg.alloy4compiler.ast.Expr.plus()
Returns the expression (this+x)
this and x must be expressions with the same arity, or both be integer expressions
Note: as a special guarantee, if x==null, then the method will return this Expr object as-is.
edu.umd.cloud9.io.map.HMapSIW.plus()
Adds values of keys from another map to this map. @param m the other map
flanagan.analysis.ErrorProp.plus()
flanagan.circuits.Phasor.plus()
flanagan.complex.Complex.plus()
geom.Position.plus()
java.time.LocalDateTime.plus()
Returns a copy of this date-time with the specified amount added.
This returns a {@code LocalDateTime}, based on this one, with the specified amount added. The amount is typically {@link Period} or {@link Duration} but may beany other type implementing the {@link TemporalAmount} interface.
The calculation is delegated to the amount object by calling {@link TemporalAmount#addTo(Temporal)}. The amount implementation is free to implement the addition in any way it wishes, however it typically calls back to {@link #plus(long,TemporalUnit)}. Consult the documentation of the amount implementation to determine if it can be successfully added.
This instance is immutable and unaffected by this method call. @param amountToAdd the amount to add, not null @return a {@code LocalDateTime} based on this date-time with the addition made, not null @throws DateTimeException if the addition cannot be made @throws ArithmeticException if numeric overflow occurs
java.time.chrono.ChronoLocalDate.plus()
{@inheritDoc} @throws DateTimeException {@inheritDoc} @throws ArithmeticException {@inheritDoc}
javax.time.Duration.plus()
Returns a copy of this duration with the specified {@code Duration} added.
This instance is immutable and unaffected by this method call. @param duration the duration to add, positive or negative, not null @return a {@code Duration} based on this duration with the specified duration added, never null @throws ArithmeticException if the calculation exceeds the capacity of {@code Duration}
javolution.text.Text.plus()
Returns the concatenation of this text and the textual representation of the specified object. @param obj the object whose textual representation is concatenated. @return this.concat(Text.valueOf(obj))
kodkod.ast.IntExpression.plus()
Returns an IntExpression that represents the sum of this and the given int node. The effect of this method is the same as calling this.compose(PLUS, intExpr). @return this.compose(PLUS, intExpr)
kodkod.engine.bool.Int.plus()
Returns an Int that represents the sum of this and the given Int. @requires this.factory = other.factory @return an Int that represents the sum of this and the given Int @throws IllegalArgumentException - this.factory != other.factory
net.machinemuse.numina.geometry.MusePoint2D.plus()
org.apache.derby.iapi.types.SQLInteger.plus()
This method implements the + operator for "int + int". @param addend1 One of the addends @param addend2 The other addend @param result The result of a previous call to this method, nullif not called yet @return A SQLInteger containing the result of the addition @exception StandardException Thrown on error
org.apache.fop.traits.MinOptMax.plus()
Returns the sum of this MinOptMax and the given MinOptMax. @param operand the second operand of the sum (the first is this instance itself), @return the sum of this MinOptMax and the given MinOptMax.
org.apache.mahout.math.DenseMatrix.plus()
org.apache.mahout.math.DenseVector.plus()
org.apache.mahout.math.Matrix.plus()
Return a new matrix containing the sum of each value of the recipient and the argument @param x a double @return a new Matrix
org.apache.mahout.math.Vector.plus()
Return a new matrix containing the sum of each value of the recipient and the argument @param x a double @return a new Vector
org.apache.mahout.matrix.DenseVector.plus()
org.apache.mahout.matrix.Vector.plus()
Return a new matrix containing the sum of each value of the recipient and the argument @param x a double @return a new Vector
org.archfirst.common.money.Money.plus()
Add aThat Money to this Money. Currencies must match.
org.archfirst.common.quantity.DecimalQuantity.plus()
org.eigenbase.relopt.RelTraitSet.plus()
Returns this trait set with a given trait added or overridden. Does not modify this trait set. @param trait Trait @return Trait set with given trait
org.ejml.simple.SimpleMatrix.plus()
org.encog.ml.data.basic.BasicMLData.plus()
Add one data element to another. This does not modify the object. @param o The other data element @return The result.
org.exist.xquery.value.AbstractDateTimeValue.plus()
org.exist.xquery.value.ComputableValue.plus()
org.fnlp.ml.types.sv.HashSparseVector.plus()
v + sv @param sv
org.gradle.api.file.FileCollection.plus()
org.gradle.internal.classpath.ClassPath.plus()
org.gradle.internal.classpath.DefaultClassPath.plus()
org.joda.money.BigMoney.plus()
Returns a copy of this monetary value with a collection of monetary amounts added.
This adds the specified amounts to this monetary amount, returning a new object. The amounts are added as though using {@link #plus(BigMoneyProvider)}. The amounts must be in the same currency.
This instance is immutable and unaffected by this method. @param moniesToAdd the monetary values to add, no null elements, not null @return the new instance with the input amounts added, never null @throws CurrencyMismatchException if the currencies differ
org.joda.time.DateMidnight.plus()
Returns a copy of this date with the specified duration added.
If the amount is zero, then this is returned. @param duration the duration, in millis, to add to this one @return a copy of this datetime with the duration added @throws ArithmeticException if the new datetime exceeds the capacity of a long
org.joda.time.DateTime.plus()
Returns a copy of this datetime with the specified duration added.
If the amount is zero or null, then this is returned. This datetime instance is immutable and unaffected by this method call. @param duration the duration, in millis, to add to this one @return a copy of this datetime with the duration added @throws ArithmeticException if the new datetime exceeds the capacity of a long
org.joda.time.Duration.plus()
Returns a new duration with this length plus that specified. This instance is immutable and is not altered.
If the addition is zero, this instance is returned. @param amount the duration to add to this one @return the new duration instance
org.jscience.mathematics.number.Complex.plus()
org.jscience.mathematics.number.Float64.plus()
org.jscience.mathematics.number.LargeInteger.plus()
org.libreplan.business.planner.entities.ShareDivision.plus()
org.libreplan.business.workingday.EffortDuration.plus()
Pluses two {@link EffortDuration}.
Warning: This method can cause an integer overflow and the result would be incorrect. @param other @return a duration that is the sum of this{@link EffortDuration} and the other duration

org.mifosplatform.organisation.monetary.domain.Money.plus()

org.modeshape.jcr.api.value.DateTime.plus()
Add the specified about of time in the supplied units. @param timeAmount the amount of time to add @param unit the units of the amount of time; may not be null @return the instance in time the specified number of time after this instant

org.threeten.bp.Instant.plus()
{@inheritDoc} @throws DateTimeException {@inheritDoc} @throws ArithmeticException {@inheritDoc}

org.threeten.bp.LocalDate.plus()
Returns a copy of this date with the specified period added.
This method returns a new date based on this date with the specified period added. The amount is typically {@link Period} but may be any other type implementingthe {@link TemporalAmount} interface.The calculation is delegated to the specified adjuster, which typically calls back to {@link #plus(long,TemporalUnit)}.
This instance is immutable and unaffected by this method call. @param amount the amount to add, not null @return a {@code LocalDate} based on this date with the addition made, not null @throws DateTimeException if the addition cannot be made @throws ArithmeticException if numeric overflow occurs

org.threeten.bp.Month.plus()

org.threeten.bp.ZonedDateTime.plus()
Returns a copy of this date-time with the specified period added.
This method returns a new date-time based on this time with the specified period added. The amount is typically {@link Period} but may be any other type implementingthe {@link TemporalAmount} interface.The calculation is delegated to the specified adjuster, which typically calls back to {@link #plus(long,TemporalUnit)}.
This instance is immutable and unaffected by this method call. @param amount the amount to add, not null @return a {@code ZonedDateTime} based on this date-time with the addition made, not null @throws DateTimeException if the addition cannot be made @throws ArithmeticException if numeric overflow occurs

org.threeten.bp.chrono.ChronoLocalDate.plus()

org.threeten.bp.temporal.Temporal.plus()
a Period instance date = date.plus(duration); // add a Duration instance date = date.plus(workingDays(6)); // example user-written workingDays method
Note that calling {@code plus} followed by {@code minus} is not guaranteed toreturn the same date-time.
Specification for implementors
Implementations must not alter either this object. Instead, an adjusted copy of the original must be returned. This provides equivalent, safe behavior for immutable and mutable implementations. @param amount the amount to add, not null @return an object of the same type with the specified adjustment made, not null @throws DateTimeException if the addition cannot be made @throws ArithmeticException if numeric overflow occurs

winterwell.utils.time.Time.plus()
@param dt @return A new object that is time+dt. Uses Calendar to step neatly.

Examples of com.opengamma.analytics.financial.provider.sensitivity.inflation.MultipleCurrencyInflationSensitivity.plus()

161 162 163 164 165 166 167 168 169 170 171 public MultipleCurrencyInflationSensitivity visitCouponFixed(final CouponFixed coupon, final InflationProviderInterface inflation) {     MultipleCurrencyMulticurveSensitivity multipleCurrencyMulticurveSensitivity = METHOD_CPN_FIXED.presentValueCurveSensitivity(coupon, inflation.getMulticurveProvider());     MultipleCurrencyInflationSensitivity multipleCurrencyInflationSensitivity = new MultipleCurrencyInflationSensitivity();     for (final Currency loopccy : multipleCurrencyMulticurveSensitivity.getCurrencies()) {       Map<String, List<DoublesPair>> sensitivityPriceCurve = new HashMap<>();       multipleCurrencyInflationSensitivity.plus(loopccy, InflationSensitivity.of(multipleCurrencyMulticurveSensitivity.getSensitivity(loopccy), sensitivityPriceCurve));     }     return multipleCurrencyInflationSensitivity; } @Override

View Full Code Here

Examples of com.opengamma.analytics.financial.provider.sensitivity.multicurve.MulticurveSensitivity.plus()

165 166 167 168 169 170 171 172 173 174 175     final BlackPriceFunction blackFunction = new BlackPriceFunction();     final double volatility = blackMulticurves.getBlackParameters().getVolatility(swaption.getTimeToExpiry(), maturity);     final BlackFunctionData dataBlack = new BlackFunctionData(forwardModified, 1.0, volatility);     final double[] bsAdjoint = blackFunction.getPriceAdjoint(option, dataBlack);     MulticurveSensitivity result = pvbpModifiedDr.multipliedBy(bsAdjoint[0]);     result = result.plus(forwardModifiedDr.multipliedBy(pvbpModified * bsAdjoint[1]));     if (!swaption.isLong()) {       result = result.multipliedBy(-1);     }     return MultipleCurrencyMulticurveSensitivity.of(swaption.getCurrency(), result); }

View Full Code Here

Examples of com.opengamma.analytics.financial.provider.sensitivity.multicurve.MultipleCurrencyMulticurveSensitivity.plus()

63 64 65 66 67 68 69 70 71 72 73 @Override public MultipleCurrencyMulticurveSensitivity visitGenericAnnuity(final Annuity<? extends Payment> annuity, final SABRCapProviderInterface sabr) {     ArgumentChecker.notNull(annuity, "Annuity");     MultipleCurrencyMulticurveSensitivity pvcs = visit(annuity.getNthPayment(0), sabr);     for (int loopp = 1; loopp < annuity.getNumberOfPayments(); loopp++) {       pvcs = pvcs.plus(visit(annuity.getNthPayment(loopp), sabr));     }     return pvcs; } @Override

View Full Code Here

Examples of com.opengamma.analytics.financial.provider.sensitivity.multicurve.MultipleCurrencyParameterSensitivity.plus()

56 57 58 59 60 61 62 63 64 65 66     ArgumentChecker.notNull(sensitivity, "Sensitivity");     ArgumentChecker.notNull(fixedCurves, "Fixed Curves");     ArgumentChecker.notNull(bundle, "Curve bundle");     MultipleCurrencyParameterSensitivity result = new MultipleCurrencyParameterSensitivity();     for (final Currency ccy : sensitivity.getCurrencies()) {       result = result.plus(pointToParameterSensitivity(ccy, sensitivity.getSensitivity(ccy), fixedCurves, bundle));     }     return result; } public MultipleCurrencyParameterSensitivity pointToParameterSensitivity(final Currency ccy, final InterestRateCurveSensitivity sensitivity, final Set<String> fixedCurves,

View Full Code Here

Examples of com.opengamma.analytics.financial.provider.sensitivity.multicurve.SimpleParameterSensitivity.plus()

81 82 83 84 85 86 87 88 89 90 91         final Double valueBumped = instrument.accept(_valueCalculator, marketDscBumped);         final Double valueDiff = valueBumped + valueInitMinus;         sensitivity[loopnode] = valueDiff / _shift;       }       final String name = issuercurves.getMulticurveProvider().getName(ccy);       result = result.plus(name, new DoubleMatrix1D(sensitivity));     }     // Forward ON     final Set<IndexON> indexON = issuercurves.getMulticurveProvider().getIndexesON();     for (final IndexON index : indexON) {       final YieldAndDiscountCurve curve = issuercurves.getMulticurveProvider().getCurve(index);

View Full Code Here

Examples of com.opengamma.util.money.CurrencyAmount.plus()

89 90 91 92 93 94 95 96 97 98 99 public void presentValue() {     final CurrencyAmount pvTransactionComputed = METHOD_TRANSACTION.presentValue(BILL_TRA, CURVE_BUNDLE);     CurrencyAmount pvSecurity = METHOD_SECURITY.presentValue(BILL_TRA.getBillPurchased(), CURVE_BUNDLE);     pvSecurity = pvSecurity.multipliedBy(QUANTITY);     final double pvSettle = BILL_TRA_DEFINITION.getSettlementAmount() * CURVE_BUNDLE.getCurve(NAME_CURVES[0]).getDiscountFactor(BILL_TRA.getBillPurchased().getSettlementTime());     assertEquals("Bill Security: discounting method - present value", pvSecurity.plus(pvSettle).getAmount(), pvTransactionComputed.getAmount(), TOLERANCE_PV); } @Test /**    * Tests the present value: Method vs Calculator

View Full Code Here

Examples of com.opengamma.util.money.MultipleCurrencyAmount.plus()

62 63 64 65 66 67 68 69 70 71 72 @Override public MultipleCurrencyAmount visitGenericAnnuity(final Annuity<? extends Payment> annuity, final SABRCapProviderInterface sabr) {     ArgumentChecker.notNull(annuity, "Annuity");     MultipleCurrencyAmount pv = visit(annuity.getNthPayment(0), sabr);     for (int loopp = 1; loopp < annuity.getNumberOfPayments(); loopp++) {       pv = pv.plus(visit(annuity.getNthPayment(loopp), sabr));     }     return pv; } @Override

View Full Code Here

Examples of com.sun.codemodel.JVar.plus()

411 412 413 414 415 416 417 418 419 420 421             // to next.             JVar currentIndex = eval.decl(generator.getModel().INT, "currentIndex" + listNum, JExpr.lit(-1));             eval._while( //                 currentIndex.lt(desiredIndex) //                     .cand(list.invoke("next"))).body().assign(currentIndex, currentIndex.plus(JExpr.lit(1)));             JBlock ifNoVal = eval._if(desiredIndex.ne(currentIndex))._then().block();             if (out.isOptional()) {               ifNoVal.assign(out.getIsSet(), JExpr.lit(0));

View Full Code Here

Examples of de.lmu.ifi.dbs.elki.math.linearalgebra.Vector.plus()

173 174 175 176 177 178 179 180 181 182 183           path.moveTo(p1);           path.cubicTo(p1.plus(direction2), p2.plus(direction1), p2);           path.cubicTo(p2.minus(direction1), p3.plus(direction2), p3);           path.cubicTo(p3.minus(direction2), p4.minus(direction1), p4);           path.cubicTo(p4.plus(direction1), p1.minus(direction2), p1);           path.close();           Element ellipse = path.makeElement(svgp);           SVGUtil.addCSSClass(ellipse, EMBORDER + cnum);           if(opacStyle == 1) {

View Full Code Here

Examples of edu.cmu.sphinx.fst.semiring.Semiring.plus()

167 168 169 170 171 172 173 174 175 176 177             State oldState = newToOldStateMap[s.getId()];             if (cl[oldState.getId()] != null) {                 for (State pathFinalState : cl[oldState.getId()].keySet()) {                     State s1 = pathFinalState;                     if (s1.getFinalWeight() != semiring.zero()) {                         s.setFinalWeight(semiring.plus(s.getFinalWeight(),                                 semiring.times(getPathWeight(oldState, s1, cl),                                         s1.getFinalWeight())));                     }                     int numArcs = s1.getNumArcs();                     for (int j = 0; j < numArcs; j++) {

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Copyright © 2018 www.massapi.com. All rights reserved.

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.