Java BigDecimal.max方法代码示例

import java.math.BigDecimal; //导入方法依赖的package包/类
/**
 * Create a graph
 * @param goalInKg the goal set
 * @param measurements the measurement data
 * @return a chart 
 */
public Chart create(BigDecimal goalInKg, Iterable<WeightMeasurement> measurements) {
	BigDecimal minValue = goalInKg;
	BigDecimal maxValue = goalInKg;
	List<List<Object>> dataPoints = new ArrayList<>();
	for (WeightMeasurement wm : measurements) {
		if (minValue == null) {
			minValue = wm.getWeightInKg();
		} else {
			minValue = minValue.min(wm.getWeightInKg());
		}
		if (maxValue == null) {
			maxValue = wm.getWeightInKg();
		} else {
			maxValue = maxValue.max(wm.getWeightInKg());
		}
		dataPoints.add(Lists.newArrayList(wm.getDateTime().toInstant(ZoneOffset.UTC).toEpochMilli(),wm.getWeightInKg()));
	}
	if (minValue != null) {
		minValue = minValue.subtract(BigDecimal.valueOf(1));
	} 
	if (maxValue != null) {
		maxValue = maxValue.add(BigDecimal.valueOf(1));
	}
	return Chart.of(minValue, maxValue, goalInKg, dataPoints, calculareTrend(dataPoints));
}
 

import java.math.BigDecimal; //导入方法依赖的package包/类
/**
 * As defined in Appendix 1 of ISDA_SIMM_2.0_(PUBLIC).pdf
 */
static BigDecimal calculateCurvatureMarginResidual(List<BucketWeightedAggregation> aggregateByBucket) {
  List<BucketWeightedAggregation> residuals = BucketWeightedAggregationUtils.filterOutNonResiduals(aggregateByBucket);
  BigDecimal sum = ZERO;
  for (BucketWeightedAggregation bucketWeightedAggregation : residuals) {
    BigDecimal weightedSensitivitiesSum = WeightedSensitivityUtils.sumWeightSensitivities(bucketWeightedAggregation.getWeightedSensitivities());
    BigDecimal calculateLambda = CurvatureMarginLambdaUtils.calculateLambda(bucketWeightedAggregation.getWeightedSensitivities());
    BigDecimal product = calculateLambda.multiply(bucketWeightedAggregation.getAggregate());
    BigDecimal riskFactorTotal = weightedSensitivitiesSum.add(product);
    sum = sum.add(riskFactorTotal);
  }
  return sum.max(ZERO);
}
 

import java.math.BigDecimal; //导入方法依赖的package包/类
/**
 * As defined in Appendix 1 of ISDA_SIMM_2.0_(PUBLIC).pdf
 */
static BigDecimal aggregateCrossBucket(RiskClass riskClass, List<BucketWeightedAggregation> aggregateByBucket) {
  List<BucketWeightedAggregation> nonResiduals = BucketWeightedAggregationUtils.filterOutResiduals(aggregateByBucket);
  if (CollectionUtils.isNotEmpty(nonResiduals)) {
    BigDecimal sumOfRiskExposures = BucketWeightedAggregationUtils.sumWeightedSensitivities(nonResiduals);
    List<WeightedSensitivity> allWeightedSensitivities =
      nonResiduals.stream().map(BucketWeightedAggregation::getWeightedSensitivities).flatMap(Collection::stream).collect(Collectors.toList());
    BigDecimal calculateLambda = CurvatureMarginLambdaUtils.calculateLambda(allWeightedSensitivities);

    BigDecimal sumSquaresByBucket = BucketWeightedAggregationUtils.sumSquared(nonResiduals);
    BigDecimal sumCorrelationsAcrossBuckets = sumCorrelationsAcrossBuckets(riskClass, nonResiduals);
    BigDecimal crossSum = sumSquaresByBucket.add(sumCorrelationsAcrossBuckets);
    BigDecimal crossSqrt = BigDecimalUtils.sqrt(crossSum);

    BigDecimal rhs = calculateLambda.multiply(crossSqrt);

    BigDecimal finalSum = sumOfRiskExposures.add(rhs);
    return finalSum.max(ZERO);
  } else {
    return ZERO;
  }
}
 

import java.math.BigDecimal; //导入方法依赖的package包/类
public static boolean doLogic(BigDecimal valueOne, Operator.Logic operator, BigDecimal valueTwo)
{
	switch (operator)
	{
		case EQUALS:
			return valueOne.equals(valueTwo);
		case NOTEQUALS:
			return !valueOne.equals(valueTwo);
		case GREATER:
			BigDecimal max = valueOne.max(valueTwo);
			return max.equals(valueOne);
		case SMALLER:
			BigDecimal min = valueOne.min(valueTwo);
			return min.equals(valueOne);
		default:
			return false;
	}
}
 

