/*
    * To change this template, choose Tools | Templates
    * and open the template in the editor.
    */
   
   package net.sf.zel.nr;
   
   import java.math.BigDecimal;
   import java.math.BigInteger;
  import javax.annotation.concurrent.Immutable;
  import net.sf.zel.math.ExtendedMathContext;
  
  /**
   * THis class currently is implemented via the gnu mp library,
   * for corect rounding a reimplementation using mpfr will be done later
   * THis class is very good if better precision math is needed
   *
   * @author zoly
   */
  
  @Immutable
  public final class OperableGNUBigFloat extends OperableGNUNumber
  {
  
      /**
       * The pointer is a 64 bit pointer to support 64 bit jvms
       */
      private transient long pointer;
  
      private final int precision;
  
      public static final OperableGNUBigFloat ZERO = new OperableGNUBigFloat("0");
      public static final OperableGNUBigFloat ONE = new OperableGNUBigFloat("1");
  
      public OperableGNUBigFloat(final String number)
      {
          precision = ExtendedMathContext.CURRENT_EXTENDED_MATH_CONTEXT.get().getMathContext().getPrecision();
          pointer = allocateGMP(number, precision);
      }
  
      public OperableGNUBigFloat(final byte[] bytes)
      {
          precision = ExtendedMathContext.CURRENT_EXTENDED_MATH_CONTEXT.get().getMathContext().getPrecision();
          pointer = allocateGMP(toString(bytes, 10), precision);
      }
  
      private OperableGNUBigFloat(final long pointer)
      {
          this.pointer = pointer;
          precision = ExtendedMathContext.CURRENT_EXTENDED_MATH_CONTEXT.get().getMathContext().getPrecision();
      }
  
      @Override
      protected void finalize() throws Throwable
      {
          try
          {
              super.finalize();
          }
          finally
          {
              freeGMP(pointer);
          }
      }
  
      private static native long allocateGMP(String number, int precision);
  
      private static native void freeGMP(long pointer);
  
      private static native String toString(byte number[], int base);
  
      private static native String toString(long pointer, int base, int precision);
  
      private static native long add(long a, long b);
  
      private static native long substract(long a, long b);
  
      public static native long multiply(long a, long b);
  
      public static native long divide(long a, long b);
  
  
      @Override
      public OperableNumber add(final OperableNumber addend)
      {
          return new OperableGNUBigFloat(add(this.pointer, addend.gnuBigFloatValue().pointer));
      }
  
      @Override
      public OperableNumber subtract(final OperableNumber subtrahend)
      {
          return new OperableGNUBigFloat(substract(this.pointer, subtrahend.gnuBigFloatValue().pointer));
      }
  
      @Override
      public OperableNumber multiply(final OperableNumber multiplier)
      {
          return new OperableGNUBigFloat(multiply(this.pointer, multiplier.gnuBigFloatValue().pointer));
      }
 
     @Override
     public OperableNumber divide(final OperableNumber divisor)
     {
         return new OperableGNUBigFloat(divide(this.pointer, divisor.gnuBigFloatValue().pointer));
     }
 
     @Override
     public OperableNumber mod(final OperableNumber divisor)
     {
        throw new UnsupportedOperationException("Modulus is a invalid operation on decimals");
     }
 
     @Override
     public Type getType()
     {
         return OperableNumber.Type.REAL;
     }
 
     @Override
     public BigDecimal bigDecimalValue()
     {
         return new BigDecimal(toString());
     }
 
     @Override
     public BigInteger bigIntegerValue()
     {
         return new BigInteger(toString());
 
     }
 
     @Override
     public OperableGNUBigInteger gnuBigIntegerValue()
     {
         return new OperableGNUBigInteger(toString());
     }
 
     @Override
     public int intValue()
     {
         return Integer.parseInt(toString());
     }
 
     @Override
     public long longValue()
     {
         return Long.parseLong(toString());
     }
 
     @Override
     public float floatValue()
     {
         return Float.parseFloat(toString());
     }
 
     @Override
     public double doubleValue()
     {
         return Double.parseDouble(toString());
     }
 
     @Override
     public String toString()
     {
         return toString(this.pointer, 10, ExtendedMathContext.CURRENT_EXTENDED_MATH_CONTEXT.get().getMathContext().getPrecision());
     }
 
     public int compareTo(Object o)
     {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public ExtendedNumber zero()
     {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public OperableGNUBigFloat gnuBigFloatValue()
     {
         return this;
     }
 
     @Override
     public int getPrecision()
     {
         return precision;
     }
 
     @Override
     public OperableNumber create(final String val)
     {
         if ("0.0".equals(val))
             return ZERO;
         else
             return new OperableGNUBigFloat(val);
     }
 
     @Override
     public ExtendedNumber one()
     {
         return ONE;
     }
 
     @Override
     public OperableNumber convert(ExtendedNumber val)
     {
         return new OperableGNUBigFloat(val.toString());
     }
 
 
 }