hamaro_bcd.c

QPSK Tuner details, for conexant chipset.

  HAMARO_BCDNO  result2;

  sign = -1;
  if (bcd->sign[0] == bcdmultby->sign[0])  sign = 0;

  /* test for mult by zero */
  if (HAMARO_BCD_zero(bcd) == True)  return;
  if (HAMARO_BCD_zero(bcdmultby) == True)
  {
    HAMARO_BCD_clear(bcd);
    return;
  }
  
  /* mult two bcd numbers */
  HAMARO_BCD_move_bcd(&temp_bcd,bcdmultby);
  HAMARO_BCD_clear(&result2);

  cnt = 0;
  while(HAMARO_BCD_zero(&temp_bcd) == False)
  {
    digit = temp_bcd.digits[HAMARO_MAX_BCDNO-1];
    _HAMARO_BCD_div_ten(&temp_bcd);

    if (digit != 0)
    {
      HAMARO_BCD_move_bcd(&result,bcd);
      _HAMARO_BCD_mult_bcd_ones(&result,digit);
      if (cnt != 0)  for (i = 0 ; i < cnt ; i++)  _HAMARO_BCD_mult_ten(&result);
      HAMARO_BCD_add_bcd(&result2,&result);
    }
    cnt++;
  }

  /* place computed results and sign back into caller storage */
  HAMARO_BCD_move_bcd(bcd,&result2);
  bcd->sign[0] = (signed char)(sign == -1 ? '-' : ' ');

  return;

}  /* HAMARO_BCD_mult_bcd() */


/*******************************************************************************************************/
/* HAMARO_BCD_div_bcd() */
/*******************************************************************************************************/
void   HAMARO_BCD_div_bcd(                    /* function to divide a HAMARO_BCDNO by a HAMARO_BCDNO */
HAMARO_BCDNO  *numer,                         /* pointer to bcd struct */
HAMARO_BCDNO  *denom)                         /* pointer to bcd struct */
{
  int    i;
  int    lsd;

  int    done;
  int    step_numer = 0;
  int    len_denom = 0;

  HAMARO_BCDNO  _numer;
  HAMARO_BCDNO  *__numer;
  HAMARO_BCDNO  _remainder;
  HAMARO_BCDNO  *remainder;
  
  HAMARO_BCDNO  _result;
  HAMARO_BCDNO  *result;

  __numer = &_numer;
  result = &_result;
  remainder = &_remainder;

  HAMARO_BCD_move_bcd(&_numer,HAMARO_BCD_abs(numer));
  HAMARO_BCD_clear(result);

  /* test if numbers can be divided */
  if (HAMARO_BCD_compare(&_numer,HAMARO_BCD_abs(denom)) <= 0)  HAMARO_BCD_clear(numer);
  else
  {
    /* find the number of digits in denom */
    for (len_denom = 0 ; len_denom < HAMARO_MAX_BCDNO ; len_denom++)
    {
      if (denom->digits[len_denom] != CNULL)  break;
    }
    len_denom = (HAMARO_MAX_BCDNO) - len_denom;

    /* pull-out at-least len_denom digits from numerator */
    for (step_numer = 0 ; step_numer < HAMARO_MAX_BCDNO ; step_numer++)
    {
      if (numer->digits[step_numer] != CNULL)  break;
    }
    
    HAMARO_BCD_clear(&_numer);
    for (i = 0 ; i < len_denom ; i++)
    {
      _HAMARO_BCD_mult_ten(&_numer);
      _HAMARO_BCD_lsd(__numer) = numer->digits[step_numer];
      step_numer++;
    }

    /* subtract denom from nom, until too little remaining */
    done = False;
    while (done == False)
    {
      _HAMARO_BCD_mult_ten(result);
      while (HAMARO_BCD_compare(&_numer,HAMARO_BCD_abs(denom)) > 0)
      {
        HAMARO_BCD_incr(result);
        HAMARO_BCD_subt_bcd(&_numer,HAMARO_BCD_abs(denom));
      }

      if (step_numer >= HAMARO_MAX_BCDNO)  break;

      /* save the remainder */
      HAMARO_BCD_move_bcd(remainder,&_numer);
      HAMARO_BCD_clear(&_numer);

      /* add remaining numer digits to end-of-result */
      do{
        _HAMARO_BCD_mult_ten(remainder);
        lsd = numer->digits[step_numer];
        _HAMARO_BCD_lsd(remainder) = (signed char)lsd;

        step_numer++;
        if (step_numer >= HAMARO_MAX_BCDNO)  break;
        if (HAMARO_BCD_compare(remainder,HAMARO_BCD_abs(denom)) >= 0)  break;
        else  _HAMARO_BCD_mult_ten(result); 
      } while (done == False && step_numer < HAMARO_MAX_BCDNO);
      HAMARO_BCD_move_bcd(&_numer,remainder);
    }
  }
  
  HAMARO_BCD_move_bcd(numer,result);
  return;

}  /* HAMARO_BCD_div_bcd() */


/*******************************************************************************************************/
/* HAMARO_BCD_div() */
/*******************************************************************************************************/
void           HAMARO_BCD_div(                /* function to divide a HAMARO_BCDNO by a binary number */
HAMARO_BCDNO          *numer,                 /* pointer to bcd struct */
unsigned long  denom)                  /* binary demon */
{
  HAMARO_BCDNO  _denom;

  if (denom != 0UL)
  {
    /* convert denom to bcd, then divide */
    HAMARO_BCD_set(&_denom,denom);
    HAMARO_BCD_div_bcd(numer,&_denom);
    return;
  }

  /* if div by zero would have occurred, set result to 0, return */
  HAMARO_BCD_set(numer,0L);
  return;

}  /* HAMARO_BCD_div() */ 


