PrimFn (Idris Java RTS 0.9.14 API)

java.lang.Object
- org.idris.rts.PrimFn

```
public class PrimFn
extends Object
```
Primitive backend functions.

Author:

Jan Bessai

Constructor Summary

Constructors
Constructor and Description

PrimFn()

Constructors
Constructor and Description
`PrimFn()`

Method Summary

Methods
Modifier and Type	Method and Description
`static ByteBuffer`	`LAllocate(long capacity)`
`static BigInteger`	`LAnd(BigInteger x, BigInteger y)`
`static byte[]`	`LAnd(byte[] x, byte[] y)`
`static byte`	`LAnd(byte x, byte y)`
`static char`	`LAnd(char x, char y)`
`static int[]`	`LAnd(int[] x, int[] y)`
`static int`	`LAnd(int x, int y)`
`static long[]`	`LAnd(long[] x, long[] y)`
`static long`	`LAnd(long x, long y)`
`static short[]`	`LAnd(short[] x, short[] y)`
`static short`	`LAnd(short x, short y)`
`static ByteBuffer`	`LAppend(ByteOrder endianness, ByteBuffer buffer, long position, long count, byte value)`
`static ByteBuffer`	`LAppend(ByteOrder endianness, ByteBuffer buffer, long position, long count, int value)`
`static ByteBuffer`	`LAppend(ByteOrder endianness, ByteBuffer buffer, long position, long count, long value)`
`static ByteBuffer`	`LAppend(ByteOrder endianness, ByteBuffer buffer, long position, long count, short value)`
`static ByteBuffer`	`LAppendBuffer(ByteBuffer to, long toSize, long count, long fromSize, long fromOffset, ByteBuffer from)`
`static BigInteger`	`LASHR(BigInteger x, BigInteger y)`
`static byte[]`	`LASHR(byte[] x, byte[] y)`
`static byte`	`LASHR(byte x, byte y)`
`static char`	`LASHR(char x, char y)`
`static int[]`	`LASHR(int[] x, int[] y)`
`static int`	`LASHR(int x, int y)`
`static long[]`	`LASHR(long[] x, long[] y)`
`static long`	`LASHR(long x, long y)`
`static short[]`	`LASHR(short[] x, short[] y)`
`static short`	`LASHR(short x, short y)`
`static short`	`LChIntIT16(char x)`
`static int`	`LChIntIT32(char x)`
`static long`	`LChIntIT64(char x)`
`static byte`	`LChIntIT8(char x)`
`static BigInteger`	`LChIntITBig(char x)`
`static BigInteger`	`LCompl(BigInteger x)`
`static byte`	`LCompl(byte x)`
`static byte[]`	`LCompl(byte[] x)`
`static char`	`LCompl(char x)`
`static int`	`LCompl(int x)`
`static int[]`	`LCompl(int[] x)`
`static long`	`LCompl(long x)`
`static long[]`	`LCompl(long[] x)`
`static short`	`LCompl(short x)`
`static short[]`	`LCompl(short[] x)`
`static int`	`LEq(BigInteger x, BigInteger y)`
`static byte[]`	`LEq(byte[] x, byte[] y)`
`static int`	`LEq(byte x, byte y)`
`static int`	`LEq(char x, char y)`
`static int`	`LEq(double x, double y)`
`static int[]`	`LEq(int[] x, int[] y)`
`static int`	`LEq(int x, int y)`
`static long[]`	`LEq(long[] x, long[] y)`
`static int`	`LEq(long x, long y)`
`static short[]`	`LEq(short[] x, short[] y)`
`static int`	`LEq(short x, short y)`
`static double`	`LFACos(double x)`
`static double`	`LFASin(double x)`
`static double`	`LFATan(double x)`
`static double`	`LFCeil(double x)`
`static double`	`LFCos(double x)`
`static double`	`LFExp(double x)`
`static double`	`LFFloor(double x)`
`static short`	`LFloatIntIT16(double x)`
`static int`	`LFloatIntIT32(double x)`
`static long`	`LFloatIntIT64(double x)`
`static byte`	`LFloatIntIT8(double x)`
`static BigInteger`	`LFloatIntITBig(double x)`
`static char`	`LFloatIntITChar(double x)`
`static String`	`LFloatStr(double x)`
`static double`	`LFLog(double x)`
`static double`	`LFSin(double x)`
`static double`	`LFSqrt(double x)`
`static double`	`LFTan(double x)`
`static byte[]`	`LGe(byte[] x, byte[] y)`
`static int`	`LGe(byte x, byte y)`
`static int`	`LGe(char x, char y)`
`static int[]`	`LGe(int[] x, int[] y)`
`static int`	`LGe(int x, int y)`
`static long[]`	`LGe(long[] x, long[] y)`
`static int`	`LGe(long x, long y)`
`static short[]`	`LGe(short[] x, short[] y)`
`static int`	`LGe(short x, short y)`
`static byte[]`	`LGt(byte[] x, byte[] y)`
`static int`	`LGt(byte x, byte y)`
`static int`	`LGt(char x, char y)`
`static int[]`	`LGt(int[] x, int[] y)`
`static int`	`LGt(int x, int y)`
`static long[]`	`LGt(long[] x, long[] y)`
`static int`	`LGt(long x, long y)`
`static short[]`	`LGt(short[] x, short[] y)`
`static int`	`LGt(short x, short y)`
`static byte`	`LIdxVec(byte[] x, int y)`
`static int`	`LIdxVec(int[] x, int y)`
`long`	`LIdxVec(long[] x, int y)`
`static short`	`LIdxVec(short[] x, int y)`
`static char`	`LIntCh(BigInteger x)`
`static char`	`LIntCh(byte x)`
`static char`	`LIntCh(char x)`
`static char`	`LIntCh(int x)`
`static char`	`LIntCh(long x)`
`static char`	`LIntCh(short x)`
`static double`	`LIntFloat(BigInteger x)`
`static double`	`LIntFloat(byte x)`
`static double`	`LIntFloat(char x)`
`static double`	`LIntFloat(int x)`
`static double`	`LIntFloat(long x)`
`static double`	`LIntFloat(short x)`
`static String`	`LIntStr(BigInteger x)`
`static String`	`LIntStr(byte x)`
`static String`	`LIntStr(char x)`
`static String`	`LIntStr(int x)`
`static String`	`LIntStr(long x)`
`static String`	`LIntStr(short x)`
`static byte[]`	`LLe(byte[] x, byte[] y)`
`static int`	`LLe(byte x, byte y)`
`static int`	`LLe(char x, char y)`
`static int[]`	`LLe(int[] x, int[] y)`
`static int`	`LLe(int x, int y)`
`static long[]`	`LLe(long[] x, long[] y)`
`static int`	`LLe(long x, long y)`
`static short[]`	`LLe(short[] x, short[] y)`
`static int`	`LLe(short x, short y)`
`static byte[]`	`LLSHR(byte[] x, byte[] y)`
`static byte`	`LLSHR(byte x, byte y)`
`static char`	`LLSHR(char x, char y)`
`static int[]`	`LLSHR(int[] x, int[] y)`
`static int`	`LLSHR(int x, int y)`
`static long[]`	`LLSHR(long[] x, long[] y)`
`static long`	`LLSHR(long x, long y)`
`static short[]`	`LLSHR(short[] x, short[] y)`
`static short`	`LLSHR(short x, short y)`
`static byte[]`	`LLt(byte[] x, byte[] y)`
`static int`	`LLt(byte x, byte y)`
`static int`	`LLt(char x, char y)`
`static int[]`	`LLt(int[] x, int[] y)`
`static int`	`LLt(int x, int y)`
`static long[]`	`LLt(long[] x, long[] y)`
`static int`	`LLt(long x, long y)`
`static short[]`	`LLt(short[] x, short[] y)`
`static int`	`LLt(short x, short y)`
`static BigInteger`	`LMinus(BigInteger x, BigInteger y)`
`static byte[]`	`LMinus(byte[] x, byte[] y)`
`static byte`	`LMinus(byte x, byte y)`
`static char`	`LMinus(char x, char y)`
`static double`	`LMinus(double x, double y)`
`static int[]`	`LMinus(int[] x, int[] y)`
`static int`	`LMinus(int x, int y)`
`static long[]`	`LMinus(long[] x, long[] y)`
`static long`	`LMinus(long x, long y)`
`static short[]`	`LMinus(short[] x, short[] y)`
`static short`	`LMinus(short x, short y)`
`static byte[]`	`LMkVec(byte... x)`
`static int[]`	`LMKVec(int... x)`
`static long[]`	`LMKVec(long... x)`
`static short[]`	`LMkVec(short... x)`
`static BigInteger`	`LOr(BigInteger x, BigInteger y)`
`static byte[]`	`LOr(byte[] x, byte[] y)`
`static byte`	`LOr(byte x, byte y)`
`static char`	`LOr(char x, char y)`
`static int[]`	`LOr(int[] x, int[] y)`
`static int`	`LOr(int x, int y)`
`static long[]`	`LOr(long[] x, long[] y)`
`static long`	`LOr(long x, long y)`
`static short[]`	`LOr(short[] x, short[] y)`
`static short`	`LOr(short x, short y)`
`static short`	`LPeekIT16(ByteOrder endianness, ByteBuffer buffer, long position)`
`static int`	`LPeekIT32(ByteOrder endianness, ByteBuffer buffer, long position)`
`static long`	`LPeekIT64(ByteOrder endianness, ByteBuffer buffer, long position)`
`static byte`	`LPeekIT8(ByteOrder endianness, ByteBuffer buffer, long position)`
`static BigInteger`	`LPlus(BigInteger x, BigInteger y)`
`static byte[]`	`LPlus(byte[] x, byte[] y)`
`static byte`	`LPlus(byte x, byte y)`
`static char`	`LPlus(char x, char y)`
`static double`	`LPlus(double x, double y)`
`static int[]`	`LPlus(int[] x, int[] y)`
`static int`	`LPlus(int x, int y)`
`static long[]`	`LPlus(long[] x, long[] y)`
`static long`	`LPlus(long x, long y)`
`static short[]`	`LPlus(short[] x, short[] y)`
`static short`	`LPlus(short x, short y)`
`static void`	`LPrintNum(Object x)`
`static void`	`LPrintStr(String x)`
`static String`	`LReadStr(Object x)`
`static BigInteger`	`LSDiv(BigInteger x, BigInteger y)`
`static byte[]`	`LSDiv(byte[] x, byte[] y)`
`static byte`	`LSDiv(byte x, byte y)`
`static char`	`LSDiv(char x, char y)`
`static double`	`LSDiv(double x, double y)`
`static int[]`	`LSDiv(int[] x, int[] y)`
`static int`	`LSDiv(int x, int y)`
`static long[]`	`LSDiv(long[] x, long[] y)`
`static long`	`LSDiv(long x, long y)`
`static short[]`	`LSDiv(short[] x, short[] y)`
`static short`	`LSDiv(short x, short y)`
`static short`	`LSExtIT16(byte x)`
`static short`	`LSExtIT16(char x)`
`static int`	`LSExtIT32(byte x)`
`static int`	`LSExtIT32(char x)`
`static int`	`LSExtIT32(short x)`
`static long`	`LSExtIT64(byte x)`
`static long`	`LSExtIT64(char x)`
`static long`	`LSExtIT64(int x)`
`static long`	`LSExtIT64(short x)`
`static BigInteger`	`LSExtITBig(byte x)`
`static BigInteger`	`LSExtITBig(char x)`
`static BigInteger`	`LSExtITBig(int x)`
`static BigInteger`	`LSExtITBig(long x)`
`static BigInteger`	`LSExtITBig(short x)`
`static short[]`	`LSExtITVec16(byte[] x)`
`static int[]`	`LSExtITVec32(byte[] x)`
`static int[]`	`LSExtITVec32(short[] x)`
`static long[]`	`LSExtITVec64(byte[] x)`
`static long[]`	`LSExtITVec64(int[] x)`
`static long[]`	`LSExtITVec64(short[] x)`
`static int`	`LSGe(BigInteger x, BigInteger y)`
`static byte[]`	`LSGe(byte[] x, byte[] y)`
`static int`	`LSGe(byte x, byte y)`
`static int`	`LSGe(char x, char y)`
`static double`	`LSGe(double x, double y)`
`static int[]`	`LSGe(int[] x, int[] y)`
`static int`	`LSGe(int x, int y)`
`static long[]`	`LSGe(long[] x, long[] y)`
`static int`	`LSGe(long x, long y)`
`static short[]`	`LSGe(short[] x, short[] y)`
`static int`	`LSGe(short x, short y)`
`static int`	`LSGt(BigInteger x, BigInteger y)`
`static byte[]`	`LSGt(byte[] x, byte[] y)`
`static int`	`LSGt(byte x, byte y)`
`static int`	`LSGt(char x, char y)`
`static double`	`LSGt(double x, double y)`
`static int[]`	`LSGt(int[] x, int[] y)`
`static int`	`LSGt(int x, int y)`
`static long[]`	`LSGt(long[] x, long[] y)`
`static int`	`LSGt(long x, long y)`
`static short[]`	`LSGt(short[] x, short[] y)`
`static int`	`LSGt(short x, short y)`
`static BigInteger`	`LSHL(BigInteger x, BigInteger y)`
`static byte[]`	`LSHL(byte[] x, byte[] y)`
`static byte`	`LSHL(byte x, byte y)`
`static char`	`LSHL(char x, char y)`
`static int[]`	`LSHL(int[] x, int[] y)`
`static int`	`LSHL(int x, int y)`
`static long[]`	`LSHL(long[] x, long[] y)`
`static long`	`LSHL(long x, long y)`
`static short[]`	`LSHL(short[] x, short[] y)`
`static short`	`LSHL(short x, short y)`
`static int`	`LSLe(BigInteger x, BigInteger y)`
`static byte[]`	`LSLe(byte[] x, byte[] y)`
`static int`	`LSLe(byte x, byte y)`
`static int`	`LSLe(char x, char y)`
`static double`	`LSLe(double x, double y)`
`static int[]`	`LSLe(int[] x, int[] y)`
`static int`	`LSLe(int x, int y)`
`static long[]`	`LSLe(long[] x, long[] y)`
`static int`	`LSLe(long x, long y)`
`static short[]`	`LSLe(short[] x, short[] y)`
`static int`	`LSLe(short x, short y)`
`static int`	`LSLt(BigInteger x, BigInteger y)`
`static byte[]`	`LSLt(byte[] x, byte[] y)`
`static int`	`LSLt(byte x, byte y)`
`static int`	`LSLt(char x, char y)`
`static double`	`LSLt(double x, double y)`
`static int[]`	`LSLt(int[] x, int[] y)`
`static int`	`LSLt(int x, int y)`
`static long[]`	`LSLt(long[] x, long[] y)`
`static int`	`LSLt(long x, long y)`
`static short[]`	`LSLt(short[] x, short[] y)`
`static int`	`LSLt(short x, short y)`
`static BigInteger`	`LSRem(BigInteger x, BigInteger y)`
`static byte[]`	`LSRem(byte[] x, byte[] y)`
`static byte`	`LSRem(byte x, byte y)`
`static char`	`LSRem(char x, char y)`
`static double`	`LSRem(double x, double y)`
`static int[]`	`LSRem(int[] x, int[] y)`
`static int`	`LSRem(int x, int y)`
`static long[]`	`LSRem(long[] x, long[] y)`
`static long`	`LSRem(long x, long y)`
`static short[]`	`LSRem(short[] x, short[] y)`
`static short`	`LSRem(short x, short y)`
`static OutputStream`	`LStdErr()`
`static InputStream`	`LStdIn()`
`static OutputStream`	`LStdOut()`
`static String`	`LStrConcat(String... args)`
`static String`	`LStrCons(char x, String y)`
`static int`	`LStrEq(String x, String y)`
`static double`	`LStrFloat(String x)`
`static char`	`LStrHead(String x)`
`static char`	`LStrIndex(String x, int y)`
`static short`	`LStrIntIT16(String x)`
`static int`	`LStrIntIT32(String x)`
`static long`	`LStrIntIT64(String x)`
`static byte`	`LStrIntIT8(String x)`
`static BigInteger`	`LStrIntITBig(String x)`
`static char`	`LStrIntITChar(String x)`
`static int`	`LStrLen(String x)`
`static int`	`LStrLt(String x, String y)`
`static String`	`LStrRev(String x)`
`static String`	`LStrTail(String x)`
`static String`	`LSystemInfo(int index)`
`static BigInteger`	`LTimes(BigInteger x, BigInteger y)`
`static byte[]`	`LTimes(byte[] x, byte[] y)`
`static byte`	`LTimes(byte x, byte y)`
`static char`	`LTimes(char x, char y)`
`static double`	`LTimes(double x, double y)`
`static int[]`	`LTimes(int[] x, int[] y)`
`static int`	`LTimes(int x, int y)`
`static long[]`	`LTimes(long[] x, long[] y)`
`static long`	`LTimes(long x, long y)`
`static short[]`	`LTimes(short[] x, short[] y)`
`static short`	`LTimes(short x, short y)`
`static short`	`LTruncIT16(BigInteger x)`
`static short`	`LTruncIT16(char x)`
`static short`	`LTruncIT16(int x)`
`static short`	`LTruncIT16(long x)`
`static int`	`LTruncIT32(BigInteger x)`
`static int`	`LTruncIT32(char x)`
`static int`	`LTruncIT32(long x)`
`static long`	`LTruncIT64(BigInteger x)`
`static long`	`LTruncIT64(char x)`
`static byte`	`LTruncIT8(BigInteger x)`
`static byte`	`LTruncIT8(char x)`
`static byte`	`LTruncIT8(int x)`
`static byte`	`LTruncIT8(long x)`
`static byte`	`LTruncIT8(short x)`
`static BigInteger`	`LTruncITBig(char x)`
`static char`	`LTruncITChar(BigInteger x)`
`static char`	`LTruncITChar(int x)`
`static char`	`LTruncITChar(long x)`
`static char`	`LTruncITChar(short x)`
`static short[]`	`LTruncITVec16(int[] x)`
`static short[]`	`LTruncITVec16(long[] x)`
`static int[]`	`LTruncITVec32(long[] x)`
`static byte[]`	`LTruncITVec8(int[] x)`
`static byte[]`	`LTruncITVec8(long[] x)`
`static byte[]`	`LTruncITVec8(short[] x)`
`static byte[]`	`LUDiv(byte[] x, byte[] y)`
`static byte`	`LUDiv(byte x, byte y)`
`static char`	`LUDiv(char x, char y)`
`static int[]`	`LUDiv(int[] x, int[] y)`
`static int`	`LUDiv(int x, int y)`
`static long[]`	`LUDiv(long[] x, long[] y)`
`static long`	`LUDiv(long x, long y)`
`static short[]`	`LUDiv(short[] x, short[] y)`
`static short`	`LUDiv(short x, short y)`
`static byte[]`	`LUpdateVec(byte[] x, int y, byte z)`
`static int[]`	`LUpdateVec(int[] x, int y, int z)`
`long[]`	`LUpdateVec(long[] x, int y, long z)`
`static short[]`	`LUpdateVec(short[] x, int y, short z)`
`static byte[]`	`LURem(byte[] x, byte[] y)`
`static byte`	`LURem(byte x, byte y)`
`static char`	`LURem(char x, char y)`
`static int[]`	`LURem(int[] x, int[] y)`
`static int`	`LURem(int x, int y)`
`static long[]`	`LURem(long[] x, long[] y)`
`static long`	`LURem(long x, long y)`
`static short[]`	`LURem(short[] x, short[] y)`
`static short`	`LURem(short x, short y)`
`static Thread`	`LVMPtr()`
`static BigInteger`	`LXOr(BigInteger x, BigInteger y)`
`static byte[]`	`LXOr(byte[] x, byte[] y)`
`static byte`	`LXOr(byte x, byte y)`
`static char`	`LXOr(char x, char y)`
`static int[]`	`LXOr(int[] x, int[] y)`
`static int`	`LXOr(int x, int y)`
`static long[]`	`LXOr(long[] x, long[] y)`
`static long`	`LXOr(long x, long y)`
`static short[]`	`LXOr(short[] x, short[] y)`
`static short`	`LXOr(short x, short y)`
`static short`	`LZExtIT16(byte x)`
`static int`	`LZExtIT32(byte x)`
`static int`	`LZExtIT32(short x)`
`static long`	`LZExtIT64(byte x)`
`static long`	`LZExtIT64(int x)`
`static long`	`LZExtIT64(short x)`
`static BigInteger`	`LZExtITBig(byte x)`
`static BigInteger`	`LZExtITBig(int x)`
`static BigInteger`	`LZExtITBig(long x)`
`static BigInteger`	`LZExtITBig(short x)`
`static char`	`LZExtITChar(byte x)`
`static char`	`LZExtITChar(int x)`
`static char`	`LZExtITChar(long x)`
`static char`	`LZExtITChar(short x)`
`static short[]`	`LZExtITVec16(byte[] x)`
`static int[]`	`LZExtITVec32(byte[] x)`
`static int[]`	`LZExtITVec32(short[] x)`
`static long[]`	`LZExtITVec64(byte[] x)`
`static long[]`	`LZExtITVec64(int[] x)`
`static long[]`	`LZExtITVec64(short[] x)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- PrimFn
```
public PrimFn()
```

Method Detail

LPlus

public static byte LPlus(byte x,
         byte y)

LPlus

public static char LPlus(char x,
         char y)

LPlus

public static short LPlus(short x,
          short y)

LPlus

public static int LPlus(int x,
        int y)

LPlus

public static long LPlus(long x,
         long y)

LPlus

public static double LPlus(double x,
           double y)

LPlus

public static BigInteger LPlus(BigInteger x,
               BigInteger y)

LPlus

public static byte[] LPlus(byte[] x,
           byte[] y)

LPlus

public static short[] LPlus(short[] x,
            short[] y)

LPlus

public static int[] LPlus(int[] x,
          int[] y)

LPlus

public static long[] LPlus(long[] x,
           long[] y)

LMinus

public static byte LMinus(byte x,
          byte y)

LMinus

public static char LMinus(char x,
          char y)

LMinus

public static short LMinus(short x,
           short y)

LMinus

public static int LMinus(int x,
         int y)

LMinus

public static long LMinus(long x,
          long y)

LMinus

public static double LMinus(double x,
            double y)

LMinus

public static BigInteger LMinus(BigInteger x,
                BigInteger y)

LMinus

public static byte[] LMinus(byte[] x,
            byte[] y)

LMinus

public static short[] LMinus(short[] x,
             short[] y)

LMinus

public static int[] LMinus(int[] x,
           int[] y)

LMinus

public static long[] LMinus(long[] x,
            long[] y)

LTimes

public static byte LTimes(byte x,
          byte y)

LTimes

public static char LTimes(char x,
          char y)

LTimes

public static short LTimes(short x,
           short y)

LTimes

public static int LTimes(int x,
         int y)

LTimes

public static long LTimes(long x,
          long y)

LTimes

public static double LTimes(double x,
            double y)

LTimes

public static BigInteger LTimes(BigInteger x,
                BigInteger y)

LTimes

public static byte[] LTimes(byte[] x,
            byte[] y)

LTimes

public static short[] LTimes(short[] x,
             short[] y)

LTimes

public static int[] LTimes(int[] x,
           int[] y)

LTimes

public static long[] LTimes(long[] x,
            long[] y)

LUDiv

public static byte LUDiv(byte x,
         byte y)

LUDiv

public static char LUDiv(char x,
         char y)

LUDiv

public static short LUDiv(short x,
          short y)

LUDiv

public static int LUDiv(int x,
        int y)

LUDiv

public static long LUDiv(long x,
         long y)

LUDiv

public static byte[] LUDiv(byte[] x,
           byte[] y)

LUDiv

public static short[] LUDiv(short[] x,
            short[] y)

LUDiv

public static int[] LUDiv(int[] x,
          int[] y)

LUDiv

public static long[] LUDiv(long[] x,
           long[] y)

LSDiv

public static byte LSDiv(byte x,
         byte y)

LSDiv

public static char LSDiv(char x,
         char y)

LSDiv

public static short LSDiv(short x,
          short y)

LSDiv

public static int LSDiv(int x,
        int y)

LSDiv

public static long LSDiv(long x,
         long y)

LSDiv

public static double LSDiv(double x,
           double y)

LSDiv

public static BigInteger LSDiv(BigInteger x,
               BigInteger y)

LSDiv

public static byte[] LSDiv(byte[] x,
           byte[] y)

LSDiv

public static short[] LSDiv(short[] x,
            short[] y)

LSDiv

public static int[] LSDiv(int[] x,
          int[] y)

LSDiv

public static long[] LSDiv(long[] x,
           long[] y)

LURem

public static byte LURem(byte x,
         byte y)

LURem

public static char LURem(char x,
         char y)

LURem

public static short LURem(short x,
          short y)

LURem

public static int LURem(int x,
        int y)

LURem

public static long LURem(long x,
         long y)

LURem

public static byte[] LURem(byte[] x,
           byte[] y)

LURem

public static short[] LURem(short[] x,
            short[] y)

LURem

public static int[] LURem(int[] x,
          int[] y)

LURem

public static long[] LURem(long[] x,
           long[] y)

LSRem

public static byte LSRem(byte x,
         byte y)

LSRem

public static char LSRem(char x,
         char y)

LSRem

public static short LSRem(short x,
          short y)

LSRem

public static int LSRem(int x,
        int y)

LSRem

public static long LSRem(long x,
         long y)

LSRem

public static double LSRem(double x,
           double y)

LSRem

public static BigInteger LSRem(BigInteger x,
               BigInteger y)

LSRem

public static byte[] LSRem(byte[] x,
           byte[] y)

LSRem

public static short[] LSRem(short[] x,
            short[] y)

LSRem

public static int[] LSRem(int[] x,
          int[] y)

LSRem

public static long[] LSRem(long[] x,
           long[] y)

LAnd

public static byte LAnd(byte x,
        byte y)

LAnd

public static char LAnd(char x,
        char y)

LAnd

public static short LAnd(short x,
         short y)

LAnd

public static int LAnd(int x,
       int y)

LAnd

public static long LAnd(long x,
        long y)

LAnd

public static BigInteger LAnd(BigInteger x,
              BigInteger y)

LAnd

public static byte[] LAnd(byte[] x,
          byte[] y)

LAnd

public static short[] LAnd(short[] x,
           short[] y)

LAnd

public static int[] LAnd(int[] x,
         int[] y)

LAnd

public static long[] LAnd(long[] x,
          long[] y)

LOr

public static byte LOr(byte x,
       byte y)

LOr

public static char LOr(char x,
       char y)

LOr

public static short LOr(short x,
        short y)

LOr

public static int LOr(int x,
      int y)

LOr

public static long LOr(long x,
       long y)

LOr

public static BigInteger LOr(BigInteger x,
             BigInteger y)

LOr

public static byte[] LOr(byte[] x,
         byte[] y)

LOr

public static short[] LOr(short[] x,
          short[] y)

LOr

public static int[] LOr(int[] x,
        int[] y)

LOr

public static long[] LOr(long[] x,
         long[] y)

LXOr

public static byte LXOr(byte x,
        byte y)

LXOr

public static char LXOr(char x,
        char y)

LXOr

public static short LXOr(short x,
         short y)

LXOr

public static int LXOr(int x,
       int y)

LXOr

public static long LXOr(long x,
        long y)

LXOr

public static BigInteger LXOr(BigInteger x,
              BigInteger y)

LXOr

public static byte[] LXOr(byte[] x,
          byte[] y)

LXOr

public static short[] LXOr(short[] x,
           short[] y)

LXOr

public static int[] LXOr(int[] x,
         int[] y)

LXOr

public static long[] LXOr(long[] x,
          long[] y)

LCompl
```
public static byte LCompl(byte x)
```

LCompl
```
public static char LCompl(char x)
```

LCompl
```
public static short LCompl(short x)
```

LCompl
```
public static int LCompl(int x)
```

LCompl
```
public static long LCompl(long x)
```

LCompl

public static BigInteger LCompl(BigInteger x)

LCompl

public static byte[] LCompl(byte[] x)

LCompl

public static short[] LCompl(short[] x)

LCompl
```
public static int[] LCompl(int[] x)
```

LCompl

public static long[] LCompl(long[] x)

LSHL

public static byte LSHL(byte x,
        byte y)

LSHL

public static char LSHL(char x,
        char y)

LSHL

public static short LSHL(short x,
         short y)

LSHL

public static int LSHL(int x,
       int y)

LSHL

public static long LSHL(long x,
        long y)

LSHL

public static BigInteger LSHL(BigInteger x,
              BigInteger y)

LSHL

public static byte[] LSHL(byte[] x,
          byte[] y)

LSHL

public static short[] LSHL(short[] x,
           short[] y)

LSHL

public static int[] LSHL(int[] x,
         int[] y)

LSHL

public static long[] LSHL(long[] x,
          long[] y)

LLSHR

public static byte LLSHR(byte x,
         byte y)

LLSHR

public static char LLSHR(char x,
         char y)

LLSHR

public static short LLSHR(short x,
          short y)

LLSHR

public static int LLSHR(int x,
        int y)

LLSHR

public static long LLSHR(long x,
         long y)

LLSHR

public static byte[] LLSHR(byte[] x,
           byte[] y)

LLSHR

public static short[] LLSHR(short[] x,
            short[] y)

LLSHR

public static int[] LLSHR(int[] x,
          int[] y)

LLSHR

public static long[] LLSHR(long[] x,
           long[] y)

LASHR

public static byte LASHR(byte x,
         byte y)

LASHR

public static char LASHR(char x,
         char y)

LASHR

public static short LASHR(short x,
          short y)

LASHR

public static int LASHR(int x,
        int y)

LASHR

public static long LASHR(long x,
         long y)

LASHR

public static BigInteger LASHR(BigInteger x,
               BigInteger y)

LASHR

public static byte[] LASHR(byte[] x,
           byte[] y)

LASHR

public static short[] LASHR(short[] x,
            short[] y)

LASHR

public static int[] LASHR(int[] x,
          int[] y)

LASHR

public static long[] LASHR(long[] x,
           long[] y)

LEq

public static int LEq(byte x,
      byte y)

LEq

public static int LEq(char x,
      char y)

LEq

public static int LEq(short x,
      short y)

LEq

public static int LEq(int x,
      int y)

LEq

public static int LEq(long x,
      long y)

LEq

public static int LEq(double x,
      double y)

LEq

public static int LEq(BigInteger x,
      BigInteger y)

LEq

public static byte[] LEq(byte[] x,
         byte[] y)

LEq

public static short[] LEq(short[] x,
          short[] y)

LEq

public static int[] LEq(int[] x,
        int[] y)

LEq

public static long[] LEq(long[] x,
         long[] y)

LSLt

public static int LSLt(byte x,
       byte y)

LSLt

public static int LSLt(char x,
       char y)

LSLt

public static int LSLt(short x,
       short y)

LSLt

public static int LSLt(int x,
       int y)

LSLt

public static int LSLt(long x,
       long y)

LSLt

public static double LSLt(double x,
          double y)

LSLt

public static int LSLt(BigInteger x,
       BigInteger y)

LSLt

public static byte[] LSLt(byte[] x,
          byte[] y)

LSLt

public static short[] LSLt(short[] x,
           short[] y)

LSLt

public static int[] LSLt(int[] x,
         int[] y)

LSLt

public static long[] LSLt(long[] x,
          long[] y)

LLt

public static int LLt(byte x,
      byte y)

LLt

public static int LLt(char x,
      char y)

LLt

public static int LLt(short x,
      short y)

LLt

public static int LLt(int x,
      int y)

LLt

public static int LLt(long x,
      long y)

LLt

public static byte[] LLt(byte[] x,
         byte[] y)

LLt

public static short[] LLt(short[] x,
          short[] y)

LLt

public static int[] LLt(int[] x,
        int[] y)

LLt

public static long[] LLt(long[] x,
         long[] y)

LSLe

public static int LSLe(byte x,
       byte y)

LSLe

public static int LSLe(char x,
       char y)

LSLe

public static int LSLe(short x,
       short y)

LSLe

public static int LSLe(int x,
       int y)

LSLe

public static int LSLe(long x,
       long y)

LSLe

public static double LSLe(double x,
          double y)

LSLe

public static int LSLe(BigInteger x,
       BigInteger y)

LSLe

public static byte[] LSLe(byte[] x,
          byte[] y)

LSLe

public static short[] LSLe(short[] x,
           short[] y)

LSLe

public static int[] LSLe(int[] x,
         int[] y)

LSLe

public static long[] LSLe(long[] x,
          long[] y)

LLe

public static int LLe(byte x,
      byte y)

LLe

public static int LLe(char x,
      char y)

LLe

public static int LLe(short x,
      short y)

LLe

public static int LLe(int x,
      int y)

LLe

public static int LLe(long x,
      long y)

LLe

public static byte[] LLe(byte[] x,
         byte[] y)

LLe

public static short[] LLe(short[] x,
          short[] y)

LLe

public static int[] LLe(int[] x,
        int[] y)

LLe

public static long[] LLe(long[] x,
         long[] y)

LSGt

public static int LSGt(byte x,
       byte y)

LSGt

public static int LSGt(char x,
       char y)

LSGt

public static int LSGt(short x,
       short y)

LSGt

public static int LSGt(int x,
       int y)

LSGt

public static int LSGt(long x,
       long y)

LSGt

public static double LSGt(double x,
          double y)

LSGt

public static int LSGt(BigInteger x,
       BigInteger y)

LSGt

public static byte[] LSGt(byte[] x,
          byte[] y)

LSGt

public static short[] LSGt(short[] x,
           short[] y)

LSGt

public static int[] LSGt(int[] x,
         int[] y)

LSGt

public static long[] LSGt(long[] x,
          long[] y)

LGt

public static int LGt(byte x,
      byte y)

LGt

public static int LGt(char x,
      char y)

LGt

public static int LGt(short x,
      short y)

LGt

public static int LGt(int x,
      int y)

LGt

public static int LGt(long x,
      long y)

LGt

public static byte[] LGt(byte[] x,
         byte[] y)

LGt

public static short[] LGt(short[] x,
          short[] y)

LGt

public static int[] LGt(int[] x,
        int[] y)

LGt

public static long[] LGt(long[] x,
         long[] y)

LSGe

public static int LSGe(byte x,
       byte y)

LSGe

public static int LSGe(char x,
       char y)

LSGe

public static int LSGe(short x,
       short y)

LSGe

public static int LSGe(int x,
       int y)

LSGe

public static int LSGe(long x,
       long y)

LSGe

public static double LSGe(double x,
          double y)

LSGe

public static int LSGe(BigInteger x,
       BigInteger y)

LSGe

public static byte[] LSGe(byte[] x,
          byte[] y)

LSGe

public static short[] LSGe(short[] x,
           short[] y)

LSGe

public static int[] LSGe(int[] x,
         int[] y)

LSGe

public static long[] LSGe(long[] x,
          long[] y)

LGe

public static int LGe(byte x,
      byte y)

LGe

public static int LGe(char x,
      char y)

LGe

public static int LGe(short x,
      short y)

LGe

public static int LGe(int x,
      int y)

LGe

public static int LGe(long x,
      long y)

LGe

public static byte[] LGe(byte[] x,
         byte[] y)

LGe

public static short[] LGe(short[] x,
          short[] y)

LGe

public static int[] LGe(int[] x,
        int[] y)

LGe

public static long[] LGe(long[] x,
         long[] y)

LSExtIT16

public static short LSExtIT16(byte x)

LSExtIT32
```
public static int LSExtIT32(byte x)
```

LSExtIT64
```
public static long LSExtIT64(byte x)
```

LSExtITBig

public static BigInteger LSExtITBig(byte x)

LSExtITVec16

public static short[] LSExtITVec16(byte[] x)

LSExtITVec32

public static int[] LSExtITVec32(byte[] x)

LSExtITVec64

public static long[] LSExtITVec64(byte[] x)

LSExtIT16

public static short LSExtIT16(char x)

LSExtIT32
```
public static int LSExtIT32(char x)
```

LSExtIT64
```
public static long LSExtIT64(char x)
```

LSExtITBig

public static BigInteger LSExtITBig(char x)

LSExtIT32
```
public static int LSExtIT32(short x)
```

LSExtIT64

public static long LSExtIT64(short x)

LSExtITBig

public static BigInteger LSExtITBig(short x)

LSExtITVec32

public static int[] LSExtITVec32(short[] x)

LSExtITVec64

public static long[] LSExtITVec64(short[] x)

LSExtIT64
```
public static long LSExtIT64(int x)
```

LSExtITBig

public static BigInteger LSExtITBig(int x)

LSExtITVec64

public static long[] LSExtITVec64(int[] x)

LSExtITBig

public static BigInteger LSExtITBig(long x)

LZExtIT16

public static short LZExtIT16(byte x)

LZExtIT32
```
public static int LZExtIT32(byte x)
```

LZExtIT64
```
public static long LZExtIT64(byte x)
```

LZExtITBig

public static BigInteger LZExtITBig(byte x)

LZExtITChar

public static char LZExtITChar(byte x)

LZExtITVec16

public static short[] LZExtITVec16(byte[] x)

LZExtITVec32

public static int[] LZExtITVec32(byte[] x)

LZExtITVec64

public static long[] LZExtITVec64(byte[] x)

LZExtIT32
```
public static int LZExtIT32(short x)
```

LZExtIT64

public static long LZExtIT64(short x)

LZExtITBig

public static BigInteger LZExtITBig(short x)

LZExtITChar

public static char LZExtITChar(short x)

LZExtITVec32

public static int[] LZExtITVec32(short[] x)

LZExtITVec64

public static long[] LZExtITVec64(short[] x)

LZExtIT64
```
public static long LZExtIT64(int x)
```

LZExtITBig

public static BigInteger LZExtITBig(int x)

LZExtITChar

public static char LZExtITChar(int x)

LZExtITVec64

public static long[] LZExtITVec64(int[] x)

LZExtITBig

public static BigInteger LZExtITBig(long x)

LZExtITChar

public static char LZExtITChar(long x)

LTruncIT8

public static byte LTruncIT8(short x)

LTruncITVec8

public static byte[] LTruncITVec8(short[] x)

LTruncITChar

public static char LTruncITChar(short x)

LTruncIT8
```
public static byte LTruncIT8(int x)
```

LTruncIT16

public static short LTruncIT16(int x)

LTruncITVec8

public static byte[] LTruncITVec8(int[] x)

LTruncITVec16

public static short[] LTruncITVec16(int[] x)

LTruncITChar

public static char LTruncITChar(int x)

LTruncIT8
```
public static byte LTruncIT8(long x)
```

LTruncIT16

public static short LTruncIT16(long x)

LTruncIT32
```
public static int LTruncIT32(long x)
```

LTruncITVec8

public static byte[] LTruncITVec8(long[] x)

LTruncITVec16

public static short[] LTruncITVec16(long[] x)

LTruncITVec32

public static int[] LTruncITVec32(long[] x)

LTruncITChar

public static char LTruncITChar(long x)

LTruncIT8

public static byte LTruncIT8(BigInteger x)

LTruncIT16

public static short LTruncIT16(BigInteger x)

LTruncIT32

public static int LTruncIT32(BigInteger x)

LTruncIT64

public static long LTruncIT64(BigInteger x)

LTruncITChar

public static char LTruncITChar(BigInteger x)

LTruncIT8
```
public static byte LTruncIT8(char x)
```

LTruncIT16

public static short LTruncIT16(char x)

LTruncIT32
```
public static int LTruncIT32(char x)
```

LTruncIT64

public static long LTruncIT64(char x)

LTruncITBig

public static BigInteger LTruncITBig(char x)

LFExp
```
public static double LFExp(double x)
```

LFLog
```
public static double LFLog(double x)
```

LFSin
```
public static double LFSin(double x)
```

LFCos
```
public static double LFCos(double x)
```

LFTan
```
public static double LFTan(double x)
```

LFASin

public static double LFASin(double x)

LFACos

public static double LFACos(double x)

LFATan

public static double LFATan(double x)

LFSqrt

public static double LFSqrt(double x)

LFFloor

public static double LFFloor(double x)

LFCeil

public static double LFCeil(double x)

LMkVec

public static byte[] LMkVec(byte... x)

LMkVec

public static short[] LMkVec(short... x)

LMKVec
```
public static int[] LMKVec(int... x)
```

LMKVec

public static long[] LMKVec(long... x)

LIdxVec

public static byte LIdxVec(byte[] x,
           int y)

LIdxVec

public static short LIdxVec(short[] x,
            int y)

LIdxVec

public static int LIdxVec(int[] x,
          int y)

LIdxVec

public long LIdxVec(long[] x,
           int y)

LUpdateVec

public static byte[] LUpdateVec(byte[] x,
                int y,
                byte z)

LUpdateVec

public static short[] LUpdateVec(short[] x,
                 int y,
                 short z)

LUpdateVec

public static int[] LUpdateVec(int[] x,
               int y,
               int z)

LUpdateVec

public long[] LUpdateVec(long[] x,
                int y,
                long z)

LStrConcat

public static String LStrConcat(String... args)

LStrLt

public static int LStrLt(String x,
         String y)

LStrEq

public static int LStrEq(String x,
         String y)

LStrLen
```
public static int LStrLen(String x)
```

LIntFloat

public static double LIntFloat(byte x)

LIntFloat

public static double LIntFloat(char x)

LIntFloat

public static double LIntFloat(short x)

LIntFloat

public static double LIntFloat(int x)

LIntFloat

public static double LIntFloat(long x)

LIntFloat

public static double LIntFloat(BigInteger x)

LFloatIntIT8

public static byte LFloatIntIT8(double x)

LFloatIntIT16

public static short LFloatIntIT16(double x)

LFloatIntIT32

public static int LFloatIntIT32(double x)

LFloatIntIT64

public static long LFloatIntIT64(double x)

LFloatIntITBig

public static BigInteger LFloatIntITBig(double x)

LFloatIntITChar

public static char LFloatIntITChar(double x)

LIntStr
```
public static String LIntStr(byte x)
```

LIntStr
```
public static String LIntStr(char x)
```

LIntStr

public static String LIntStr(short x)

LIntStr
```
public static String LIntStr(int x)
```

LIntStr
```
public static String LIntStr(long x)
```

LIntStr

public static String LIntStr(BigInteger x)

LStrIntIT8

public static byte LStrIntIT8(String x)

LStrIntIT16

public static short LStrIntIT16(String x)

LStrIntIT32

public static int LStrIntIT32(String x)

LStrIntIT64

public static long LStrIntIT64(String x)

LStrIntITBig

public static BigInteger LStrIntITBig(String x)

LStrIntITChar

public static char LStrIntITChar(String x)

LFloatStr

public static String LFloatStr(double x)

LStrFloat

public static double LStrFloat(String x)

LIntCh
```
public static char LIntCh(byte x)
```

LIntCh
```
public static char LIntCh(char x)
```

LIntCh
```
public static char LIntCh(short x)
```

LIntCh
```
public static char LIntCh(int x)
```

LIntCh
```
public static char LIntCh(long x)
```

LIntCh

public static char LIntCh(BigInteger x)

LChIntIT8
```
public static byte LChIntIT8(char x)
```

LChIntIT16

public static short LChIntIT16(char x)

LChIntIT32
```
public static int LChIntIT32(char x)
```

LChIntIT64

public static long LChIntIT64(char x)

LChIntITBig

public static BigInteger LChIntITBig(char x)

LPrintNum

public static void LPrintNum(Object x)

LPrintStr

public static void LPrintStr(String x)

LReadStr

public static String LReadStr(Object x)

LStrHead

public static char LStrHead(String x)

LStrTail

public static String LStrTail(String x)

LStrCons

public static String LStrCons(char x,
              String y)

LStrIndex

public static char LStrIndex(String x,
             int y)

LStrRev

public static String LStrRev(String x)

LStdIn
```
public static InputStream LStdIn()
```

LStdOut
```
public static OutputStream LStdOut()
```

LStdErr
```
public static OutputStream LStdErr()
```

LAllocate

public static ByteBuffer LAllocate(long capacity)

LAppendBuffer

public static ByteBuffer LAppendBuffer(ByteBuffer to,
                       long toSize,
                       long count,
                       long fromSize,
                       long fromOffset,
                       ByteBuffer from)

LAppend

public static ByteBuffer LAppend(ByteOrder endianness,
                 ByteBuffer buffer,
                 long position,
                 long count,
                 byte value)

LAppend

public static ByteBuffer LAppend(ByteOrder endianness,
                 ByteBuffer buffer,
                 long position,
                 long count,
                 short value)

LAppend

public static ByteBuffer LAppend(ByteOrder endianness,
                 ByteBuffer buffer,
                 long position,
                 long count,
                 int value)

LAppend

public static ByteBuffer LAppend(ByteOrder endianness,
                 ByteBuffer buffer,
                 long position,
                 long count,
                 long value)

LPeekIT8

public static byte LPeekIT8(ByteOrder endianness,
            ByteBuffer buffer,
            long position)

LPeekIT16

public static short LPeekIT16(ByteOrder endianness,
              ByteBuffer buffer,
              long position)

LPeekIT32

public static int LPeekIT32(ByteOrder endianness,
            ByteBuffer buffer,
            long position)

LPeekIT64

public static long LPeekIT64(ByteOrder endianness,
             ByteBuffer buffer,
             long position)

LSystemInfo

public static String LSystemInfo(int index)

LVMPtr
```
public static Thread LVMPtr()
```

Class PrimFn

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

PrimFn

Method Detail

LPlus

LPlus

LPlus

LPlus

LPlus

LPlus

LPlus

LPlus

LPlus

LPlus

LPlus

LMinus

LMinus

LMinus

LMinus

LMinus

LMinus

LMinus

LMinus

LMinus

LMinus

LMinus

LTimes

LTimes

LTimes

LTimes

LTimes

LTimes

LTimes

LTimes

LTimes

LTimes

LTimes

LUDiv

LUDiv

LUDiv

LUDiv

LUDiv

LUDiv

LUDiv

LUDiv

LUDiv

LSDiv

LSDiv

LSDiv

LSDiv

LSDiv

LSDiv

LSDiv

LSDiv

LSDiv

LSDiv

LSDiv

LURem

LURem

LURem

LURem

LURem

LURem

LURem

LURem

LURem

LSRem

LSRem

LSRem

LSRem

LSRem

LSRem

LSRem

LSRem

LSRem

LSRem

LSRem