/*********************************************
*
* Copyright 2004 by Sean Conner.  All Rights Reserved.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*
* Comments, questions and criticisms can be sent to: sean@conman.org
*
**********************************************/

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <float.h>
#include <math.h>

/*************************************************************************
*
* This is the number of bytes to set aside to hold the result.  The number
* of digits of the final result will be approximately 2.3 times this number.
*
************************************************************************/

#define E		(24*1024)

/************************************************************************
* 
* Various constants used in the program
*
*************************************************************************/

#define LOGPI2div2	(double)0.399089934
#define LN10		(double)2.302585093
#define LOG256		(double)2.408239965

#ifndef FALSE
#  define FALSE		0
#endif

#ifndef TRUE
#  define TRUE		!FALSE
#endif

/************************************************************************/

unsigned char *e;
unsigned long  esize = E;

/***********************************************************************/

int			main		(int,char *[]);
static void		calc_e		(unsigned short);
static void		div_e		(unsigned short);
static double		num_digits	(unsigned long);
static unsigned long 	calc_n		(double);
static void		print_e		(double);
static unsigned short	e10		(void);

/************************************************************************/

int main(int argc,char *argv[])
{
  unsigned long n;
  double        nd;
  
  if (argc > 1)
  {
    esize = strtol(argv[1],NULL,10);
  }
  
  nd = num_digits(esize);
  n  = calc_n(nd);
  
  printf("bytes: %lu nd: %f mag: 10**%lu\n",esize,nd,n);
  
  if (n == 0) 
  {
    fprintf(stderr,"Can not calculate\n");
    return(1);
  }
  
  e = malloc(esize * sizeof(unsigned char));
  if (e == NULL)
  {
    fprintf(stderr,"no memory\n");
    return(1);
  }
  
  calc_e(n);
  print_e(nd);

  return(0);
}

/**********************************************************************/

static void calc_e(unsigned short nmax)
{
  unsigned short n;
    
  for (n = nmax ; n > 1 ; n--)
  {
    div_e(n);
  }  
}
    
/***********************************************************************/

#define inline()	{					\
			  ter += ter;				\
			  te  += te;				\
			  a   += a;				\
			  if (te & 0x0100) a |= 0x0001;		\
			  if (a >= n)				\
			  {					\
			    a -= n;				\
			    ter |= 0x01;			\
			  }					\
			}
			  
static void div_e(unsigned short n)
{
  unsigned short a;
  unsigned short te;
  unsigned char  ter;
  int            i;
  
  a = 1;
  
  for (i = 0 ; i < esize ; i++)
  {
    ter  = 0;
    te   = e[i];
    
    inline();
    inline();
    inline();
    inline();
    inline();
    inline();
    inline();
    inline();
    
    e[i] = ter;
  }
}

/*******************************************************************/
  
static double num_digits(unsigned long e)
{
  return((double)e * LOG256);
}

/************************************************************************/

static unsigned long calc_n(double digits)
{
  unsigned long i;
  double        n;
  double        magnb;
   
  for(i = 1 , n = 1.0 ; i < ULONG_MAX ; i++ , n+= 1.0)
  {
    magnb = LOGPI2div2 + (log10(n) * (n + 0.5)) - ( n / LN10) ;
    if (magnb > digits)
    {
      return(i);
    }
  }
  return(0);
}

/*************************************************************************
*
* The print module
*
*************************************************************************/

static void print_e(double nd)
{
  int            page  = 0;
  int            group = 0;
  int            digit = 0;
  int            even  = TRUE;         
  unsigned short p;
  
  for ( ; nd > 0 ; nd -= 1.0)
  {
    if (digit == 5)
    {
      putchar(' ');
      digit = 0;
      group++;
    }
    
    if (group == 12)
    {
      putchar('\n');
      group = 0;
      page++;
    }
    
    if (page == 60)
    {
      putchar('\n');
      putchar('\n');
      page = 0;
    }
    
    digit++;
    
    if (even) 
    {
      p = e10();
      putchar((p/10) + '0');
      even = FALSE;
    }
    else
    {
      putchar((p % 10) + '0');
      even = TRUE;
    }
  }
  putchar('\n');
}
            
/**********************************************************************/
    
static unsigned short e10(void)
{
  unsigned short p;
  int            i;
  unsigned char  c;

  c = 0;
      
  for (i = esize-1 ; i >= 0 ; i--)
  {
    p    = (e[i] * 100) + c;
    e[i] = p & 0xff;
    c    = (p >> 8) & 0xff;
  }
  p = c;
  
  return(p);
}

/*************************************************************************/