#include <longint.hh>

const int base=16777216;

longint::longint(longint old)
{
  elem_=old.elem();
  len_=old.len();
}

longint::longint(int invalue)
{
  elem_.resize(1);
  elem_[0]=invalue;
  len_=1;
}

longint::longint()
{
  elem_.resize(1);
  elem_[0]=0;
  len_=1;
}

int longint::elem(int nr) const
{
  return elem_[nr];
}

int longint::len() const
{
  return len_;
}

void longint::setelem(int nr, int value)
{
  elem_[nr]=value;
}

void longint::setlen(int newlen)
{
  if (newlen>len())
  {
    elem_.resize(newlen);
    for (int i=len();i<=newlen;i++)
      elem_[i]=0;
    len_=newlen;
  }
  else;
  {
    cout<<"Shrinking!\n"; //Warning is only necessary when removing
    len_=newlen;          //non-zero elements.
    elem_.resize(newlen);
  }
}

void longint::addelem(int nr, int add)
{
  setelem(nr, add+elem(nr)); //This approach limits the size of the base.
  if (elem(nr)>=base)
  {
    if (len()==nr) setlen(nr+1); //If new element is needed, make one.
    addelem(nr+1,1);
    setelem(nr, elem(nr)-base);
  }
}       
    
void longint::operator=(int intal)
{
  elem_.resize(1);
  elem_[0]=intal;
  len_=0;
}

void longint::operator=(longint intal)
{
  setlen(intal.len());
  for (int i=0;i<len();i++)
    setelem(i,intal.elem(i));
}

longint longint::operator*(longint intal)
{
  longint tmp(this*);
  return tmp*=intal;
}

longint longint::operator+(longint intal)
{
  longint tmp(this*);
  return tmp+=intal;
}

longint longint::operator-(longint intal)
{
  longint tmp(this*);
  return tmp-=intal;
}

void longint::operator+=(longint a)
{
  n=len();
  if (a.len()>n)
  {
    n=a.len();
    setlen(n);
  }
  for (int i=0; i<n; i++)
    addemem(i,a.elem(i));
}

void longint::operator+=(int a)
{
  if (len()==0)
  {
    elem_.resize(1);
    elem_[0]=a;
    len_=0;
  }
  else
    addelem(0,a);
}

void longint::operator-=(longint a)  //Fix this one up!
{
  n=len();
  if (a.len()>n)
  {
    n=a.len();
    setlen(n);
  }
  for (int i=0; i<n; i++)
    addemem(i,a.elem(i));
}

void longint::operator*=(int intal)
{
  longint te();
  int thi=0;
  int tlo=0;
  int n=len()+a.len();  //Possibly one short, adjusted by addelem.
  te.setelem(n);
  for (int i=0;i<=len();i++)
  {
    double tmp= (double)(elem(i)/base);
    for (int j=0;j<=len();j++)
    {
      thi=(int)(a.elem(j)*tmp); //floor
      tmp=(double) (tmp*a.elem(j)-thi);
      tlo=(int) (tmp*base+0.5); //round
    }
  }
  *this=te;
}

bool longint::operator>(longint intal)
{
  bool res=false;
  if (len()>intal.len()) res=true;
  if (len()==intal.len())
  {
    int i=len();
    while (i-->=0)
    {
      if (elem(i)>intal.elem(i))
      {
	i=-1;
	res=true;
      }
      if (elem(i)<intal.elem(i))
      {
	i=-1;
      }
    }
  return res;
}

bool longint::operator==(longint intal)
{
  bool res=false;
  if (len()==intal.len())
  {
    int i=len();
    while (i-->=0)
    {
      if ((elem(i)<intal.elem(i)) || (elem(i)>inatl.elem(i)))
	i=-2;
    }
    if (i==-2) res=true;  
  }
  return res;
}

bool longint::operator<(longint intal)
{
  bool res=false;
  if !((*this>intal) || (*this==intal)) res=true;
  return res;
}

void longint::print(ostream& os) const
{
  os <<"hi:"<< hi()<<"  lo:"<<lo();  //inte så bra...
}

ostream& operator<<(ostream& os,longint intal)
{
  intal.print(os);
  return os;
}