char * itoa(int value, char * str, int base)
{
if (base < 2 || base > 36)
// not handled, there is no error code
return str;
if (base == 10)
itodec(value, str);
else if (base == 8)
itooct(value, str);
else if (base == 0x10)
itohex(value, str, 0);
else
{
// TODO
}
return str;
}
/*
* Routine: set_pricing(int nTabId, ds_pricing_t *pPricing)
* Purpose: handle the various pricing calculations for the fact tables
* Notes:
* the RNG usage is not kept in sync between sales pricing and returns pricing. If the calculations look wrong, it may
* be necessary to "waste" some RNG calls on one side or the other to bring things back in line
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
void set_pricing(int nTabId, ds_pricing_t *pPricing)
{
static int nLastId = -1,
init = 0,
nQuantityMax,
nQuantityMin = 1;
static decimal_t dQuantity, dMarkupMin, dDiscountMin, dWholesaleMin,
dMarkupMax, dDiscountMax, dWholesaleMax, dCouponMin, dCouponMax,
dZero, dOneHalf, d9pct, dOne, dTemp, dHundred;
decimal_t dMarkup, dCoupon, dShipping, dDiscount, dTemp2;
int i,
nCashPct,
nCreditPct,
nCouponUsage;
if (!init)
{
strtodec(&dMarkupMin, "0.00");
strtodec(&dDiscountMin, "0.00");
strtodec(&dWholesaleMin, "1.00");
strtodec(&dCouponMin, "0.00");
strtodec(&dZero, "0.00");
strtodec(&dOneHalf, "0.50");
strtodec(&d9pct, "0.09");
strtodec(&dWholesaleMin, "1.00");
strtodec(&dHundred, "100.00");
strtodec(&dOne, "1.00");
init = 1;
}
if (nTabId != nLastId)
{
nLastId = -1;
for (i=0; i < MAX_LIMIT; i++)
{
if (nTabId == aPriceLimits[i].nId)
nLastId = i;
}
if (nLastId == -1)
INTERNAL("No pricing limits defined");
nQuantityMax = atoi(aPriceLimits[nLastId].szQuantity);
strtodec(&dDiscountMax, aPriceLimits[nLastId].szDiscount);
strtodec(&dMarkupMax, aPriceLimits[nLastId].szMarkUp);
strtodec(&dWholesaleMax, aPriceLimits[nLastId].szWholesale);
strtodec(&dCouponMax, aPriceLimits[nLastId].szCoupon);
}
switch(nTabId)
{
case SS_PRICING:
case CS_PRICING:
case WS_PRICING:
case S_PLINE_PRICING:
case S_CLIN_PRICING:
case S_WLIN_PRICING:
genrand_integer(&pPricing->quantity, DIST_UNIFORM, nQuantityMin, nQuantityMax, 0, nTabId);
itodec(&dQuantity, pPricing->quantity);
genrand_decimal(&pPricing->wholesale_cost, DIST_UNIFORM, &dWholesaleMin, &dWholesaleMax, NULL, nTabId);
/* ext_wholesale_cost = wholesale_cost * quantity */
decimal_t_op(&pPricing->ext_wholesale_cost, OP_MULT, &dQuantity, &pPricing->wholesale_cost);
/* list_price = wholesale_cost * (1 + markup) */
genrand_decimal(&dMarkup, DIST_UNIFORM, &dMarkupMin, &dMarkupMax, NULL, nTabId);
decimal_t_op(&dMarkup, OP_PLUS, &dMarkup, &dOne);
decimal_t_op(&pPricing->list_price, OP_MULT, &pPricing->wholesale_cost, &dMarkup);
/* sales_price = list_price * (1 - discount)*/
genrand_decimal(&dDiscount, DIST_UNIFORM, &dDiscountMin, &dDiscountMax, NULL, nTabId);
NegateDecimal(&dDiscount);
decimal_t_op(&pPricing->ext_discount_amt, OP_PLUS, &dDiscount, &dOne);
decimal_t_op(&pPricing->sales_price, OP_MULT, &pPricing->list_price, &pPricing->ext_discount_amt);
/* ext_list_price = list_price * quantity */
decimal_t_op(&pPricing->ext_list_price, OP_MULT, &pPricing->list_price, &dQuantity);
/* ext_sales_price = sales_price * quantity */
decimal_t_op(&pPricing->ext_sales_price, OP_MULT, &pPricing->sales_price, &dQuantity);
/* ext_discount_amt = ext_list_price - ext_sales_price */
decimal_t_op(&pPricing->ext_discount_amt, OP_MINUS, &pPricing->ext_list_price, &pPricing->ext_sales_price);
/* coupon_amt = ext_sales_price * coupon */
genrand_decimal(&dCoupon, DIST_UNIFORM, &dZero, &dOne, NULL, nTabId);
genrand_integer(&nCouponUsage, DIST_UNIFORM, 1, 100, 0, nTabId);
if (nCouponUsage <= 20) /* 20% of sales employ a coupon */
decimal_t_op(&pPricing->coupon_amt, OP_MULT, &pPricing->ext_sales_price, &dCoupon);
else
memcpy(&pPricing->coupon_amt, &dZero, sizeof(decimal_t));
/* net_paid = ext_sales_price - coupon_amt */
decimal_t_op(&pPricing->net_paid, OP_MINUS, &pPricing->ext_sales_price, &pPricing->coupon_amt);
/* shipping_cost = list_price * shipping */
genrand_decimal(&dShipping, DIST_UNIFORM, &dZero, &dOneHalf, NULL, nTabId);
decimal_t_op(&pPricing->ship_cost, OP_MULT, &pPricing->list_price, &dShipping);
/* ext_shipping_cost = shipping_cost * quantity */
decimal_t_op(&pPricing->ext_ship_cost, OP_MULT, &pPricing->ship_cost, &dQuantity);
/* net_paid_inc_ship = net_paid + ext_shipping_cost */
decimal_t_op(&pPricing->net_paid_inc_ship, OP_PLUS, &pPricing->net_paid, &pPricing->ext_ship_cost);
/* ext_tax = tax * net_paid */
genrand_decimal(&pPricing->tax_pct, DIST_UNIFORM, &dZero, &d9pct, NULL, nTabId);
decimal_t_op(&pPricing->ext_tax, OP_MULT, &pPricing->net_paid, &pPricing->tax_pct);
/* net_paid_inc_tax = net_paid + ext_tax */
decimal_t_op(&pPricing->net_paid_inc_tax, OP_PLUS, &pPricing->net_paid, &pPricing->ext_tax);
/* net_paid_inc_ship_tax = net_paid_inc_tax + ext_shipping_cost */
decimal_t_op(&pPricing->net_paid_inc_ship_tax, OP_PLUS, &pPricing->net_paid_inc_ship, &pPricing->ext_tax);
/* net_profit = net_paid - ext_wholesale_cost */
decimal_t_op(&pPricing->net_profit, OP_MINUS, &pPricing->net_paid, &pPricing->ext_wholesale_cost);
break;
case CR_PRICING:
case SR_PRICING:
case WR_PRICING:
/* quantity is determined before we are called */
/* ext_wholesale_cost = wholesale_cost * quantity */
itodec(&dQuantity, pPricing->quantity);
decimal_t_op(&pPricing->ext_wholesale_cost, OP_MULT, &dQuantity, &pPricing->wholesale_cost);
/* ext_list_price = list_price * quantity */
decimal_t_op(&pPricing->ext_list_price, OP_MULT, &pPricing->list_price, &dQuantity);
/* ext_sales_price = sales_price * quantity */
decimal_t_op(&pPricing->ext_sales_price, OP_MULT, &pPricing->sales_price, &dQuantity);
/* net_paid = ext_list_price (couppons don't effect returns) */
memcpy(&pPricing->net_paid, &pPricing->ext_sales_price, sizeof(decimal_t));
/* shipping_cost = list_price * shipping */
genrand_decimal(&dShipping, DIST_UNIFORM, &dZero, &dOneHalf, NULL, nTabId);
decimal_t_op(&pPricing->ship_cost, OP_MULT, &pPricing->list_price, &dShipping);
/* ext_shipping_cost = shipping_cost * quantity */
decimal_t_op(&pPricing->ext_ship_cost, OP_MULT, &pPricing->ship_cost, &dQuantity);
/* net_paid_inc_ship = net_paid + ext_shipping_cost */
decimal_t_op(&pPricing->net_paid_inc_ship, OP_PLUS, &pPricing->net_paid, &pPricing->ext_ship_cost);
/* ext_tax = tax * net_paid */
decimal_t_op(&pPricing->ext_tax, OP_MULT, &pPricing->net_paid, &pPricing->tax_pct);
/* net_paid_inc_tax = net_paid + ext_tax */
decimal_t_op(&pPricing->net_paid_inc_tax, OP_PLUS, &pPricing->net_paid, &pPricing->ext_tax);
/* net_paid_inc_ship_tax = net_paid_inc_tax + ext_shipping_cost */
decimal_t_op(&pPricing->net_paid_inc_ship_tax, OP_PLUS, &pPricing->net_paid_inc_ship, &pPricing->ext_tax);
/* net_profit = net_paid - ext_wholesale_cost */
decimal_t_op(&pPricing->net_profit, OP_MINUS, &pPricing->net_paid, &pPricing->ext_wholesale_cost);
/* see to it that the returned amounts add up to the total returned */
/* allocate some of return to cash */
genrand_integer(&nCashPct, DIST_UNIFORM, 0, 100, 0, nTabId);
itodec(&dTemp, nCashPct);
decimal_t_op(&pPricing->refunded_cash, OP_DIV, &dTemp, &dHundred);
decimal_t_op(&pPricing->refunded_cash, OP_MULT, &pPricing->refunded_cash, &pPricing->net_paid);
/* allocate some to reversed charges */
genrand_integer(&nCreditPct, DIST_UNIFORM, 1, 100, 0, nTabId);
itodec(&dTemp2, nCreditPct);
decimal_t_op(&dTemp, OP_DIV, &dTemp2, &dHundred);
decimal_t_op(&dTemp2, OP_MINUS, &pPricing->net_paid, &pPricing->refunded_cash);
decimal_t_op(&pPricing->reversed_charge, OP_MULT, &dTemp2, &dTemp);
/* the rest is store credit */
decimal_t_op(&pPricing->store_credit, OP_MINUS, &pPricing->net_paid, &pPricing->reversed_charge);
decimal_t_op(&pPricing->store_credit, OP_MINUS, &pPricing->store_credit, &pPricing->refunded_cash);
/* pick a fee for the return */
genrand_decimal(&pPricing->fee, DIST_UNIFORM, &dOneHalf, &dHundred, &dZero, nTabId);
/* and calculate the net effect */
decimal_t_op(&pPricing->net_loss, OP_MINUS, &pPricing->net_paid_inc_ship_tax, &pPricing->store_credit);
decimal_t_op(&pPricing->net_loss, OP_MINUS, &pPricing->net_loss, &pPricing->refunded_cash);
decimal_t_op(&pPricing->net_loss, OP_MINUS, &pPricing->net_loss, &pPricing->reversed_charge);
decimal_t_op(&pPricing->net_loss, OP_PLUS, &pPricing->net_loss, &pPricing->fee);
break;
}
return;
}
/**
* @brief Write formatted data to string
* @param str Pointer to a buffer where the resulting C-string is stored. The buffer should be large enough to contain the resulting string.
* @param format C string that contains a format string that follows the same specifications as format in printf
* @param ... Depending on the format string, the function may expect a sequence of additional arguments, each containing a value to be used to replace a format specifier in the format string (or a pointer to a storage location, for n). There should be at least as many of these arguments as the number of values specified in the format specifiers. Additional arguments are ignored by the function.
* @returns On success, the total number of characters written is returned. This count does not include the additional null-character automatically appended at the end of the string.
On failure, a negative number is returned.
*
* Composes a string with the same text that would be printed if format was used on printf, but instead of being printed, the content is stored as a C string in the buffer pointed by s. The size of the buffer should be large enough to contain the entire resulting string. A terminating null character is automatically appended after the content. After the format parameter, the function expects at least as many additional arguments as needed for format.
*/
int sprintf ( char * str, const char * format, ... )
{
/*
* %[flags][width][.precision][length]specifier
*
* Right now no optional arguments are supported yet (i.e. specifier only)
*/
char strbufmem[17];
int int_val;
unsigned int uint_val;
char char_val;
char * str_val;
int * intp_val;
va_list vl;
char * str_start = str;
char* strbuf = strbufmem;
va_start(vl, format);
while (*format != '\0')
{
if (*format == '%')
{
format++;
switch(*format)
{
case 'd':
case 'i':
int_val = va_arg(vl,int);
itodec(int_val, str);
while (*str != '\0') { str++;}
break;
case 'u':
uint_val = va_arg(vl,unsigned int);
uitodec(uint_val, str);
while (*str != '\0') { str++;}
break;
case 'o':
uint_val = va_arg(vl,unsigned int);
itooct(uint_val, str);
while (*str != '\0') { str++;}
break;
case 'x':
uint_val = va_arg(vl,unsigned int);
itohex(uint_val, str, 0);
while (*str != '\0') { str++;}
break;
case 'X':
case 'p': // treat the pointer '%p' as an uint (which is legal on the DCPU)
uint_val = va_arg(vl,unsigned int);
itohex(uint_val, str, 1);
while (*str != '\0') { str++;}
break;
case 'f':
case 'F':
case 'e':
case 'E':
case 'g':
case 'G':
case 'a':
case 'A':
// TODO when floats are implemented
// for now just ignore
uint_val = va_arg(vl,unsigned int);
break;
case 'c':
char_val = va_arg(vl,char);
*(str++) = char_val;
break;
case 's':
str_val = va_arg(vl,char*);
while(*str_val != '\0')
*(str++) = *(str_val++);
break;
case 'n':
intp_val = va_arg(vl,int*);
// TODO needs casting :)
//*intp_val = str - str_start;
break;
case '%':
*(str++) = '%';
break;
default:
;
// dont do anything
}
format++;
}
else
{
