MoneyAlgorithmics.java

/*
 * Copyright (c) 2012, 2013, Werner Keil, Credit Suisse (Anatole Tresch). Licensed under the Apache
 * License, Version 2.0 (the "License"); you may not use this file except in compliance with the
 * License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License. Contributors: Anatole Tresch - initial version.
 */
package org.javamoney.adopjsr;

import javax.money.CurrencyUnit;
import javax.money.MonetaryAmount;
import javax.money.MonetaryOperator;
import javax.money.MonetaryQuery;
import java.math.BigDecimal;
import java.util.List;

/**
 * Class to perform algorithmic calculations and some of the provided external functions on amounts.
 * Created by Anatole on 07.03.14.
 */
public class MoneyAlgorithmics {

    /**
     * Add up all {@link MonetaryAmount} instances.
     *
     * @param amounts the amounts (only in one single currency).
     * @return the sum of all amounts
     */
    public MonetaryAmount addAll(MonetaryAmount... amounts) {
        throw new UnsupportedOperationException();
    }

    /**
     * Multiply the {@link MonetaryAmount} with the given factor.
     *
     * @param amount the amount
     * @param factor the the factor
     * @return the multiplied amount
     */
    public MonetaryAmount multiply(MonetaryAmount amount, Number factor) {
        throw new UnsupportedOperationException();
    }

    /**
     * subtract two {@link MonetaryAmount}s.
     *
     * @param amount the amount
     * @param amt2   the amoun to be
     * @return
     */
    public MonetaryAmount subtract(MonetaryAmount amount, MonetaryAmount amt2) {
        throw new UnsupportedOperationException();
    }

    /**
     * Divide an {@link MonetaryAmount}.
     *
     * @param amount the amount
     * @param factor the factor
     * @return
     */
    public MonetaryAmount divide(MonetaryAmount amount, BigDecimal factor) {
        throw new UnsupportedOperationException();
    }

    /**
     * Scale an {@link MonetaryAmount}.
     *
     * @param amount the amount
     * @param scale  the scale factor
     * @return
     */
    public MonetaryAmount scaleByTen(MonetaryAmount amount, int scale) {
        throw new UnsupportedOperationException();
    }

    /**
     * Sort the given {@link MonetaryAmount}s, by currency and number.
     *
     * @param amounts the amounts
     * @return
     */
    public List<MonetaryAmount> sortAmounts(MonetaryAmount... amounts) {
        throw new UnsupportedOperationException();
    }

    /**
     * Calculate the sum of only the given amounts, that are of the given currency.
     *
     * @param targetCurrency the target currency
     * @param amounts        the amounts to filter and add
     * @return the amount's total, in the given target currency.
     */
    public MonetaryAmount querySumOf(CurrencyUnit targetCurrency, MonetaryAmount... amounts) {
        throw new UnsupportedOperationException();
    }

    /**
     * Calculate the reciprocal of the given {@link MonetaryAmount} (1/amount).
     *
     * @param amount the amount, with the same currency.
     * @return the amount's reciprocal value.
     */
    public MonetaryAmount calculateReciprocal(MonetaryAmount amount) {
        throw new UnsupportedOperationException();
    }

    /**
     * Calulculate the given percentage of an {@link MonetaryAmount}.
     *
     * @param amt     the amount
     * @param percent the percentage, with the same currency.
     * @return the amount's percentage value.
     * @see org.javamoney.moneta.function.MonetaryFunctions
     */
    public MonetaryAmount calculatePercent(MonetaryAmount amt, double percent) {
        throw new UnsupportedOperationException();
    }

    /**
     * Calulculate the given permil of an {@link MonetaryAmount}.
     *
     * @param amt    the amount
     * @param permil the percentage, with the same currency.
     * @return the amount's permil value.
     * @see org.javamoney.moneta.function.MonetaryFunctions
     */
    public MonetaryAmount calculatePermil(MonetaryAmount amt, double permil) {
        throw new UnsupportedOperationException();
    }

    /**
     * Get the major part only of the given {@link MonetaryAmount}.
     *
     * @param amt the amount
     * @return the major part of it, with the same currency.
     * @see org.javamoney.moneta.function.MonetaryFunctions
     * @see org.javamoney.moneta.function.MonetaryUtil
     */
    public MonetaryAmount getMajorPart(MonetaryAmount amt) {
        throw new UnsupportedOperationException();
    }

    /**
     * Calculate a compound interest, defined as {@code }base * (1+interest)^n}
     *
     * @param base the base amount
     * @param rate the interest rate
     * @param n    the periods
     * @return the compound interest.
     */
    public MonetaryAmount getCompoundInterest(MonetaryAmount base, double rate, int n) {
        throw new UnsupportedOperationException();
    }


    /**
     * Multiply amount with the given factor (advanced). <p/>
     * <b>Hint: </b>The factor may exceed the numeric capabilities of the
     * amount implementation given!
     *
     * @param amount the amount
     * @param factor the factor
     * @return the correct result
     * @see javax.money.MonetaryAmount#getContext()
     * @see javax.money.MonetaryContext
     * @see javax.money.MonetaryAmounts#getAmountFactory(Class) (javax.money.AmountFactoryQuery)
     */
    public MonetaryAmount multiplyAdvanced(MonetaryAmount amount, BigDecimal factor) {
        throw new UnsupportedOperationException();
    }

    /**
     * Subtract two amounts. <p/>
     * <b>Hint: </b>The valuation may exceed the numeric capabilities of the
     * amount implementation given!  You should handle this situation, e.g. by using a more appropriate amount
     * implementation.
     *
     * @param amount the base amount
     * @param amt2   the amount to be subtracted
     * @return the subtraction result
     * @see javax.money.MonetaryAmount#getContext()
     * @see javax.money.MonetaryContext
     * @see javax.money.MonetaryAmounts#getAmountFactory(Class) (javax.money.AmountFactoryQuery)
     */
    public MonetaryAmount subtractAdvanced(MonetaryAmount amount, MonetaryAmount amt2) {
        throw new UnsupportedOperationException();
    }

    /**
     * Divide an amount.<p/>
     * <b>Hint: </b>The valuation may exceed the numeric capabilities of the
     * amount implementation given! You should handle this situation, e.g. by using a more appropriate amount
     * implementation.
     *
     * @param amount the amount
     * @param factor the factor (divisor)
     * @return the division result
     * @see javax.money.MonetaryAmount#getContext()
     * @see javax.money.MonetaryContext
     * @see javax.money.MonetaryAmounts#getAmountFactory(Class) (javax.money.AmountFactoryQuery)
     */
    public MonetaryAmount divideAdvanced(MonetaryAmount amount, BigDecimal factor) {
        throw new UnsupportedOperationException();
    }


    /**
     * Implement a {@link javax.money.MonetaryOperator} that simply duplicates the amount given.
     *
     * @return the duplicating operator.
     */
    public MonetaryOperator getDuplicateOperator() {
        throw new UnsupportedOperationException();
    }

    /**
     * Implement a {@link javax.money.MonetaryOperator} that calculates the total of all amounts operated on.
     */
    public MonetaryOperator getTotalOperator() {
        throw new UnsupportedOperationException();
    }

    /**
     * Implement a {@link javax.money.MonetaryQuery} that return {@code true} for each amount, that has an ISO
     * currency (as available on {@link java.util.Currency}.
     */
    public MonetaryQuery<Boolean> getCountingQuery() {
        throw new UnsupportedOperationException();
    }

}