> For the complete documentation index, see [llms.txt](https://money2.onepub.dev/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://money2.onepub.dev/arithmetic-operations.md).

# Arithmetic Operations

The Money class is immutable, so each operation returns a new Money instance.

Whilst money does support a number of arithmetic operations that take a double as the operator this is STRONGLY DISCOURAGE.  Doubles are imprecise and will introduce rounding errors.

Where ever possible used the methods that take a Fixed, Int or BigInt.

### MultiplyByFixed

Multiply a Money instance by a Fixed instance.

```dart
final kr = Currency.create('KR', 0);
final amount = Money.parseWithCurrency('100', kr, pattern: 'S0');
final halfish = amount.multiplyByFixed(Fixed.parse('0.4', ));
expect(halfish, equals(Money.fromIntWithCurrency(40, kr)));
expect(halfish.decimalDigits, equals(0));
```

### Multiply by num (double or int)

The '\*' operator takes a num and converts it to a Fixed value with 16 decimal places. However the scale of the result is dictated by the Money instance passed to the '\*' operator.

```dart
/// Create the KR currency with 0 decimal digits.
final kr = Currency.create('KR', 0);
/// parse '100' to get a Money storing KR100.
final amount = Money.parseWithCurrency('100', kr, pattern: 'S0');
/// Multiply by 0.4 to get KR40
final halfish = amount * 0.4;
expect(halfish, equals(Money.fromIntWithCurrency(40, kr)));
/// scale of the results is 0 as dictated by the Currency.
expect(halfish.decimalDigits, equals(0));
```

`Money` provides the following arithmetic operators:

* unary `-()`
* `+(Money)`
* `-(Money)`
* `*(num)`
* `/(num)`

**Operators `+` and `-` must be used with operands in same currency, otherwise `ArgumentError` will be thrown.**

```dart
import 'package:money2/money2.dart';
final tenDollars = fiveDollars + fiveDollars;
final zeroDollars = fiveDollars - fiveDollars;
```

Operators `*`, `/` receive a `num` as the second operand. Both operators use *schoolbook rounding* to round result up to a minorUnits of a currency.

```dart
import 'package:money2/money2.dart';
    test('Operators', () {
      final fiveDollars = Money.parse('5.00', isoCode: 'USD');
      final tenDollars = fiveDollars + fiveDollars;
      expect(tenDollars.minorUnits.toInt(), equals(1000));
      final zeroDollars = fiveDollars - fiveDollars;
      expect(zeroDollars.minorUnits.toInt(), equals(0));

      final fifteenCents = Money.fromBigInt(BigInt.from(15), isoCode: 'USD');

      final thirtyCents = fifteenCents * 2; // $0.30
      expect(thirtyCents.minorUnits.toInt(), equals(30));
      final eightCents = fifteenCents * 0.5; // $0.08 (rounded from 0.075)
      expect(eightCents.minorUnits.toInt(), equals(8));
    });
```