num.c

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <math.h>
#include <inttypes.h>
#include <string.h>
#include "num.h"

void
num_init(struct num *num) {
  num->type = TYPE_INT;
  num->unit = UNIT_BTC;
  num->intval = 0LL;
}

void
error_any() {
  fprintf(stderr, "error: --price argument required when using arbitrary units\n");
  exit(1);
}

static int64_t
num_to_msat(struct num *num) {
  double anyval = 1.0;

  if (num->type == TYPE_FLOAT) {
    double val = num->floatval;
    switch (num->unit) {
    case UNIT_OTHER:
      if (g_other.unit == UNIT_NONE) error_any();
      double other = 1.0/(g_other.type == TYPE_FLOAT ? g_other.floatval
                          : (double)g_other.intval);
      return (int64_t)(val * BTC * other);
    case UNIT_MSATOSHI:
      return (int64_t)val;
    case UNIT_SATOSHI:
      return (int64_t)(val * SATOSHI);
    case UNIT_FINNEY:
      return (int64_t)(val * FINNEY);
    case UNIT_BITS:
      return (int64_t)(val * BITS);
    case UNIT_MBTC:
      return (int64_t)(val * MBTC);
    case UNIT_BTC:
      return (int64_t)(val * BTC);
    case UNIT_NONE:
      assert(!"got UNIT_NONE in num_to_msat");
    }
  }

  int64_t val = num->intval;
  switch (num->unit) {
  case UNIT_MSATOSHI:
    return val;
  case UNIT_SATOSHI:
    return val * SATOSHI;
  case UNIT_FINNEY:
    return val * FINNEY;
  case UNIT_BITS:
    return val * BITS;
  case UNIT_MBTC:
    return val * MBTC;
  case UNIT_OTHER:
    if (g_other.unit != UNIT_OTHER) error_any();
    anyval = g_other.type == TYPE_FLOAT?
      g_other.floatval : (double)g_other.intval;
  case UNIT_BTC:
    return val * BTC*(1.0/anyval);
  case UNIT_NONE:
    assert(!"got UNIT_NONE in num_to_msat");
  }
}

#define num_op (op)

void
num_add(struct num *dst, struct num *a, struct num *b) {
  dst->type = TYPE_INT;
  dst->unit = UNIT_MSATOSHI;
  dst->intval = num_to_msat(a) + num_to_msat(b);
}


void
num_sub(struct num *dst, struct num *a, struct num *b) {
  dst->type = TYPE_INT;
  dst->unit = UNIT_MSATOSHI;
  dst->intval = num_to_msat(a) - num_to_msat(b);
}

int64_t
unit_msat_multiple(enum unit format) {
  switch (format) {
  case UNIT_MSATOSHI: return MSATOSHI;
  case UNIT_SATOSHI:  return SATOSHI;
  case UNIT_FINNEY:   return FINNEY;
  case UNIT_BITS:     return BITS;
  case UNIT_MBTC:     return MBTC;
  case UNIT_OTHER:
    if (g_other.unit != UNIT_OTHER) error_any();
    return BTC / (g_other.type == TYPE_FLOAT
      ? g_other.floatval
      : g_other.intval);
  case UNIT_BTC:      return BTC;
  case UNIT_NONE:     assert(!"got UNIT_NONE in num_to_msat");
  }
}

void
num_mul(struct num *dst, struct num *a, struct num *b) {
  assert(b->unit == UNIT_NONE);
  dst->type = TYPE_INT;
  dst->unit = UNIT_MSATOSHI;
  int64_t num = num_to_msat(a);
  switch (b->type) {
  case TYPE_FLOAT:
    dst->intval = (int64_t)(num * b->floatval);
    double d = (double)num * b->floatval;
    // FIXME: floating point sucks
    if (d <= 1.000000000000001L && 0.99999999999999L <= d) dst->intval = 1LL;
    break;
  case TYPE_INT:
    dst->intval = num * b->intval;
    break;
  }
}

void
num_div(struct num *dst, struct num *a, struct num *b) {
  dst->type = TYPE_INT;
  dst->unit = UNIT_MSATOSHI;

  if (b->unit == UNIT_NONE) {
    dst->intval = num_to_msat(a) / (b->type == TYPE_FLOAT? b->floatval
                                   : b->intval);
  } else if (a->unit == UNIT_NONE) {
    assert(!"not working yet");
    /* dst->type = TYPE_FLOAT; */
    /* dst->unit = b->unit; */
    /* double ad = a->type == TYPE_FLOAT? a->floatval : (double)a->intval; */
    /* int64_t bmsat = num_to_msat(b); */
  }
  else {
    assert(!"shouldnt happen");
  }
}

void
num_init_float(struct num *num, double d, enum unit unit) {
  num_init(num);
  num->floatval = d;
  num->type = TYPE_FLOAT;
  num->unit = unit;
  if (unit != UNIT_NONE) num_assign(num, num);
}

void
num_init_int(struct num *num, int64_t val, enum unit unit) {
  num_init(num);
  num->intval = val;
  num->type = TYPE_INT;
  num->unit = unit;
  if (unit != UNIT_NONE) num_assign(num, num);
}

void
num_assign(struct num *dst, struct num *a) {
  struct num num;
  num.type = TYPE_INT;
  num.unit = UNIT_MSATOSHI;
  num.intval = num_to_msat(a);
  *dst = num;
}

static void
trim_zeros (char *s, int n)
{
  char *p;
  int count;

  p = strchr (s,'.');         // Find decimal point, if any.
  if (p != NULL) {
    count = n;              // Adjust for more or less decimals.
    while (count >= 0) {    // Maximum decimals allowed.
      count--;
      if (*p == '\0')    // If there's less than desired.
        break;
      p++;               // Next character.
    }

    *p-- = '\0';            // Truncate string.
    while (*p == '0')       // Remove trailing zeros.
      *p-- = '\0';

    if (*p == '.') {        // If all decimals were zeros, remove ".".
      *p = '\0';
    }
  }
}

void
num_print(struct num *num, enum unit format, char *unitname, int print_unit) {
  static char buffer[255];
  int64_t msat_multiple = unit_msat_multiple(format);


  double d = num->type == TYPE_FLOAT? num->floatval : (double)num->intval;
  d /= (double)msat_multiple;
  sprintf (buffer, "%.11f", d);
  trim_zeros(buffer, 12);
  printf("%s", buffer);

  if (print_unit)
    printf(" %s", unitname? unitname : unit_name(format));

  printf("\n");
}



char *
unit_name(enum unit unit) {
  switch (unit) {
  case UNIT_MSATOSHI: return "msat";
  case UNIT_SATOSHI:  return "sat";
  case UNIT_FINNEY:   return "finney";
  case UNIT_BITS:     return "bits";
  case UNIT_MBTC:     return "mBTC";
  case UNIT_BTC:      return "BTC";
  case UNIT_OTHER:    return g_other_name;
  case UNIT_NONE:     assert(!"got UNIT_NONE in num_to_msat");
  default:
    assert(!"missing unit");
  }
}