Long.avt

Переключить прокрутку окна
Загрузить этот исходный код

/*
    Исходный код среды исполнения ПВТ-ОО.

    Этот исходный код является частью проекта ПВТ-ОО.

    Copyright © 2021 Малик Разработчик

    Это свободная программа: вы можете перераспространять её и/или
    изменять её на условиях Меньшей Стандартной общественной лицензии GNU в том виде,
    в каком она была опубликована Фондом свободного программного обеспечения;
    либо версии 3 лицензии, либо (по вашему выбору) любой более поздней версии.

    Эта программа распространяется в надежде, что она может быть полезна,
    но БЕЗО ВСЯКИХ ГАРАНТИЙ; даже без неявной гарантии ТОВАРНОГО ВИДА
    или ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЁННЫХ ЦЕЛЕЙ. Подробнее см. в Меньшей Стандартной
    общественной лицензии GNU.

    Вы должны были получить копию Меньшей Стандартной общественной лицензии GNU
    вместе с этой программой. Если это не так, см.
    <http://www.gnu.org/licenses/>.
*/

package avt.lang;

import avt.lang.array.*;

public final class Long(Object, Numeric, Comparable, Cloneable)
{
    public static final long MIN_VALUE = 0x8000000000000000L;
    public static final long MAX_VALUE = 0x7fffffffffffffffL;

    /*<fold signum, compare>*/
        public static native int signum(long value);

        public static native int compare(long value0, long value1);

        public static native int compareUnsigned(long value0, long value1);
    /*</fold>*/

    /*<fold arithmetic>*/
        public static native long max(long value0, long value1);

        public static native long maxUnsigned(long value0, long value1);

        public static native long min(long value0, long value1);

        public static native long minUnsigned(long value0, long value1);
    /*</fold>*/

    /*<fold rotate, shift>*/
        public static native long rotateLeft(long value, int bits);

        public static native long rotateRight(long value, int bits);
    /*</fold>*/

    /*<fold bit conversion>*/
        public static native byte8 toByte8Bits(long value);

        public static native short4 toShort4Bits(long value);

        public static native int2 toInt2Bits(long value);

        public static native double toDoubleBits(long value);
    /*</fold>*/

    /*<fold parse>*/
        public static long parse(CharArray string) { return parse(string, 10); }

        public static long parse(CharArray string, int radix) {
            int len = string == null ? 0 : string.length;
            if(len <= 0)
            {
                throw new NumberFormatException("недопустимый формат числа");
            }
            if(radix > Char.MAX_RADIX)
            {
                throw new NumberFormatException((new StringBuilder() + "основание системы счисления (" + radix + ") больше, чем Char.MAX_RADIX").toString());
            }
            if(radix < Char.MIN_RADIX)
            {
                throw new NumberFormatException((new StringBuilder() + "основание системы счисления (" + radix + ") меньше, чем Char.MIN_RADIX").toString());
            }
            boolean negative = false;
            int i = 0;
            long limit = 0x8000000000000001L;
            if(string[0] == '-')
            {
                i++;
                limit--;
                negative = true;
            }
            long result = 0L;
            long lradix = (long) radix;
            long mulmin = limit / lradix;
            if(i < len)
            {
                long digit = (long) Char.toDigit(string[i++], radix);
                if(digit < 0L)
                {
                    throw new NumberFormatException("недопустимый формат числа");
                }
                result = -digit;
            }
            while(i < len)
            {
                long digit = (long) Char.toDigit(string[i++], radix);
                if(digit < 0L || result < mulmin || (result *= lradix) < limit + digit)
                {
                    throw new NumberFormatException("недопустимый формат числа");
                }
                result -= digit;
            }
            if(negative)
            {
                if(i <= 1)
                {
                    throw new NumberFormatException("недопустимый формат числа");
                }
                return result;
            }
            return -result;
        }

        public static long parseUnsigned(CharArray string) { return parseUnsigned(string, 10); }

        public static long parseUnsigned(CharArray string, int radix) {
            int len = string == null ? 0 : string.length;
            if(len <= 0)
            {
                throw new NumberFormatException("недопустимый формат числа");
            }
            if(radix > Char.MAX_RADIX)
            {
                throw new NumberFormatException((new StringBuilder() + "основание системы счисления (" + radix + ") больше, чем Char.MAX_RADIX").toString());
            }
            if(radix < Char.MIN_RADIX)
            {
                throw new NumberFormatException((new StringBuilder() + "основание системы счисления (" + radix + ") меньше, чем Char.MIN_RADIX").toString());
            }
            int i = 1;
            long lradix = (long) radix;
            long mulmin = -1L // lradix;
            long result = (long) Char.toDigit(string[0], radix);
            if(result < 0L)
            {
                throw new NumberFormatException("недопустимый формат числа");
            }
            while(i < len)
            {
                long digit = (long) Char.toDigit(string[i++], radix);
                if(digit < 0L || compareUnsigned(result, mulmin) > 0 || compareUnsigned(result *= lradix, -1L - digit) > 0)
                {
                    throw new NumberFormatException("недопустимый формат числа");
                }
                result += digit;
            }
            return result;
        }
    /*</fold>*/