/*******************************************************************************************************/
/* HAMARO_BCD_out() */
/*******************************************************************************************************/
unsigned long  HAMARO_BCD_out(                /* function to convert bcd number in HAMARO_BCDNO struct to a long */
HAMARO_BCDNO          *bcd)                   /* pointer to bcd struct */
{
  int    i;

  unsigned long  ulTemp = HAMARO_M*HAMARO_M*HAMARO_M;
  unsigned long  rtn = 0UL;

  /* unsigned long will only hold several max 4+ billion, start at billions, and roll BCD out to unsigned long */
  for (i = (HAMARO_MAX_BCDNO-1)-9 ; i < HAMARO_MAX_BCDNO ; i++)
  {
    rtn += ((unsigned long)bcd->digits[i]*ulTemp);
    ulTemp = ulTemp/10UL;
  }

  return(rtn);

}  /* HAMARO_BCD_out() */


/*******************************************************************************************************/
/* HAMARO_BCD_move_bcd() */
/*******************************************************************************************************/
void   HAMARO_BCD_move_bcd(                   /* function to move HAMARO_BCDNO source to HAMARO_BCDNO dest */
HAMARO_BCDNO  *bcd,                           /* pointer to bcd struct */
HAMARO_BCDNO  *bcdsource)                     /* pointer to bcd struct */
{
  int  idx;

  bcd->sign[0] = bcdsource->sign[0];
  for (idx = 0 ; idx < HAMARO_MAX_BCDNO ; idx++)
  {
    bcd->digits[idx] = bcdsource->digits[idx];
  }
  
  return;

}  /* HAMARO_BCD_move_bcd() */  


/*******************************************************************************************************/
/* HAMARO_BCD_zero() */
/*******************************************************************************************************/
BOOL  HAMARO_BCD_zero(                        /* function to set a HAMARO_BCDNO struct to zero */
HAMARO_BCDNO  *bcd)                           /* pointer to bcd struct */
{
  int  idx;

  /* test bcd for zero */
  for (idx = HAMARO_MAX_BCDNO-1 ; idx > 0 ; idx--)  if (bcd->digits[idx] != CNULL)  return(False);

  /* bcd is equal to zero */
  return(True);

}  /* HAMARO_BCD_zero() */


/*******************************************************************************************************/
/* HAMARO_BCD_compare() */
/*******************************************************************************************************/
int    HAMARO_BCD_compare(                    /* function to compare two bcd numbers.  returns 0 if equal */
HAMARO_BCDNO  *bcd,                           /* pointer to bcd struct */
HAMARO_BCDNO  *bcd2)                          /* pointer to bcd struct */
{
  int  idx;

  /* test sign for quick result bcd sig == +, return 1 else -1 */
  if (HAMARO_BCD_sign(bcd) != HAMARO_BCD_sign(bcd2))  return(HAMARO_BCD_sign(bcd));

  /* compare two bcd numbers, returns positive no., if bcd is higher-than bcd2 */
  for (idx = 0 ; idx < HAMARO_MAX_BCDNO ; idx++)
  {
    if (bcd->digits[idx] != bcd2->digits[idx] != CNULL)  
      return((int)(bcd->digits[idx]-bcd2->digits[idx]));
  }

  /* bcd is equal to bcd2 */
  return(0);

}  /* HAMARO_BCD_compare() */


/*******************************************************************************************************/
/* _HAMARO_BCD_div_ten() */
/*******************************************************************************************************/
void   _HAMARO_BCD_div_ten(                   /* function to perfrom a bcd div by ten (kill lowest digit) */
HAMARO_BCDNO  *bcd)                           /* pointer to bcd struct */
{
  int  idx;

  /* shift bcd rt by one BCD place */
  for (idx = HAMARO_MAX_BCDNO-1 ; idx > 1 ; idx--)  bcd->digits[idx] = bcd->digits[idx-1];
  bcd->digits[0] = CNULL;
  return;

}  /* _HAMARO_BCD_div_ten() */


/*******************************************************************************************************/
/* HAMARO_BCD_abs() */
/*******************************************************************************************************/
HAMARO_BCDNO  *HAMARO_BCD_abs(                       /* function to perform abs() functionality on a HAMARO_BCDNO number */
HAMARO_BCDNO  *bcd)                           /* pointer to bcd struct */
{
  static HAMARO_BCDNO  bcd_abs;

  HAMARO_BCD_move_bcd(&bcd_abs,bcd);
  HAMARO_BCD_setsign((&bcd_abs),1);  
  return(&bcd_abs);

}  /* HAMARO_BCD_abs() */


/*******************************************************************************************************/
/* _HAMARO_BCD_mult_ten() */
/*******************************************************************************************************/
void   _HAMARO_BCD_mult_ten(                  /* function to multiply a HAMARO_BCDNO by ten (performs a bcd <<1 op.) */
HAMARO_BCDNO  *bcd)                           /* pointer to bcd struct */
{
  int  idx;

  /* shift bcd lt by one BCD place */
  for (idx = 0 ; idx < HAMARO_MAX_BCDNO-1 ; idx++)  bcd->digits[idx] = bcd->digits[idx+1];
  bcd->digits[HAMARO_MAX_BCDNO-1] = 0;
  return;

}  /* _HAMARO_BCD_mult_ten() */

/*******************************************************************************************************/
/*******************************************************************************************************/
/*******************************************************************************************************/
/* CR 9509 : Add an extra newline */