numeric.java

FuncPlotter is a combined Java application and applet for displaying two-dimensional plots of explic

/*====================================================================*\

Numeric.java

Numeric utility methods class.

------------------------------------------------------------------------

This file is part of FuncPlotter, a combined Java application and applet
for plotting explicit functions in one variable.
Copyright 2005-2007 Andy Morgan-Richards.

FuncPlotter 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 3 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, see <http://www.gnu.org/licenses/>.

\*====================================================================*/


// PACKAGE


package util;

//----------------------------------------------------------------------


// IMPORTS


import java.math.BigInteger;

import java.util.Arrays;

//----------------------------------------------------------------------


// NUMERIC UTILITY METHODS CLASS


public class Numeric
{

////////////////////////////////////////////////////////////////////////
//  Constants
////////////////////////////////////////////////////////////////////////

    public static final String  HEX_DIGITS_UPPER    = "0123456789ABCDEF";
    public static final String  HEX_DIGITS_LOWER    = "0123456789abcdef";

////////////////////////////////////////////////////////////////////////
//  Constructors
////////////////////////////////////////////////////////////////////////

    private Numeric( )
    {
    }

    //------------------------------------------------------------------

////////////////////////////////////////////////////////////////////////
//  Class methods
////////////////////////////////////////////////////////////////////////

    public static int bytesToIntBE( byte[] data,
                                    int    offset,
                                    int    length )
    {
        int endOffset = offset + length;
        int value = data[offset];
        while ( ++offset < endOffset )
        {
            value <<= 8;
            value |= data[offset] & 0xFF;
        }
        return value;
    }

    //------------------------------------------------------------------

    public static int bytesToIntLE( byte[] data,
                                    int    offset,
                                    int    length )
    {
        int i = offset + length;
        int value = data[--i];
        while ( --i >= offset )
        {
            value <<= 8;
            value |= data[i] & 0xFF;
        }
        return value;
    }

    //------------------------------------------------------------------

    public static void intToBytesBE( int    value,
                                     byte[] buffer,
                                     int    offset,
                                     int    length )
    {
        for ( int i = offset + length - 1; i >= offset; --i )
        {
            buffer[i] = (byte)value;
            value >>>= 8;
        }
    }

    //------------------------------------------------------------------

    public static void intToBytesLE( int    value,
                                     byte[] buffer,
                                     int    offset,
                                     int    length )
    {
        int endOffset = offset + length;
        for ( int i = offset; i < endOffset; ++i )
        {
            buffer[i] = (byte)value;
            value >>>= 8;
        }
    }

    //------------------------------------------------------------------

    public static long bytesToLongBE( byte[] data,
                                      int    offset,
                                      int    length )
    {
        int endOffset = offset + length;
        long value = data[offset];
        while ( ++offset < endOffset )
        {
            value <<= 8;
            value |= data[offset] & 0xFF;
        }
        return value;
    }

    //------------------------------------------------------------------

    public static long bytesToLongLE( byte[] data,
                                      int    offset,
                                      int    length )
    {
        int i = offset + length;
        long value = data[--i];
        while ( --i >= offset )
        {
            value <<= 8;
            value |= data[i] & 0xFF;
        }
        return value;
    }

    //------------------------------------------------------------------

    public static void longToBytesBE( long   value,
                                      byte[] buffer,
                                      int    offset,
                                      int    length )
    {
        for ( int i = offset + length - 1; i >= offset; --i )
        {
            buffer[i] = (byte)value;
            value >>>= 8;
        }
    }

    //------------------------------------------------------------------

    public static void longToBytesLE( long   value,
                                      byte[] buffer,
                                      int    offset,
                                      int    length )
    {
        int endOffset = offset + length;
        for ( int i = offset; i < endOffset; ++i )
        {
            buffer[i] = (byte)value;
            value >>>= 8;
        }
    }

    //------------------------------------------------------------------

    public static String byteToHexString( int value )
    {
        char[] digits = { hexDigits.charAt( (value >> 4) & 0x0F ), hexDigits.charAt( value & 0x0F ) };
        return new String( digits );
    }

    //------------------------------------------------------------------

    public static String uIntToBinString( int  value,
                                          int  numDigits,
                                          char padChar )
    {
        char[] buffer = new char[numDigits];
        Arrays.fill( buffer, padChar );
        int i = numDigits;
        while ( --i >= 0 )
        {
            buffer[i] = (char)((value & 1) + '0');
            value >>>= 1;
            if ( value == 0 )
                break;
        }
        return new String( buffer );
    }

    //------------------------------------------------------------------