import java.math.BigDecimal; //导入方法依赖的package包/类
private BigDecimal getFeeAmount(BigDecimal amount, BigDecimal feeRatio, BigDecimal feeMax) {
    BigDecimal fee = new BigDecimal(0);
    if(null == amount || null == feeRatio) return fee;
    //金额乘以费率 = 手续费
    fee = amount.multiply(feeRatio);
    //最大值为feeMax
    if(null != feeMax && feeMax.compareTo(new BigDecimal("0")) >= 0) fee = fee.max(feeMax);
    //设置精确到分并四舍五入
    fee = fee.setScale(4, BigDecimal.ROUND_HALF_UP);
    return fee;
}
 

import java.math.BigDecimal; //导入方法依赖的package包/类
/**
 * Calculate Maximum
 * 
 * @param fileContents
 * @param target
 * @return sumValue
 */
private BigDecimal calculateMax(FileContents fileContents,
        final String target) {
    /* Calculate Maximum Column Value */
    BigDecimal maxValue = BigDecimal.valueOf(Double.MIN_VALUE);
    for (final FileRecord fileRecord : fileContents.getData()) {
        BigDecimal expressionValue = new BigDecimal(String.valueOf(
                evaluateExpression(fileContents, fileRecord, target)));
        maxValue = maxValue.max(expressionValue);
    }
    return maxValue;
}
 

import java.math.BigDecimal; //导入方法依赖的package包/类
@Override
public BigDecimal max(BigDecimal arg0, BigDecimal arg1) {
    return arg0.max(arg1);
}
 

import java.math.BigDecimal; //导入方法依赖的package包/类
public static BigDecimal max( BigDecimal a, BigDecimal b ) {
   return a.max( b );
}
 

import java.math.BigDecimal; //导入方法依赖的package包/类
@Override
protected BigDecimal adjustSellBoundaryPrice(Context context, Request request, BigDecimal price) {

    if (price == null) {
        return null;
    }

    Key key = getUnderlyingKey(request);

    if (key == null) {
        return price;
    }

    BigDecimal ask = context.getBestAskPrice(key);

    BigDecimal comm = context.getCommissionRate(key);

    BigDecimal spread = request.getTradingSpread();

    BigDecimal dailyRate = getDecimalProperty(KEY_SWAP_S, SWAP_RATE);

    BigDecimal swap = calculateSwapRate(context, request, dailyRate);

    if (ask == null || comm == null || swap == null) {
        return null;
    }

    BigDecimal theoretical = ask.multiply(ONE.add(comm).add(spread).add(swap));

    return price.max(theoretical);

}
 

import java.math.BigDecimal; //导入方法依赖的package包/类
@VisibleForTesting
BigDecimal calculateSellLimitPrice(Context context, Request request, BigDecimal weighedPrice, BigDecimal basis) {

    if (weighedPrice == null || basis == null) {

        log.trace("Sell price not available : weighed=[{}] basis=[{}]", weighedPrice, basis);

        return null;

    }

    Key key = Key.from(request);

    BigDecimal bound = calculateSellBoundaryPrice(context, request, basis);

    if (bound == null) {

        log.trace("Sell price not available : No bound price.");

        return null;

    }

    BigDecimal basisPrice = weighedPrice.multiply(ONE.add(basis));

    BigDecimal boundPrice = basisPrice.max(bound);

    BigDecimal rounded = context.roundTickSize(key, boundPrice, UP);

    log.trace("Sell price : {} (target=[{}] basis=[{}])", rounded, boundPrice, basisPrice);

    return rounded;

}
 

import java.math.BigDecimal; //导入方法依赖的package包/类
@VisibleForTesting
BigDecimal getDecimal(String site, String instrument,
                      PropertyType type, BigDecimal min, BigDecimal max, BigDecimal defaultValue) {

    try {

        BigDecimal value = get(type, site, instrument, Configuration::getBigDecimal);

        BigDecimal adjusted = value;

        if (min != null) {
            adjusted = adjusted.max(min);
        }

        if (max != null) {
            adjusted = adjusted.min(max);
        }

        log.trace("Fetched {} ({}.{}) : {} -> {}", type, site, instrument, value, adjusted);

        return adjusted;

    } catch (RuntimeException e) {

        log.warn(format("Invalid %s (%s.%s)", type, site, instrument), e);

        return defaultValue;

    }

}
 

import java.math.BigDecimal; //导入方法依赖的package包/类
public static BigDecimal max(BigDecimal a, BigDecimal b) { return a.max(b); }