formatted(): string {
   let s: string = Utils.bigFormat(this.amount);
   if (this.amount.greaterThan(0.0)) {
     s = '+' + s;
   }
   return s;
 }

 validate(): String[] {
   let errors = [];
   if (!this.date || !Utils.validateDate(this.date)) {
     errors.push('invalid date');
   }
   if (!this.localAmount || this.localAmount.lessThanOrEqualTo(0.0)) {
     errors.push('non-positive local amount');
   }
   if (!this.category) {
     errors.push('missing category');
   }
   return errors;
 }

 validate(): String[] {
   let that: Income = this;
   let errors = [];
   if (!that.date || !Utils.validateDate(that.date)) {
     errors.push('invalid date');
   }
   if (!that.foreignAmount || that.foreignAmount.lessThanOrEqualTo(0.0)) {
     errors.push('non-positive foreign amount');
   }
   if (!that.exchangeRate || that.exchangeRate.lessThanOrEqualTo(0.0)) {
     errors.push('non-positive exchange rate');
   }
   return errors;
 }

  addLastExpenseInternal(expense: Expense): Project {
    let that: Project = this;

    let fulfilledAmount = new BigNumber(0);
    let iteration = 0;
    while (fulfilledAmount.lessThan(expense.localAmount)) {
      iteration += 1;
      let pos = findFirstNonEmptyIncome(that.incomes);
      let income = that.incomes.get(pos);
      let neededValue = expense.localAmount.minus(fulfilledAmount);
      let valueToTake = neededValue;
      let availableValue = income.localAmount.minus(income.spentLocalAmount);
      if (pos < that.incomes.size - 1) {
        // If this is not the last possible income, then cap fulfillment amount
        // to this income.
        valueToTake = Utils.bigMin(neededValue, availableValue);
      } else if (availableValue.lessThan(neededValue)) {
        expense = expense.set('overshoot', true);
      }
      that = that.merge({
        incomes: that.incomes.set(pos, income.spendInLocalCurrency(valueToTake))
      });
      expense = expense.merge({
        foreignAmount:
          expense.foreignAmount.plus(valueToTake.dividedBy(income.exchangeRate)),
        multiPart: iteration > 1
      });
      fulfilledAmount = fulfilledAmount.plus(valueToTake);
    }

    let exchangeRate = expense.localAmount.dividedBy(expense.foreignAmount);
    return that.merge({
      expenses: that.expenses.push(
        expense.set('exchangeRate', exchangeRate)
      )
    });
  }