/*
 * FreeAdhocUDF - copyright (c) 2004 - 2006 adhoc dataservice GmbH
 * Christoph Theuring / Peter Mandrella / Georg Horn
 * based on FreeUDFLibC - copyright (c) 1999 Gregory Deatz
 *
 * File Name:	conv_functions.c
 * Description: this module contains UDFs to convert units
 *
 * for exported functions list see conv_functions.h
 *
 * Software distributed under the License is distributed on an
 * "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express
 * or implied. See the License for the specific language governing
 * rights and limitations under the License.
 *
*****************************************************************/

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <math.h>
#include "global.h"
#include "conv_functions.h"

// all functions ct 2006-11-25 implementation of NULL for FB 2.0

// distance
// inch to meter
double *in2m(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 2.54 / 100.0;
	return result;
    }
}

// feet to meter
double *ft2m(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 0.3048;
	return result;
    }
}

// yard to meter
double *yd2m(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 0.9144;
	return result;
    }
}

// mile to kilometer
double *mile2km(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 1.609344;
	return result;
    }
}

// seamile to kilometer
double *sm2km(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 1.8520;
	return result;
    }
}

// fathom to meter
double *fm2m(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 1.829;
	return result;
    }
}

// typoPoint to millimeter
double *p2mm(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 0.376065;
	return result;
    }
}

// meter to inch
double *m2in(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 2.54 * 100.0;
	return result;
    }
}

// meter to feet
double *m2ft(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 0.3048;
	return result;
    }
}

// meter to yard
double *m2yd(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 0.9144;
	return result;
    }
}

// kilometer to mile
double *km2mile(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 1.609344;
	return result;
    }
}

// kilometer to seamile
double *km2sm(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 1.8520;
	return result;
    }
}

// meter to fathom
double *m2fm(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 1.829;
	return result;
    }
}

// millimeter to typoPoint
double *mm2p(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 0.376065;
	return result;
    }
}

// area
// ar to squarmeter
double *ar2sqm(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 100.0;
	return result;
    }
}

// ha to squarmeter
double *ha2sqm(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 10000.0;
	return result;
    }
}

// german Morgen to squarmeter
double *morgen2sqm(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 2500.0;
	return result;
    }
}

// squarfeet to squarmeter
double *sqft2sqm(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 0.09290306;
	return result;
    }
}

// acre to squarmeter
double *ac2sqm(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 4046.856;
	return result;
    }
}

// squaryard to squarmeter
double *sqyd2sqm(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 0.8361;
	return result;
    }
}

// squarmeter to ar
double *sqm2ar(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 100.0;
	return result;
    }
}

// squarmeter to ha
double *sqm2ha(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 10000.0;
	return result;
    }
}

// squarmeter to german Morgen
double *sqm2morgen(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 2500.0;
	return result;
    }
}

// squarmeter to squarfeet
double *sqm2sqft(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 0.09290306;
	return result;
    }
}

// squarmeter to acre
double *sqm2ac(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 4046.856;
	return result;
    }
}

// squarmeter to squaryard
double *sqm2sqyd(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 0.8361;
	return result;
    }
}

// volume
// barrel to liter
double *bbl2l(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 158.988;
	return result;
    }
}

// GB fluid ounce to mililiter
double *gbfloz2ml(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 28.4131;
	return result;
    }
}

// US fluid ounce to mililiter
double *usfloz2ml(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 29.5735;
	return result;
    }
}

// GB pint to liter
double *gbpt2l(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 0.568262;
	return result;
    }
}

// US pint to liter
double *uspt2l(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 0.473176;
	return result;
    }
}

// GB quart to liter
double *gbqt2l(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 1.136521;
	return result;
    }
}

// US quart to liter
double *usqt2l(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 0.9463531;
	return result;
    }
}

// GB gallon to liter
double *gbgal2l(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 4.546091;
	return result;
    }
}

// US gallon to liter
double *usgal2l(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 3.785411;
	return result;
    }
}

// register ton to cubic meter
double *rt2cbm(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 2.83168;
	return result;
    }
}

// liter to barrel
double *l2bbl(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 158.988;
	return result;
    }
}

// mililiter to GB fluid ounce
double *ml2gbfloz(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 28.4131;
	return result;
    }
}