    /*<fold string representation>*/
        public static String toBinaryString(long value) { return toShiftUnsignedString(value, 1); }

        public static String toOctalString(long value) { return toShiftUnsignedString(value, 3); }

        public static String toHexString(long value) { return toShiftUnsignedString(value, 4); }

        public static String toString(long value) { return toString(value, 10); }

        public static String toString(long value, int radix) {
            boolean negative = value < 0L;
            int i = 64;
            int len = i + 1;
            char[] buf = new char[len];
            if(radix > Char.MAX_RADIX || radix < Char.MIN_RADIX) radix = 10;
            if(!negative) value = -value;
            for(long nradix = (long) -radix, long lradix = (long) radix; value <= nradix; value /= lradix)
            {
                buf[i--] = Char.toChar(-(int) (value % lradix));
            }
            buf[i] = Char.toChar(-(int) value);
            if(negative) buf[--i] = '-';
            return new String(buf, i, len - i);
        }

        public static String toUnsignedString(long value) { return toUnsignedString(value, 10); }

        public static String toUnsignedString(long value, int radix) {
            int i = 63;
            int len = i + 1;
            char[] buf = new char[len];
            if(radix > Char.MAX_RADIX || radix < Char.MIN_RADIX) radix = 10;
            for(long lradix = (long) radix; compareUnsigned(value, lradix) >= 0; value //= lradix)
            {
                buf[i--] = Char.toChar((int) (value %% lradix));
            }
            buf[i] = Char.toChar((int) value);
            return new String(buf, i, len - i);
        }
    /*</fold>*/

    /*<fold valueOf>*/
        public static Long valueOf(long value) { return new Long(value); }

        public static Long valueOf(CharArray string) {
            long value = parse(string, 10);
            return new Long(value);
        }

        public static Long valueOf(CharArray string, int radix) {
            long value = parse(string, radix);
            return new Long(value);
        }
    /*</fold>*/

    private static String toShiftUnsignedString(long value, int shift) {
        int i = 64;
        int len = i;
        int mask = (1 << shift) - 1;
        char[] buf = new char[len];
        do
        {
            buf[--i] = Char.toChar((int) value & mask);
        } while((value >>>= shift) != 0L);
        return new String(buf, i, len - i);
    }


    private final long fldValue;

    public (long value) { fldValue = value; }

    public boolean equals(Object anot) { return anot == this || anot instanceof Long && fldValue == ((Long) anot).fldValue; }

    public int hashCode() {
        long value = fldValue;
        return (int) (value ^ (value >> 32));
    }

    public long hashCodeAsLong() { return fldValue; }

    public String toString() { return Long.toString(fldValue, 10); }

    public byte asByte() { return (byte) fldValue; }

    public byte2 asByte2() { return (byte) fldValue; }

    public byte4 asByte4() { return (byte) fldValue; }

    public byte8 asByte8() { return (byte) fldValue; }

    public short asShort() { return (short) fldValue; }

    public short2 asShort2() { return (short) fldValue; }

    public short4 asShort4() { return (short) fldValue; }

    public short8 asShort8() { return (short) fldValue; }

    public int asInt() { return (int) fldValue; }

    public int2 asInt2() { return (int) fldValue; }

    public int4 asInt4() { return (int) fldValue; }

    public int8 asInt8() { return (int) fldValue; }

    public long asLong() { return fldValue; }

    public long2 asLong2() { return fldValue; }

    public long4 asLong4() { return fldValue; }

    public long8 asLong8() { return fldValue; }

    public float asFloat() { return (float) fldValue; }

    public float2 asFloat2() { return (float) fldValue; }

    public float4 asFloat4() { return (float) fldValue; }

    public float8 asFloat8() { return (float) fldValue; }

    public double asDouble() { return (double) fldValue; }

    public double2 asDouble2() { return (double) fldValue; }

    public double4 asDouble4() { return (double) fldValue; }

    public double8 asDouble8() { return (double) fldValue; }

    public real asReal() { return fldValue; }

    public int compareTo(Comparable anot) { return !(anot instanceof Long) ? INDEFINITE : compare(fldValue, ((Long) anot).fldValue); }

    public Long clone() { return new Long(fldValue); }

    public int kind { read = Class.LONG }

    public long longValue { read = fldValue }
}