    public static String uLongToBinString( long value,
                                           int  numDigits,
                                           char padChar )
    {
        char[] buffer = new char[numDigits];
        Arrays.fill( buffer, padChar );
        int i = numDigits;
        while ( --i >= 0 )
        {
            buffer[i] = (char)((value & 1) + '0');
            value >>>= 1;
            if ( value == 0 )
                break;
        }
        return new String( buffer );
    }

    //------------------------------------------------------------------

    public static String uIntToDecString( int  value,
                                          int  numDigits,
                                          char padChar )
    {
        char[] buffer = new char[numDigits];
        Arrays.fill( buffer, padChar );
        int i = numDigits;
        while ( --i >= 0 )
        {
            buffer[i] = (char)(value % 10 + '0');
            value /= 10;
            if ( value == 0 )
                break;
        }
        return new String( buffer );
    }

    //------------------------------------------------------------------

    public static String uLongToDecString( long value )
    {
        byte[] buffer = new byte[8];
        longToBytesBE( value, buffer, 0, buffer.length );
        return new BigInteger( 1, buffer ).toString( );
    }

    //------------------------------------------------------------------

    public static String uLongToDecString( long value,
                                           int  numDigits,
                                           char padChar )
    {
        char[] buffer = new char[numDigits];
        Arrays.fill( buffer, padChar );
        int i = numDigits;
        while ( --i >= 0 )
        {
            buffer[i] = (char)(value % 10 + '0');
            value /= 10;
            if ( value == 0 )
                break;
        }
        return new String( buffer );
    }

    //------------------------------------------------------------------

    public static void setHexUpper( )
    {
        hexDigits = HEX_DIGITS_UPPER;
    }

    //------------------------------------------------------------------

    public static void setHexLower( )
    {
        hexDigits = HEX_DIGITS_LOWER;
    }

    //------------------------------------------------------------------

    public static String uIntToHexString( int  value,
                                          int  numDigits,
                                          char padChar )
    {
        char[] buffer = new char[numDigits];
        Arrays.fill( buffer, padChar );
        int i = numDigits;
        while ( --i >= 0 )
        {
            buffer[i] = hexDigits.charAt( value & 0x0F );
            value >>>= 4;
            if ( value == 0 )
                break;
        }
        return new String( buffer );
    }

    //------------------------------------------------------------------

    public static String uLongToHexString( long value,
                                           int  numDigits,
                                           char padChar )
    {
        char[] buffer = new char[numDigits];
        Arrays.fill( buffer, padChar );
        int i = numDigits;
        while ( --i >= 0 )
        {
            buffer[i] = hexDigits.charAt( (int)value & 0x0F );
            value >>>= 4;
            if ( value == 0 )
                break;
        }
        return new String( buffer );
    }

    //------------------------------------------------------------------

    public static int parseUIntDec( String str )
        throws NumberFormatException
    {
        BigInteger value = new BigInteger( str );
        if ( (value.signum( ) < 0) || (value.bitLength( ) > 32) )
            throw new NumberFormatException( );
        return value.intValue( );
    }

    //------------------------------------------------------------------

    public static int parseUIntHex( String str )
        throws NumberFormatException
    {
        int length = str.length( );
        if ( (length < 1) || (length > 8) )
            throw new NumberFormatException( );

        int value = 0;
        for ( int i = 0; i < length; ++i )
        {
            char ch = Character.toUpperCase( str.charAt( i ) );
            int digitValue = HEX_DIGITS_UPPER.indexOf( ch );
            if ( digitValue < 0 )
                throw new NumberFormatException( );
            value <<= 4;
            value |= digitValue;
        }
        return value;
    }

    //------------------------------------------------------------------

    public static long parseULongDec( String str )
        throws NumberFormatException
    {
        BigInteger value = new BigInteger( str );
        if ( (value.signum( ) < 0) || (value.bitLength( ) > 64) )
            throw new NumberFormatException( );
        return value.longValue( );
    }

    //------------------------------------------------------------------

    public static long parseULongHex( String str )
        throws NumberFormatException
    {
        int length = str.length( );
        if ( (length < 1) || (length > 16) )
            throw new NumberFormatException( );

        long value = 0;
        for ( int i = 0; i < length; ++i )
        {
            char ch = Character.toUpperCase( str.charAt( i ) );
            int digitValue = HEX_DIGITS_UPPER.indexOf( ch );
            if ( digitValue < 0 )
                throw new NumberFormatException( );
            value <<= 4;
            value |= digitValue;
        }
        return value;
    }

    //------------------------------------------------------------------

////////////////////////////////////////////////////////////////////////
//  Class variables
////////////////////////////////////////////////////////////////////////

    private static  String  hexDigits   = HEX_DIGITS_UPPER;

}

//----------------------------------------------------------------------