/*
 * FreeAdhocUDF - copyright (c) 2004 adhoc dataservice GmbH Peter Mandrella
 * based on FreeUDFLibC - copyright (c) 1999 Gregory Deatz
 * altered 2001 by ADITO Software GmbH Robert Loipfinger
 *
 *   math_functions.c
 *     Math routines declarations
 *
 *   for exported functions list see math_functions.h
 */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#include "global.h"
#include "math_functions.h"

static int get_value_of (char, char *);

static int get_value_of (c, digits)
     char c;
     char * digits;
{
  int i;
  
  for (i = 0 ;
       (digits[i] != (char) 0) && (digits[i] != c) ;
       i++) ;
  return i;
}

int convertfrom33 (sz)
     char * sz;
{
  int base = 33;
  
  return convertfrombase (sz, &base, "123456789ABCDEFGHIJKLMNPQRSTUVWXYZ");
}

char * convertto33 (value)
     int * value;
{
  int base = 33;

  return converttobase (value, &base, "123456789ABCDEFGHIJKLMNPQRSTUVWXYZ");
}

int convertfrombase (sz, base, digits)
     char * sz;
     int * base;
     char * digits;
{
  int i;
  int res = 0;
  int len = strlen(sz);
  
  for (i = 0 ; i < len ; i++)
    res = (*base * res) + get_value_of(sz[i], digits);
  return res;
}

char * converttobase (value, base, digits)
     int * value;
     int * base;
     char * digits;
{
  char sz_res[LOC_STRING_SIZE + 1];
  char * sz_result = (char *) MALLOC (LOC_STRING_SIZE + 1);
  int i = 0;
  int j, r, len_sz_res;
  int first_time = 1;

  for ( j = *value ;
       (j != 0) || first_time;
	j = j / *base, first_time = 0){
    r = j % *base;
    sz_res[i++] = digits[r];
  }
  sz_res[i] = (char) 0;
  sz_result[i] = (char) 0;
  len_sz_res = i;
  
  for (i = 0 ; i < len_sz_res ; i++)
    sz_result[i] = sz_res[len_sz_res - i - 1];
  return sz_result;
}

char * converttodollar (value)
     double * value;
{
  char * sz_result = (char *) MALLOC (LOC_STRING_SIZE + 1);

  sprintf(sz_result, "$%.2f", (*value));

  return sz_result;
}

double doubleabs (value)
     double * value;
{
  if (*value < 0)
    return -*value;
  else
    return *value;
}

char * fixedpoint (value, decimals)
     double * value;
     int * decimals;
{
  char * sz_result = MALLOC (LOC_STRING_SIZE + 1);

  sprintf(sz_result, "%.*f", *decimals, *value);

  return sz_result;
}

// pm 21.08.04
char * fixedpointlang (double *value, int *nk, char *comma, char *tsep)
{
  char buffer[128];
  double val = *value;
  char * sz_result = MALLOC (LOC_STRING_SIZE + 1);
  char * resp = sz_result;
  char * pc;
  int i, bl;

  // Vorkommastellen
  if (*nk <= 0)
    val += 0.5;
  bl = sprintf(buffer, "%.0f", floor(val));
  for (i = 0; i < bl; i++)
  {
    *resp++ = buffer[i];
    if (*tsep && i>0 && i<bl-1 && ((bl-1-i) % 3) == 0)
    {
      // Tausender-Separator
      pc = tsep;
      while (*pc)
        *resp++ = *pc++;
    }
  }

  if (*nk > 0)
  {
    // Dezimalpunkt
    pc = comma;
    while (*pc)
    {
      *resp = *pc;
      resp++, pc++;
    }

    // Nachkommastellen
    for (i=*nk; i>1; i--)
    {
      val = 10 * (val - floor(val));
      *resp = (char)(floor(val) + '0');
      resp++;
    }
    *resp = (char)(floor(10 * (val - floor(val)) + 0.5) + '0');
    resp++;
  }

  // terminate
  *resp = '\0';
  return sz_result;
}


int integerabs (value)
     int * value;
{
  if (*value < 0)
    return -*value;
  else
    return *value;
}


// pm 21.08.04
double maxnum (double *d1, double *d2)
{
  if (*d1 >= *d2) return *d1;
  else return *d2;
}


// pm 21.08.04
double minnum (double *d1, double *d2)
{
  if (*d1 <= *d2) return *d1;
  else return *d2;
}


int modulo (numerator, denominator)
     int * numerator;
     int * denominator;
{
  if (*denominator == 0)
    return 0;
  else
    return *numerator % *denominator;
}

// pm 21.08.04
int isdivisibleby (int* numerator, int* denominator)
{
  if (*denominator == 0)
    return 0;
  else
    return ((*numerator % *denominator) == 0);
}


int round (value)
     double * value;
{
  if (*value < 0)
    return (int)(*value - 0.5);
  else
    return (int)(*value + 0.5);
}

int truncate (value)
     double * value;
{
  return (int) (*value);
}

// pm 21.08.04  mda
double fact (int *n)
{
  if (*n<1 || *n>100)
    return 0.0;
  else
  {
    int i;
    double f = 1.0;
    for (i=2; i<=*n; i++)
      f *= i;
    return f;
  }
};

