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 org.joda.time.DateTime.plus()

556 557 558 559 560 561 562 563 564 565 566       duration = Duration.standardHours(1);     }         // check interval at next half hour     DateTime firstTimeslot = getNextHalfHour();     Interval test = new Interval(firstTimeslot, firstTimeslot.plus(duration));     testInterval(infeasible, preferred, test, solutions);         // loop over all infeasible intervals     for (Interval i : infeasible) {       // test timeslot left from the infeasible interval

View Full Code Here

Examples of org.joda.time.Duration.plus()

135 136 137 138 139 140 141 142 143 144 145           workingHours = workingHours.withEnd(now);         } else if (workingHours.getEnd().isBefore(now)) {           // leave end of working hours as is         }       }       duration = duration.plus(workingHours.toDuration());       dateBeingProcessed = dateBeingProcessed.plusDays(1);       processingInterval = getEntireDayIntervalForDate(dateBeingProcessed);     }     System.out.println(duration.toPeriod());     return duration;

View Full Code Here

Examples of org.jscience.mathematics.number.Complex.plus()

420 421 422 423 424 425 426 427 428 429 430         startTime();         for (int i = 0; i < 10000; i++) {             StackContext.enter();             Complex x = Complex.valueOf(1.0, 2.0);             for (int j = 0; j < results.length; j++) {                 results[j] = x.plus(x);             }             StackContext.exit();         }         endTime(10000 * results.length);

View Full Code Here

Examples of org.jscience.mathematics.number.Float64.plus()

396 397 398 399 400 401 402 403 404 405 406         startTime();         for (int i = 0; i < 10000; i++) {             StackContext.enter();             Float64 x = Float64.ONE;             for (int j = 0; j < results.length; j++) {                 results[j] = x.plus(x);             }             StackContext.exit();         }         endTime(10000 * results.length);

View Full Code Here

Examples of org.jscience.mathematics.number.LargeInteger.plus()

473 474 475 476 477 478 479 480 481 482 483         System.out.print("LargeInteger (1024 bits) addition: ");         startTime();         for (int i = 0; i < 1000; i++) {             StackContext.enter();             for (int j = 0; j < results.length; j++) {                 results[j] = large.plus(large);             }             StackContext.exit();         }         endTime(1000 * results.length);

View Full Code Here

Examples of org.libreplan.business.planner.entities.ShareDivision.plus()

168 169 170 171 172 173 174 175 176 177 178     }     private EffortDuration[] distribute(EffortDuration effort,             List<Share> shares) {         ShareDivision division = ShareDivision.create(shares);         return fromSecondsToDurations(division.to(division.plus(effort                 .getSeconds())));     }     private List<EffortDuration> asList(EffortDuration[] acc) {         return new ArrayList<EffortDuration>(Arrays.asList(acc));

View Full Code Here

Examples of org.libreplan.business.workingday.EffortDuration.plus()

578 579 580 581 582 583 584 585 586 587 588     private void addToResult(SortedMap<LocalDate, EffortDuration> result,             LocalDate date, EffortDuration duration) {         EffortDuration current = result.get(date) != null ? result.get(date)                 : zero();         result.put(date, current.plus(duration));     }     public List<DayAssignment> getDayAssignments(DayAssignment.FilterType filter) {         List<DayAssignment> dayAssignments = new ArrayList<DayAssignment>();         Set<ResourceAllocation<?>> resourceAllocations = getSatisfiedResourceAllocations();

View Full Code Here

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

449 450 451 452 453 454 455 456 457 458 459             numberOfDaysOfBalance = spanOfBalance.daysInPeriodInclusiveOfEndDate();         } else {             if (isDeposit()) {                 // endOfDayBalance = openingBalance.plus(getAmount(currency));                 // if (endOfDayBalance.isLessThanZero()) {                 endOfDayBalance = endOfDayBalance.plus(getAmount(currency));                 // }             } else if (isWithdrawal() || isChargeTransactionAndNotReversed()) {                 // endOfDayBalance = openingBalance.minus(getAmount(currency));                 if (endOfDayBalance.isGreaterThanZero()) {                     endOfDayBalance = endOfDayBalance.minus(getAmount(currency));

View Full Code Here

Examples of org.modeshape.jcr.api.value.DateTime.plus()

912 913 914 915 916 917 918 919 920 921 922                 ++i;                 if (stat == null) continue;                 sb.append("\n ");                 sb.append(stat);                 sb.append(" at ");                 sb.append(startTime.plus(i * width, TimeUnit.SECONDS));             }             return sb.toString();         }     } }

View Full Code Here

Examples of org.threeten.bp.Instant.plus()

583 584 585 586 587 588 589 590 591 592 593       assertEquals(now.plus(1, MINUTES).plus(60, SECONDS), exchanges.get(3).getVersionToInstant());       //       assertEquals(now.plus(1, MINUTES).plus(60, SECONDS), exchanges.get(2).getVersionFromInstant());       assertEquals(now.plus(1, MINUTES).plus(120, SECONDS), exchanges.get(2).getVersionToInstant());       //       assertEquals(now.plus(1, MINUTES).plus(120, SECONDS), exchanges.get(1).getVersionFromInstant());       assertEquals(now.plus(1, MINUTES).plus(180, SECONDS), exchanges.get(1).getVersionToInstant());       //       assertEquals(now.plus(1, MINUTES).plus(180, SECONDS), exchanges.get(0).getVersionFromInstant());       assertEquals(null, exchanges.get(0).getVersionToInstant());     } finally {

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.