// mililiter to US fluid ounce
double *ml2usfloz(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 29.5735;
	return result;
    }
}

// liter to GB pint
double *l2gbpt(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 0.568262;
	return result;
    }
}

// liter to US pint
double *l2uspt(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 0.473176;
	return result;
    }
}

// liter to GB quart
double *l2gbqt(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 1.136521;
	return result;
    }
}

// liter to US quart
double *l2usqt(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 0.9463531;
	return result;
    }
}

// liter to GB gallon
double *l2gbgal(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 4.546091;
	return result;
    }
}

// liter to US gallon
double *l2usgal(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 3.785411;
	return result;
    }
}

// cubic meter to register ton
double *cbm2rt(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 2.83168;
	return result;
    }
}

// weight
// carat to gramm
double *ct2g(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 0.2;
	return result;
    }
}

// ounce to gramm
double *oz2g(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 28.3495;
	return result;
    }
}

// troy ounce to gramm
double *oztr2g(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 31.1;
	return result;
    }
}

// pound to kilogramm
double *lb2kg(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 0.45359237;
	return result;
    }
}

// gramm to carat
double *g2ct(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 0.2;
	return result;
    }
}

// gramm to ounce
double *g2oz(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 28.3495;
	return result;
    }
}

// gramm to troy ounce
double *g2oztr(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 31.1;
	return result;
    }
}

// kilogramm to pound
double *kg2lb(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 0.45359237;
	return result;
    }
}

// tecnical
//  Gauss to Tesla
double *g2t(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 10000.0;
	return result;
    }
}

// bar to torr
double *bar2torr(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 750.0638;
	return result;
    }
}

// bar to pascal
double *bar2pa(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 100000.0;
	return result;
    }
}

// psi to pascal
double *psi2pa(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 6894.757;
	return result;
    }
}

// torr to pascal
double *torr2pa(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 133.322;
	return result;
    }
}

// calorie to joule
double *cal2j(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 4.1868;
	return result;
    }
}

// PS to kW
double *ps2kw(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 0.73549875;
	return result;
    }
}

// british hp to kW
double *bhp2kw(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 0.745699;
	return result;
    }
}

//  Tesla to Gauss
double *t2g(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 10000.0;
	return result;
    }
}

// torr to bar
double *torr2bar(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 750.0638;
	return result;
    }
}

// pascal to bar
double *pa2bar(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 100000.0;
	return result;
    }
}

// pascal to psi
double *pa2psi(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 6894.757;
	return result;
    }
}

// pascal to torr
double *pa2torr(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 133.322;
	return result;
    }
}

// joule to calorie
double *j2cal(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 4.1868;
	return result;
    }
}

// kW to PS
double *kw2ps(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 0.73549875;
	return result;
    }
}

// kW to british hp
double *kw2bhp(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x / 0.745699;
	return result;
    }
}

// temperature
// celsius to fahrenheit
double *c2f(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *x * 1.8 + 32.0;
	return result;
    }
}

// fahrenheit to celsius
double *f2c(double *x)
{
    if (!x)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = (*x - 32.0) / 1.8;
	return result;
    }
}

// number system
// roman to arabic
int *roman2arabic(char *rz)
{
    if (!rz)
	return NULL;
    else {
	int *result = MALLOC(sizeof(int));
	int len = strlen(rz);
	char ziffer;		/* enthaelt die aktuelle Ziffer der roemischen Zahl */
	int naechst = 0;	/* enthaelt 'ziffer' in arabischer Form             */
	int letzt = 0;		/* enthaelt die vorherige Ziffer in arabischer Form */
	int wert = 0;		/* enthaelt das Ergebnis = arabische Zahl           */

	int i;

    /*----------------------------------------------------
    verarbeite die roemische Zahl von links nach rechts:
    ----------------------------------------------------*/
	for (i = 0; i < len; i++) {

	    ziffer = toupper(rz[i]);

      /*-------------------------------------------
      Die aktuelle roemische Ziffer wird in ihren
      arabischen Gegenwert uebersetzt.
      -------------------------------------------*/
	    switch (ziffer) {

	    case 'M':
		naechst = 1000;
		break;

	    case 'D':
		naechst = 500;
		break;

	    case 'C':
		naechst = 100;
		break;

	    case 'L':
		naechst = 50;
		break;

	    case 'X':
		naechst = 10;
		break;

	    case 'V':
		naechst = 5;
		break;

	    case 'I':
		naechst = 1;
		break;

	    default:
		*result = -1;	/* ungueltige Ziffer => Abbruch */
		return result;

	    }			/* switch */

      /*--------------------------------------------------------
      Wenn die vorherige roemische Ziffer einen kleineren Wert
      hat als die akutelle, so wird der Wert der vorherigen
      subtrahiert, ansonsten wird er addiert.
      --------------------------------------------------------*/
	    if (letzt < naechst) {
		wert -= letzt;
	    } else {
		wert += letzt;
	    }

	    letzt = naechst;	/* eine Ziffer weiterruecken */

	}			/* for */

	wert += letzt;

	*result = wert;
	return result;
    }
}

// arabic to roman
static int ArabicTab[13] =
    { 1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000 };

static char *RomanTab[13] =
    { "I", "IV", "V", "IX", "X", "XL", "L", "XC", "C", "CD", "D", "CM", "M" };

char *arabic2roman(int *az)
{
    if (!az)
	return NULL;
    else {
	int i, a = *az;
	char *rz = (char *) MALLOC(250);

	*rz = '\0';
	if (a <= 200000) {
	    for (i = 12; i >= 0; i--) {
		while (a >= ArabicTab[i]) {
		    a -= ArabicTab[i];
		    strcat(rz, RomanTab[i]);
		}
	    }
	}
	return rz;
    }
}


int *convertfrom33(char *sz)
{
    if (!sz)
	return NULL;
    else {
	int base = 33;
	int *result = convertfrombase(sz, &base,
	    "123456789ABCDEFGHIJKLMNPQRSTUVWXYZ");
	return result;
    }
}


char *convertto33(int *value)
{
    if (!value)
	return NULL;
    else {
	int base = 33;
	char *result = converttobase(value, &base,
	    "123456789ABCDEFGHIJKLMNPQRSTUVWXYZ");
	return result;
    }
}


static int get_value_of(char c, char *digits)
{
    int i;

    for (i = 0; (digits[i] != (char) 0) && (digits[i] != c); i++);
    return i;
}


int *convertfrombase(char *sz, int *base, char *digits)
{
    if (!sz || !base || !digits)
	return NULL;
    else {
	int *result = MALLOC(sizeof(int));
	int i;
	int res = 0;
	int len = strlen(sz);

	for (i = 0; i < len; i++)
	    res = (*base * res) + get_value_of(sz[i], digits);
	*result = res;
	return result;
    }
}


char *converttobase(int *value, int *base, char *digits)
{
    if (!value || !base || !digits)
	return NULL;
    else {
	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;
    }
}


// pm 03.10.05
// ct 2006-11-25 implementation of NULL for FB 2.0
char *inttohex(int *n, int *digits)
{
    if (!n || !digits)
	return NULL;
    else {
	char *sz_result = (char *) MALLOC(*digits + 1);
	char *pc = sz_result;

	sprintf(sz_result, "%*x", *digits, *n);

	while (*pc) {
	    if (*pc == ' ')
		*pc = '0';
	    pc++;
	}

	return sz_result;
    }
}


// pm 03.10.05
// ct 2006-11-25 implementation of NULL for FB 2.0
int *hextoint(char *sz)
{
    if (!sz)
	return NULL;
    else {
	int *result = MALLOC(sizeof(int));
	int res = 0;

	while (*sz) {
	    res *= 16;
	    if (isdigit(*sz)) {
		res += (*sz - '0');
	    } else if (isalpha(*sz)) {
		if (*sz <= 'Z')
		    res += ((*sz - 'A') + 10);
		else
		    res += ((*sz - 'a') + 10);
	    }
	    sz++;
	}

	*result = res;
	return result;
    }
}

//  geometrical
// pm 03.10.05
// ct 2006-11-25 implementation of NULL for FB 2.0
double *degtorad(double *d)
{
    if (!d)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *d / 180.0 * M_PI;
	return result;
    }
}


// pm 03.10.05
// ct 2006-11-25 implementation of NULL for FB 2.0
double *radtodeg(double *d)
{
    if (!d)
	return NULL;
    else {
	double *result = MALLOC(sizeof(double));
	*result = *d / M_PI * 180.0;
	return result;
    }
}
