Tuple4U (magma-func 2.0.0 API)

java.lang.Object
- eu.lunisolar.magma.func.tuple.Tuple4U

public final class Tuple4U
extends Object

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T1,T2> LBiObjBoolTriple.MutBiObjBoolTriple<T1,T2>`	`biObjBoolTriple(T1 a1, T2 a2, boolean a3)`
`static <T1,T2> LBiObjByteTriple.MutBiObjByteTriple<T1,T2>`	`biObjByteTriple(T1 a1, T2 a2, byte a3)`
`static <T1,T2> LBiObjCharTriple.MutBiObjCharTriple<T1,T2>`	`biObjCharTriple(T1 a1, T2 a2, char a3)`
`static <T1,T2> LBiObjDblTriple.MutBiObjDblTriple<T1,T2>`	`biObjDblTriple(T1 a1, T2 a2, double a3)`
`static <T1,T2> LBiObjFltTriple.MutBiObjFltTriple<T1,T2>`	`biObjFltTriple(T1 a1, T2 a2, float a3)`
`static <T1,T2> LBiObjIntTriple.MutBiObjIntTriple<T1,T2>`	`biObjIntTriple(T1 a1, T2 a2, int a3)`
`static <T1,T2> LBiObjLongTriple.MutBiObjLongTriple<T1,T2>`	`biObjLongTriple(T1 a1, T2 a2, long a3)`
`static <T1,T2> LBiObjSrtTriple.MutBiObjSrtTriple<T1,T2>`	`biObjSrtTriple(T1 a1, T2 a2, short a3)`
`static LBoolIntPair.MutBoolIntPair`	`boolIntPair(boolean a1, int a2)`
`static LBoolPair.MutBoolPair`	`boolPair(boolean a1, boolean a2)`
`static LBoolSingle.MutBoolSingle`	`boolSingle(boolean a)`
`static LBoolTriple.MutBoolTriple`	`boolTriple(boolean a1, boolean a2, boolean a3)`
`static LByteIntPair.MutByteIntPair`	`byteIntPair(byte a1, int a2)`
`static LBytePair.MutBytePair`	`bytePair(byte a1, byte a2)`
`static LByteSingle.MutByteSingle`	`byteSingle(byte a)`
`static LCharIntPair.MutCharIntPair`	`charIntPair(char a1, int a2)`
`static LCharPair.MutCharPair`	`charPair(char a1, char a2)`
`static LCharSingle.MutCharSingle`	`charSingle(char a)`
`static LBoolSingle.MutCompBoolSingle`	`comparable(boolean a)`
`static LBoolPair.MutCompBoolPair`	`comparable(boolean a1, boolean a2)`
`static LBoolTriple.MutCompBoolTriple`	`comparable(boolean a1, boolean a2, boolean a3)`
`static LBoolIntPair.MutCompBoolIntPair`	`comparable(boolean a1, int a2)`
`static LByteSingle.MutCompByteSingle`	`comparable(byte a)`
`static LBytePair.MutCompBytePair`	`comparable(byte a1, byte a2)`
`static LByteIntPair.MutCompByteIntPair`	`comparable(byte a1, int a2)`
`static LCharSingle.MutCompCharSingle`	`comparable(char a)`
`static LCharPair.MutCompCharPair`	`comparable(char a1, char a2)`
`static LCharIntPair.MutCompCharIntPair`	`comparable(char a1, int a2)`
`static LDblSingle.MutCompDblSingle`	`comparable(double a)`
`static LDblPair.MutCompDblPair`	`comparable(double a1, double a2)`
`static LDblIntPair.MutCompDblIntPair`	`comparable(double a1, int a2)`
`static LFltSingle.MutCompFltSingle`	`comparable(float a)`
`static LFltPair.MutCompFltPair`	`comparable(float a1, float a2)`
`static LFltIntPair.MutCompFltIntPair`	`comparable(float a1, int a2)`
`static LIntSingle.MutCompIntSingle`	`comparable(int a)`
`static LIntPair.MutCompIntPair`	`comparable(int a1, int a2)`
`static LLongSingle.MutCompLongSingle`	`comparable(long a)`
`static LLongIntPair.MutCompLongIntPair`	`comparable(long a1, int a2)`
`static LLongPair.MutCompLongPair`	`comparable(long a1, long a2)`
`static LSrtSingle.MutCompSrtSingle`	`comparable(short a)`
`static LSrtIntPair.MutCompSrtIntPair`	`comparable(short a1, int a2)`
`static LSrtPair.MutCompSrtPair`	`comparable(short a1, short a2)`
`static <T extends Comparable<T>> LSingle.MutCompSingle<T>`	`comparable(T a)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LObjIntObjTriple.MutCompObjIntObjTriple<T1,T2>`	`comparable(T1 a1, int a2, T2 a3)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LPair.MutCompPair<T1,T2>`	`comparable(T1 a1, T2 a2)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjBoolTriple.MutCompBiObjBoolTriple<T1,T2>`	`comparable(T1 a1, T2 a2, boolean a3)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjByteTriple.MutCompBiObjByteTriple<T1,T2>`	`comparable(T1 a1, T2 a2, byte a3)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjCharTriple.MutCompBiObjCharTriple<T1,T2>`	`comparable(T1 a1, T2 a2, char a3)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjDblTriple.MutCompBiObjDblTriple<T1,T2>`	`comparable(T1 a1, T2 a2, double a3)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjFltTriple.MutCompBiObjFltTriple<T1,T2>`	`comparable(T1 a1, T2 a2, float a3)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjIntTriple.MutCompBiObjIntTriple<T1,T2>`	`comparable(T1 a1, T2 a2, int a3)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjLongTriple.MutCompBiObjLongTriple<T1,T2>`	`comparable(T1 a1, T2 a2, long a3)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjSrtTriple.MutCompBiObjSrtTriple<T1,T2>`	`comparable(T1 a1, T2 a2, short a3)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>,T3 extends Comparable<T3>> LTriple.MutCompTriple<T1,T2,T3>`	`comparable(T1 a1, T2 a2, T3 a3)`
`static <T extends Comparable<T>> LObjBoolPair.MutCompObjBoolPair<T>`	`comparable(T a1, boolean a2)`
`static <T extends Comparable<T>> LObjBytePair.MutCompObjBytePair<T>`	`comparable(T a1, byte a2)`
`static <T extends Comparable<T>> LObjCharPair.MutCompObjCharPair<T>`	`comparable(T a1, char a2)`
`static <T extends Comparable<T>> LObjDblPair.MutCompObjDblPair<T>`	`comparable(T a1, double a2)`
`static <T extends Comparable<T>> LObjFltPair.MutCompObjFltPair<T>`	`comparable(T a1, float a2)`
`static <T extends Comparable<T>> LObjIntPair.MutCompObjIntPair<T>`	`comparable(T a1, int a2)`
`static <T extends Comparable<T>> LObjIntBoolTriple.MutCompObjIntBoolTriple<T>`	`comparable(T a1, int a2, boolean a3)`
`static <T extends Comparable<T>> LObjIntByteTriple.MutCompObjIntByteTriple<T>`	`comparable(T a1, int a2, byte a3)`
`static <T extends Comparable<T>> LObjIntCharTriple.MutCompObjIntCharTriple<T>`	`comparable(T a1, int a2, char a3)`
`static <T extends Comparable<T>> LObjIntDblTriple.MutCompObjIntDblTriple<T>`	`comparable(T a1, int a2, double a3)`
`static <T extends Comparable<T>> LObjIntFltTriple.MutCompObjIntFltTriple<T>`	`comparable(T a1, int a2, float a3)`
`static <T extends Comparable<T>> LObjBiIntTriple.MutCompObjBiIntTriple<T>`	`comparable(T a1, int a2, int a3)`
`static <T extends Comparable<T>> LObjIntLongTriple.MutCompObjIntLongTriple<T>`	`comparable(T a1, int a2, long a3)`
`static <T extends Comparable<T>> LObjIntSrtTriple.MutCompObjIntSrtTriple<T>`	`comparable(T a1, int a2, short a3)`
`static <T extends Comparable<T>> LObjLongPair.MutCompObjLongPair<T>`	`comparable(T a1, long a2)`
`static <T extends Comparable<T>> LObjSrtPair.MutCompObjSrtPair<T>`	`comparable(T a1, short a2)`
`static LDblIntPair.MutDblIntPair`	`dblIntPair(double a1, int a2)`
`static LDblPair.MutDblPair`	`dblPair(double a1, double a2)`
`static LDblSingle.MutDblSingle`	`dblSingle(double a)`
`static LFltIntPair.MutFltIntPair`	`fltIntPair(float a1, int a2)`
`static LFltPair.MutFltPair`	`fltPair(float a1, float a2)`
`static LFltSingle.MutFltSingle`	`fltSingle(float a)`
`static LBoolSingle.ComparableBoolSingle`	`immComp(boolean a)`
`static LBoolPair.ComparableBoolPair`	`immComp(boolean a1, boolean a2)`
`static LBoolTriple.ComparableBoolTriple`	`immComp(boolean a1, boolean a2, boolean a3)`
`static LBoolIntPair.ComparableBoolIntPair`	`immComp(boolean a1, int a2)`
`static LByteSingle.ComparableByteSingle`	`immComp(byte a)`
`static LBytePair.ComparableBytePair`	`immComp(byte a1, byte a2)`
`static LByteIntPair.ComparableByteIntPair`	`immComp(byte a1, int a2)`
`static LCharSingle.ComparableCharSingle`	`immComp(char a)`
`static LCharPair.ComparableCharPair`	`immComp(char a1, char a2)`
`static LCharIntPair.ComparableCharIntPair`	`immComp(char a1, int a2)`
`static LDblSingle.ComparableDblSingle`	`immComp(double a)`
`static LDblPair.ComparableDblPair`	`immComp(double a1, double a2)`
`static LDblIntPair.ComparableDblIntPair`	`immComp(double a1, int a2)`
`static LFltSingle.ComparableFltSingle`	`immComp(float a)`
`static LFltPair.ComparableFltPair`	`immComp(float a1, float a2)`
`static LFltIntPair.ComparableFltIntPair`	`immComp(float a1, int a2)`
`static LIntSingle.ComparableIntSingle`	`immComp(int a)`
`static LIntPair.ComparableIntPair`	`immComp(int a1, int a2)`
`static LLongSingle.ComparableLongSingle`	`immComp(long a)`
`static LLongIntPair.ComparableLongIntPair`	`immComp(long a1, int a2)`
`static LLongPair.ComparableLongPair`	`immComp(long a1, long a2)`
`static LSrtSingle.ComparableSrtSingle`	`immComp(short a)`
`static LSrtIntPair.ComparableSrtIntPair`	`immComp(short a1, int a2)`
`static LSrtPair.ComparableSrtPair`	`immComp(short a1, short a2)`
`static <T extends Comparable<T>> LSingle.ComparableSingle`	`immComp(T a)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LObjIntObjTriple.ComparableObjIntObjTriple`	`immComp(T1 a1, int a2, T2 a3)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LPair.ComparablePair`	`immComp(T1 a1, T2 a2)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjBoolTriple.ComparableBiObjBoolTriple`	`immComp(T1 a1, T2 a2, boolean a3)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjByteTriple.ComparableBiObjByteTriple`	`immComp(T1 a1, T2 a2, byte a3)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjCharTriple.ComparableBiObjCharTriple`	`immComp(T1 a1, T2 a2, char a3)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjDblTriple.ComparableBiObjDblTriple`	`immComp(T1 a1, T2 a2, double a3)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjFltTriple.ComparableBiObjFltTriple`	`immComp(T1 a1, T2 a2, float a3)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjIntTriple.ComparableBiObjIntTriple`	`immComp(T1 a1, T2 a2, int a3)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjLongTriple.ComparableBiObjLongTriple`	`immComp(T1 a1, T2 a2, long a3)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjSrtTriple.ComparableBiObjSrtTriple`	`immComp(T1 a1, T2 a2, short a3)`
`static <T1 extends Comparable<T1>,T2 extends Comparable<T2>,T3 extends Comparable<T3>> LTriple.ComparableTriple`	`immComp(T1 a1, T2 a2, T3 a3)`
`static <T extends Comparable<T>> LObjBoolPair.ComparableObjBoolPair`	`immComp(T a1, boolean a2)`
`static <T extends Comparable<T>> LObjBytePair.ComparableObjBytePair`	`immComp(T a1, byte a2)`
`static <T extends Comparable<T>> LObjCharPair.ComparableObjCharPair`	`immComp(T a1, char a2)`
`static <T extends Comparable<T>> LObjDblPair.ComparableObjDblPair`	`immComp(T a1, double a2)`
`static <T extends Comparable<T>> LObjFltPair.ComparableObjFltPair`	`immComp(T a1, float a2)`
`static <T extends Comparable<T>> LObjIntPair.ComparableObjIntPair`	`immComp(T a1, int a2)`
`static <T extends Comparable<T>> LObjIntBoolTriple.ComparableObjIntBoolTriple`	`immComp(T a1, int a2, boolean a3)`
`static <T extends Comparable<T>> LObjIntByteTriple.ComparableObjIntByteTriple`	`immComp(T a1, int a2, byte a3)`
`static <T extends Comparable<T>> LObjIntCharTriple.ComparableObjIntCharTriple`	`immComp(T a1, int a2, char a3)`
`static <T extends Comparable<T>> LObjIntDblTriple.ComparableObjIntDblTriple`	`immComp(T a1, int a2, double a3)`
`static <T extends Comparable<T>> LObjIntFltTriple.ComparableObjIntFltTriple`	`immComp(T a1, int a2, float a3)`
`static <T extends Comparable<T>> LObjBiIntTriple.ComparableObjBiIntTriple`	`immComp(T a1, int a2, int a3)`
`static <T extends Comparable<T>> LObjIntLongTriple.ComparableObjIntLongTriple`	`immComp(T a1, int a2, long a3)`
`static <T extends Comparable<T>> LObjIntSrtTriple.ComparableObjIntSrtTriple`	`immComp(T a1, int a2, short a3)`
`static <T extends Comparable<T>> LObjLongPair.ComparableObjLongPair`	`immComp(T a1, long a2)`
`static <T extends Comparable<T>> LObjSrtPair.ComparableObjSrtPair`	`immComp(T a1, short a2)`
`static LBoolSingle`	`immutable(boolean a)`
`static LBoolPair`	`immutable(boolean a1, boolean a2)`
`static LBoolTriple`	`immutable(boolean a1, boolean a2, boolean a3)`
`static LBoolIntPair`	`immutable(boolean a1, int a2)`
`static LByteSingle`	`immutable(byte a)`
`static LBytePair`	`immutable(byte a1, byte a2)`
`static LByteIntPair`	`immutable(byte a1, int a2)`
`static LCharSingle`	`immutable(char a)`
`static LCharPair`	`immutable(char a1, char a2)`
`static LCharIntPair`	`immutable(char a1, int a2)`
`static LDblSingle`	`immutable(double a)`
`static LDblPair`	`immutable(double a1, double a2)`
`static LDblIntPair`	`immutable(double a1, int a2)`
`static LFltSingle`	`immutable(float a)`
`static LFltPair`	`immutable(float a1, float a2)`
`static LFltIntPair`	`immutable(float a1, int a2)`
`static LIntSingle`	`immutable(int a)`
`static LIntPair`	`immutable(int a1, int a2)`
`static LLongSingle`	`immutable(long a)`
`static LLongIntPair`	`immutable(long a1, int a2)`
`static LLongPair`	`immutable(long a1, long a2)`
`static LSrtSingle`	`immutable(short a)`
`static LSrtIntPair`	`immutable(short a1, int a2)`
`static LSrtPair`	`immutable(short a1, short a2)`
`static <T> LSingle<T>`	`immutable(T a)`
`static <T1,T2> LObjIntObjTriple<T1,T2>`	`immutable(T1 a1, int a2, T2 a3)`
`static <T1,T2> LPair<T1,T2>`	`immutable(T1 a1, T2 a2)`
`static <T1,T2> LBiObjBoolTriple<T1,T2>`	`immutable(T1 a1, T2 a2, boolean a3)`
`static <T1,T2> LBiObjByteTriple<T1,T2>`	`immutable(T1 a1, T2 a2, byte a3)`
`static <T1,T2> LBiObjCharTriple<T1,T2>`	`immutable(T1 a1, T2 a2, char a3)`
`static <T1,T2> LBiObjDblTriple<T1,T2>`	`immutable(T1 a1, T2 a2, double a3)`
`static <T1,T2> LBiObjFltTriple<T1,T2>`	`immutable(T1 a1, T2 a2, float a3)`
`static <T1,T2> LBiObjIntTriple<T1,T2>`	`immutable(T1 a1, T2 a2, int a3)`
`static <T1,T2> LBiObjLongTriple<T1,T2>`	`immutable(T1 a1, T2 a2, long a3)`
`static <T1,T2> LBiObjSrtTriple<T1,T2>`	`immutable(T1 a1, T2 a2, short a3)`
`static <T1,T2,T3> LTriple<T1,T2,T3>`	`immutable(T1 a1, T2 a2, T3 a3)`
`static <T> LObjBoolPair<T>`	`immutable(T a1, boolean a2)`
`static <T> LObjBytePair<T>`	`immutable(T a1, byte a2)`
`static <T> LObjCharPair<T>`	`immutable(T a1, char a2)`
`static <T> LObjDblPair<T>`	`immutable(T a1, double a2)`
`static <T> LObjFltPair<T>`	`immutable(T a1, float a2)`
`static <T> LObjIntPair<T>`	`immutable(T a1, int a2)`
`static <T> LObjIntBoolTriple<T>`	`immutable(T a1, int a2, boolean a3)`
`static <T> LObjIntByteTriple<T>`	`immutable(T a1, int a2, byte a3)`
`static <T> LObjIntCharTriple<T>`	`immutable(T a1, int a2, char a3)`
`static <T> LObjIntDblTriple<T>`	`immutable(T a1, int a2, double a3)`
`static <T> LObjIntFltTriple<T>`	`immutable(T a1, int a2, float a3)`
`static <T> LObjBiIntTriple<T>`	`immutable(T a1, int a2, int a3)`
`static <T> LObjIntLongTriple<T>`	`immutable(T a1, int a2, long a3)`
`static <T> LObjIntSrtTriple<T>`	`immutable(T a1, int a2, short a3)`
`static <T> LObjLongPair<T>`	`immutable(T a1, long a2)`
`static <T> LObjSrtPair<T>`	`immutable(T a1, short a2)`
`static LIntPair.MutIntPair`	`intPair(int a1, int a2)`
`static LIntSingle.MutIntSingle`	`intSingle(int a)`
`static LLongIntPair.MutLongIntPair`	`longIntPair(long a1, int a2)`
`static LLongPair.MutLongPair`	`longPair(long a1, long a2)`
`static LLongSingle.MutLongSingle`	`longSingle(long a)`
`static <T> LObjBiIntTriple.MutObjBiIntTriple<T>`	`objBiIntTriple(T a1, int a2, int a3)`
`static <T> LObjBoolPair.MutObjBoolPair<T>`	`objBoolPair(T a1, boolean a2)`
`static <T> LObjBytePair.MutObjBytePair<T>`	`objBytePair(T a1, byte a2)`
`static <T> LObjCharPair.MutObjCharPair<T>`	`objCharPair(T a1, char a2)`
`static <T> LObjDblPair.MutObjDblPair<T>`	`objDblPair(T a1, double a2)`
`static <T> LObjFltPair.MutObjFltPair<T>`	`objFltPair(T a1, float a2)`
`static <T> LObjIntBoolTriple.MutObjIntBoolTriple<T>`	`objIntBoolTriple(T a1, int a2, boolean a3)`
`static <T> LObjIntByteTriple.MutObjIntByteTriple<T>`	`objIntByteTriple(T a1, int a2, byte a3)`
`static <T> LObjIntCharTriple.MutObjIntCharTriple<T>`	`objIntCharTriple(T a1, int a2, char a3)`
`static <T> LObjIntDblTriple.MutObjIntDblTriple<T>`	`objIntDblTriple(T a1, int a2, double a3)`
`static <T> LObjIntFltTriple.MutObjIntFltTriple<T>`	`objIntFltTriple(T a1, int a2, float a3)`
`static <T> LObjIntLongTriple.MutObjIntLongTriple<T>`	`objIntLongTriple(T a1, int a2, long a3)`
`static <T1,T2> LObjIntObjTriple.MutObjIntObjTriple<T1,T2>`	`objIntObjTriple(T1 a1, int a2, T2 a3)`
`static <T> LObjIntPair.MutObjIntPair<T>`	`objIntPair(T a1, int a2)`
`static <T> LObjIntSrtTriple.MutObjIntSrtTriple<T>`	`objIntSrtTriple(T a1, int a2, short a3)`
`static <T> LObjLongPair.MutObjLongPair<T>`	`objLongPair(T a1, long a2)`
`static <T> LObjSrtPair.MutObjSrtPair<T>`	`objSrtPair(T a1, short a2)`
`static <T1,T2> LPair.MutPair<T1,T2>`	`pair(T1 a1, T2 a2)`
`static <T> LSingle.MutSingle<T>`	`single(T a)`
`static LSrtIntPair.MutSrtIntPair`	`srtIntPair(short a1, int a2)`
`static LSrtPair.MutSrtPair`	`srtPair(short a1, short a2)`
`static LSrtSingle.MutSrtSingle`	`srtSingle(short a)`
`static <T1,T2,T3> LTriple.MutTriple<T1,T2,T3>`	`triple(T1 a1, T2 a2, T3 a3)`
`static LTuple.Void`	`tuple()`
`static LBoolSingle.MutBoolSingle`	`tuple(boolean a)`
`static LBoolPair.MutBoolPair`	`tuple(boolean a1, boolean a2)`
`static LBoolTriple.MutBoolTriple`	`tuple(boolean a1, boolean a2, boolean a3)`
`static LBoolIntPair.MutBoolIntPair`	`tuple(boolean a1, int a2)`
`static LByteSingle.MutByteSingle`	`tuple(byte a)`
`static LBytePair.MutBytePair`	`tuple(byte a1, byte a2)`
`static LByteIntPair.MutByteIntPair`	`tuple(byte a1, int a2)`
`static LCharSingle.MutCharSingle`	`tuple(char a)`
`static LCharPair.MutCharPair`	`tuple(char a1, char a2)`
`static LCharIntPair.MutCharIntPair`	`tuple(char a1, int a2)`
`static LDblSingle.MutDblSingle`	`tuple(double a)`
`static LDblPair.MutDblPair`	`tuple(double a1, double a2)`
`static LDblIntPair.MutDblIntPair`	`tuple(double a1, int a2)`
`static LFltSingle.MutFltSingle`	`tuple(float a)`
`static LFltPair.MutFltPair`	`tuple(float a1, float a2)`
`static LFltIntPair.MutFltIntPair`	`tuple(float a1, int a2)`
`static LIntSingle.MutIntSingle`	`tuple(int a)`
`static LIntPair.MutIntPair`	`tuple(int a1, int a2)`
`static LLongSingle.MutLongSingle`	`tuple(long a)`
`static LLongIntPair.MutLongIntPair`	`tuple(long a1, int a2)`
`static LLongPair.MutLongPair`	`tuple(long a1, long a2)`
`static LSrtSingle.MutSrtSingle`	`tuple(short a)`
`static LSrtIntPair.MutSrtIntPair`	`tuple(short a1, int a2)`
`static LSrtPair.MutSrtPair`	`tuple(short a1, short a2)`
`static <T> LSingle.MutSingle<T>`	`tuple(T a)`
`static <T1,T2> LObjIntObjTriple.MutObjIntObjTriple<T1,T2>`	`tuple(T1 a1, int a2, T2 a3)`
`static <T1,T2> LPair.MutPair<T1,T2>`	`tuple(T1 a1, T2 a2)`
`static <T1,T2> LBiObjBoolTriple.MutBiObjBoolTriple<T1,T2>`	`tuple(T1 a1, T2 a2, boolean a3)`
`static <T1,T2> LBiObjByteTriple.MutBiObjByteTriple<T1,T2>`	`tuple(T1 a1, T2 a2, byte a3)`
`static <T1,T2> LBiObjCharTriple.MutBiObjCharTriple<T1,T2>`	`tuple(T1 a1, T2 a2, char a3)`
`static <T1,T2> LBiObjDblTriple.MutBiObjDblTriple<T1,T2>`	`tuple(T1 a1, T2 a2, double a3)`
`static <T1,T2> LBiObjFltTriple.MutBiObjFltTriple<T1,T2>`	`tuple(T1 a1, T2 a2, float a3)`
`static <T1,T2> LBiObjIntTriple.MutBiObjIntTriple<T1,T2>`	`tuple(T1 a1, T2 a2, int a3)`
`static <T1,T2> LBiObjLongTriple.MutBiObjLongTriple<T1,T2>`	`tuple(T1 a1, T2 a2, long a3)`
`static <T1,T2> LBiObjSrtTriple.MutBiObjSrtTriple<T1,T2>`	`tuple(T1 a1, T2 a2, short a3)`
`static <T1,T2,T3> LTriple.MutTriple<T1,T2,T3>`	`tuple(T1 a1, T2 a2, T3 a3)`
`static <T> LObjBoolPair.MutObjBoolPair<T>`	`tuple(T a1, boolean a2)`
`static <T> LObjBytePair.MutObjBytePair<T>`	`tuple(T a1, byte a2)`
`static <T> LObjCharPair.MutObjCharPair<T>`	`tuple(T a1, char a2)`
`static <T> LObjDblPair.MutObjDblPair<T>`	`tuple(T a1, double a2)`
`static <T> LObjFltPair.MutObjFltPair<T>`	`tuple(T a1, float a2)`
`static <T> LObjIntPair.MutObjIntPair<T>`	`tuple(T a1, int a2)`
`static <T> LObjIntBoolTriple.MutObjIntBoolTriple<T>`	`tuple(T a1, int a2, boolean a3)`
`static <T> LObjIntByteTriple.MutObjIntByteTriple<T>`	`tuple(T a1, int a2, byte a3)`
`static <T> LObjIntCharTriple.MutObjIntCharTriple<T>`	`tuple(T a1, int a2, char a3)`
`static <T> LObjIntDblTriple.MutObjIntDblTriple<T>`	`tuple(T a1, int a2, double a3)`
`static <T> LObjIntFltTriple.MutObjIntFltTriple<T>`	`tuple(T a1, int a2, float a3)`
`static <T> LObjBiIntTriple.MutObjBiIntTriple<T>`	`tuple(T a1, int a2, int a3)`
`static <T> LObjIntLongTriple.MutObjIntLongTriple<T>`	`tuple(T a1, int a2, long a3)`
`static <T> LObjIntSrtTriple.MutObjIntSrtTriple<T>`	`tuple(T a1, int a2, short a3)`
`static <T> LObjLongPair.MutObjLongPair<T>`	`tuple(T a1, long a2)`
`static <T> LObjSrtPair.MutObjSrtPair<T>`	`tuple(T a1, short a2)`

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

Method Detail

tuple

public static <T1,T2> LPair.MutPair<T1,T2> tuple(T1 a1,
                                                 T2 a2)

pair

public static <T1,T2> LPair.MutPair<T1,T2> pair(T1 a1,
                                                T2 a2)

comparable

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LPair.MutCompPair<T1,T2> comparable(T1 a1,
                                                                                                        T2 a2)

immutable

public static <T1,T2> LPair<T1,T2> immutable(T1 a1,
                                             T2 a2)

immComp

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LPair.ComparablePair immComp(T1 a1,
                                                                                                 T2 a2)

tuple

public static <T> LSingle.MutSingle<T> tuple(T a)

single

public static <T> LSingle.MutSingle<T> single(T a)

comparable

public static <T extends Comparable<T>> LSingle.MutCompSingle<T> comparable(T a)

immutable

public static <T> LSingle<T> immutable(T a)

immComp

public static <T extends Comparable<T>> LSingle.ComparableSingle immComp(T a)

tuple

public static <T1,T2,T3> LTriple.MutTriple<T1,T2,T3> tuple(T1 a1,
                                                           T2 a2,
                                                           T3 a3)

triple

public static <T1,T2,T3> LTriple.MutTriple<T1,T2,T3> triple(T1 a1,
                                                            T2 a2,
                                                            T3 a3)

comparable

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>,T3 extends Comparable<T3>> LTriple.MutCompTriple<T1,T2,T3> comparable(T1 a1,
                                                                                                                                         T2 a2,
                                                                                                                                         T3 a3)

immutable

public static <T1,T2,T3> LTriple<T1,T2,T3> immutable(T1 a1,
                                                     T2 a2,
                                                     T3 a3)

immComp

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>,T3 extends Comparable<T3>> LTriple.ComparableTriple immComp(T1 a1,
                                                                                                                               T2 a2,
                                                                                                                               T3 a3)

tuple

public static LBoolSingle.MutBoolSingle tuple(boolean a)

boolSingle

public static LBoolSingle.MutBoolSingle boolSingle(boolean a)

comparable

public static LBoolSingle.MutCompBoolSingle comparable(boolean a)

immutable

public static LBoolSingle immutable(boolean a)

immComp

public static LBoolSingle.ComparableBoolSingle immComp(boolean a)

tuple

public static LByteSingle.MutByteSingle tuple(byte a)

byteSingle

public static LByteSingle.MutByteSingle byteSingle(byte a)

comparable

public static LByteSingle.MutCompByteSingle comparable(byte a)

immutable

public static LByteSingle immutable(byte a)

immComp

public static LByteSingle.ComparableByteSingle immComp(byte a)

tuple

public static LCharSingle.MutCharSingle tuple(char a)

charSingle

public static LCharSingle.MutCharSingle charSingle(char a)

comparable

public static LCharSingle.MutCompCharSingle comparable(char a)

immutable

public static LCharSingle immutable(char a)

immComp

public static LCharSingle.ComparableCharSingle immComp(char a)

tuple

public static LDblSingle.MutDblSingle tuple(double a)

dblSingle

public static LDblSingle.MutDblSingle dblSingle(double a)

comparable

public static LDblSingle.MutCompDblSingle comparable(double a)

immutable

public static LDblSingle immutable(double a)

immComp

public static LDblSingle.ComparableDblSingle immComp(double a)

tuple

public static LFltSingle.MutFltSingle tuple(float a)

fltSingle

public static LFltSingle.MutFltSingle fltSingle(float a)

comparable

public static LFltSingle.MutCompFltSingle comparable(float a)

immutable

public static LFltSingle immutable(float a)

immComp

public static LFltSingle.ComparableFltSingle immComp(float a)

tuple

public static LIntSingle.MutIntSingle tuple(int a)

intSingle

public static LIntSingle.MutIntSingle intSingle(int a)

comparable

public static LIntSingle.MutCompIntSingle comparable(int a)

immutable

public static LIntSingle immutable(int a)

immComp

public static LIntSingle.ComparableIntSingle immComp(int a)

tuple

public static LLongSingle.MutLongSingle tuple(long a)

longSingle

public static LLongSingle.MutLongSingle longSingle(long a)

comparable

public static LLongSingle.MutCompLongSingle comparable(long a)

immutable

public static LLongSingle immutable(long a)

immComp

public static LLongSingle.ComparableLongSingle immComp(long a)

tuple

public static LSrtSingle.MutSrtSingle tuple(short a)

srtSingle

public static LSrtSingle.MutSrtSingle srtSingle(short a)

comparable

public static LSrtSingle.MutCompSrtSingle comparable(short a)

immutable

public static LSrtSingle immutable(short a)

immComp

public static LSrtSingle.ComparableSrtSingle immComp(short a)

tuple

public static LBoolPair.MutBoolPair tuple(boolean a1,
                                          boolean a2)

boolPair

public static LBoolPair.MutBoolPair boolPair(boolean a1,
                                             boolean a2)

comparable

public static LBoolPair.MutCompBoolPair comparable(boolean a1,
                                                   boolean a2)

immutable

public static LBoolPair immutable(boolean a1,
                                  boolean a2)

immComp

public static LBoolPair.ComparableBoolPair immComp(boolean a1,
                                                   boolean a2)

tuple

public static LBytePair.MutBytePair tuple(byte a1,
                                          byte a2)

bytePair

public static LBytePair.MutBytePair bytePair(byte a1,
                                             byte a2)

comparable

public static LBytePair.MutCompBytePair comparable(byte a1,
                                                   byte a2)

immutable

public static LBytePair immutable(byte a1,
                                  byte a2)

immComp

public static LBytePair.ComparableBytePair immComp(byte a1,
                                                   byte a2)

tuple

public static LCharPair.MutCharPair tuple(char a1,
                                          char a2)

charPair

public static LCharPair.MutCharPair charPair(char a1,
                                             char a2)

comparable

public static LCharPair.MutCompCharPair comparable(char a1,
                                                   char a2)

immutable

public static LCharPair immutable(char a1,
                                  char a2)

immComp

public static LCharPair.ComparableCharPair immComp(char a1,
                                                   char a2)

tuple

public static LDblPair.MutDblPair tuple(double a1,
                                        double a2)

dblPair

public static LDblPair.MutDblPair dblPair(double a1,
                                          double a2)

comparable

public static LDblPair.MutCompDblPair comparable(double a1,
                                                 double a2)

immutable

public static LDblPair immutable(double a1,
                                 double a2)

immComp

public static LDblPair.ComparableDblPair immComp(double a1,
                                                 double a2)

tuple

public static LFltPair.MutFltPair tuple(float a1,
                                        float a2)

fltPair

public static LFltPair.MutFltPair fltPair(float a1,
                                          float a2)

comparable

public static LFltPair.MutCompFltPair comparable(float a1,
                                                 float a2)

immutable

public static LFltPair immutable(float a1,
                                 float a2)

immComp

public static LFltPair.ComparableFltPair immComp(float a1,
                                                 float a2)

tuple

public static LIntPair.MutIntPair tuple(int a1,
                                        int a2)

intPair

public static LIntPair.MutIntPair intPair(int a1,
                                          int a2)

comparable

public static LIntPair.MutCompIntPair comparable(int a1,
                                                 int a2)

immutable

public static LIntPair immutable(int a1,
                                 int a2)

immComp

public static LIntPair.ComparableIntPair immComp(int a1,
                                                 int a2)

tuple

public static LLongPair.MutLongPair tuple(long a1,
                                          long a2)

longPair

public static LLongPair.MutLongPair longPair(long a1,
                                             long a2)

comparable

public static LLongPair.MutCompLongPair comparable(long a1,
                                                   long a2)

immutable

public static LLongPair immutable(long a1,
                                  long a2)

immComp

public static LLongPair.ComparableLongPair immComp(long a1,
                                                   long a2)

tuple

public static LSrtPair.MutSrtPair tuple(short a1,
                                        short a2)

srtPair

public static LSrtPair.MutSrtPair srtPair(short a1,
                                          short a2)

comparable

public static LSrtPair.MutCompSrtPair comparable(short a1,
                                                 short a2)

immutable

public static LSrtPair immutable(short a1,
                                 short a2)

immComp

public static LSrtPair.ComparableSrtPair immComp(short a1,
                                                 short a2)

tuple

public static LBoolIntPair.MutBoolIntPair tuple(boolean a1,
                                                int a2)

boolIntPair

public static LBoolIntPair.MutBoolIntPair boolIntPair(boolean a1,
                                                      int a2)

comparable

public static LBoolIntPair.MutCompBoolIntPair comparable(boolean a1,
                                                         int a2)

immutable

public static LBoolIntPair immutable(boolean a1,
                                     int a2)

immComp

public static LBoolIntPair.ComparableBoolIntPair immComp(boolean a1,
                                                         int a2)

tuple

public static LByteIntPair.MutByteIntPair tuple(byte a1,
                                                int a2)

byteIntPair

public static LByteIntPair.MutByteIntPair byteIntPair(byte a1,
                                                      int a2)

comparable

public static LByteIntPair.MutCompByteIntPair comparable(byte a1,
                                                         int a2)

immutable

public static LByteIntPair immutable(byte a1,
                                     int a2)

immComp

public static LByteIntPair.ComparableByteIntPair immComp(byte a1,
                                                         int a2)

tuple

public static LCharIntPair.MutCharIntPair tuple(char a1,
                                                int a2)

charIntPair

public static LCharIntPair.MutCharIntPair charIntPair(char a1,
                                                      int a2)

comparable

public static LCharIntPair.MutCompCharIntPair comparable(char a1,
                                                         int a2)

immutable

public static LCharIntPair immutable(char a1,
                                     int a2)

immComp

public static LCharIntPair.ComparableCharIntPair immComp(char a1,
                                                         int a2)

tuple

public static LDblIntPair.MutDblIntPair tuple(double a1,
                                              int a2)

dblIntPair

public static LDblIntPair.MutDblIntPair dblIntPair(double a1,
                                                   int a2)

comparable

public static LDblIntPair.MutCompDblIntPair comparable(double a1,
                                                       int a2)

immutable

public static LDblIntPair immutable(double a1,
                                    int a2)

immComp

public static LDblIntPair.ComparableDblIntPair immComp(double a1,
                                                       int a2)

tuple

public static LFltIntPair.MutFltIntPair tuple(float a1,
                                              int a2)

fltIntPair

public static LFltIntPair.MutFltIntPair fltIntPair(float a1,
                                                   int a2)

comparable

public static LFltIntPair.MutCompFltIntPair comparable(float a1,
                                                       int a2)

immutable

public static LFltIntPair immutable(float a1,
                                    int a2)

immComp

public static LFltIntPair.ComparableFltIntPair immComp(float a1,
                                                       int a2)

tuple

public static LLongIntPair.MutLongIntPair tuple(long a1,
                                                int a2)

longIntPair

public static LLongIntPair.MutLongIntPair longIntPair(long a1,
                                                      int a2)

comparable

public static LLongIntPair.MutCompLongIntPair comparable(long a1,
                                                         int a2)

immutable

public static LLongIntPair immutable(long a1,
                                     int a2)

immComp

public static LLongIntPair.ComparableLongIntPair immComp(long a1,
                                                         int a2)

tuple

public static LSrtIntPair.MutSrtIntPair tuple(short a1,
                                              int a2)

srtIntPair

public static LSrtIntPair.MutSrtIntPair srtIntPair(short a1,
                                                   int a2)

comparable

public static LSrtIntPair.MutCompSrtIntPair comparable(short a1,
                                                       int a2)

immutable

public static LSrtIntPair immutable(short a1,
                                    int a2)

immComp

public static LSrtIntPair.ComparableSrtIntPair immComp(short a1,
                                                       int a2)

tuple

public static <T1,T2> LBiObjBoolTriple.MutBiObjBoolTriple<T1,T2> tuple(T1 a1,
                                                                       T2 a2,
                                                                       boolean a3)

biObjBoolTriple

public static <T1,T2> LBiObjBoolTriple.MutBiObjBoolTriple<T1,T2> biObjBoolTriple(T1 a1,
                                                                                 T2 a2,
                                                                                 boolean a3)

comparable

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjBoolTriple.MutCompBiObjBoolTriple<T1,T2> comparable(T1 a1,
                                                                                                                              T2 a2,
                                                                                                                              boolean a3)

immutable

public static <T1,T2> LBiObjBoolTriple<T1,T2> immutable(T1 a1,
                                                        T2 a2,
                                                        boolean a3)

immComp

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjBoolTriple.ComparableBiObjBoolTriple immComp(T1 a1,
                                                                                                                       T2 a2,
                                                                                                                       boolean a3)

tuple

public static <T1,T2> LBiObjByteTriple.MutBiObjByteTriple<T1,T2> tuple(T1 a1,
                                                                       T2 a2,
                                                                       byte a3)

biObjByteTriple

public static <T1,T2> LBiObjByteTriple.MutBiObjByteTriple<T1,T2> biObjByteTriple(T1 a1,
                                                                                 T2 a2,
                                                                                 byte a3)

comparable

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjByteTriple.MutCompBiObjByteTriple<T1,T2> comparable(T1 a1,
                                                                                                                              T2 a2,
                                                                                                                              byte a3)

immutable

public static <T1,T2> LBiObjByteTriple<T1,T2> immutable(T1 a1,
                                                        T2 a2,
                                                        byte a3)

immComp

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjByteTriple.ComparableBiObjByteTriple immComp(T1 a1,
                                                                                                                       T2 a2,
                                                                                                                       byte a3)

tuple

public static <T1,T2> LBiObjCharTriple.MutBiObjCharTriple<T1,T2> tuple(T1 a1,
                                                                       T2 a2,
                                                                       char a3)

biObjCharTriple

public static <T1,T2> LBiObjCharTriple.MutBiObjCharTriple<T1,T2> biObjCharTriple(T1 a1,
                                                                                 T2 a2,
                                                                                 char a3)

comparable

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjCharTriple.MutCompBiObjCharTriple<T1,T2> comparable(T1 a1,
                                                                                                                              T2 a2,
                                                                                                                              char a3)

immutable

public static <T1,T2> LBiObjCharTriple<T1,T2> immutable(T1 a1,
                                                        T2 a2,
                                                        char a3)

immComp

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjCharTriple.ComparableBiObjCharTriple immComp(T1 a1,
                                                                                                                       T2 a2,
                                                                                                                       char a3)

tuple

public static <T1,T2> LBiObjDblTriple.MutBiObjDblTriple<T1,T2> tuple(T1 a1,
                                                                     T2 a2,
                                                                     double a3)

biObjDblTriple

public static <T1,T2> LBiObjDblTriple.MutBiObjDblTriple<T1,T2> biObjDblTriple(T1 a1,
                                                                              T2 a2,
                                                                              double a3)

comparable

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjDblTriple.MutCompBiObjDblTriple<T1,T2> comparable(T1 a1,
                                                                                                                            T2 a2,
                                                                                                                            double a3)

immutable

public static <T1,T2> LBiObjDblTriple<T1,T2> immutable(T1 a1,
                                                       T2 a2,
                                                       double a3)

immComp

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjDblTriple.ComparableBiObjDblTriple immComp(T1 a1,
                                                                                                                     T2 a2,
                                                                                                                     double a3)

tuple

public static <T1,T2> LBiObjFltTriple.MutBiObjFltTriple<T1,T2> tuple(T1 a1,
                                                                     T2 a2,
                                                                     float a3)

biObjFltTriple

public static <T1,T2> LBiObjFltTriple.MutBiObjFltTriple<T1,T2> biObjFltTriple(T1 a1,
                                                                              T2 a2,
                                                                              float a3)

comparable

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjFltTriple.MutCompBiObjFltTriple<T1,T2> comparable(T1 a1,
                                                                                                                            T2 a2,
                                                                                                                            float a3)

immutable

public static <T1,T2> LBiObjFltTriple<T1,T2> immutable(T1 a1,
                                                       T2 a2,
                                                       float a3)

immComp

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjFltTriple.ComparableBiObjFltTriple immComp(T1 a1,
                                                                                                                     T2 a2,
                                                                                                                     float a3)

tuple

public static <T1,T2> LBiObjIntTriple.MutBiObjIntTriple<T1,T2> tuple(T1 a1,
                                                                     T2 a2,
                                                                     int a3)

biObjIntTriple

public static <T1,T2> LBiObjIntTriple.MutBiObjIntTriple<T1,T2> biObjIntTriple(T1 a1,
                                                                              T2 a2,
                                                                              int a3)

comparable

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjIntTriple.MutCompBiObjIntTriple<T1,T2> comparable(T1 a1,
                                                                                                                            T2 a2,
                                                                                                                            int a3)

immutable

public static <T1,T2> LBiObjIntTriple<T1,T2> immutable(T1 a1,
                                                       T2 a2,
                                                       int a3)

immComp

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjIntTriple.ComparableBiObjIntTriple immComp(T1 a1,
                                                                                                                     T2 a2,
                                                                                                                     int a3)

tuple

public static <T1,T2> LBiObjLongTriple.MutBiObjLongTriple<T1,T2> tuple(T1 a1,
                                                                       T2 a2,
                                                                       long a3)

biObjLongTriple

public static <T1,T2> LBiObjLongTriple.MutBiObjLongTriple<T1,T2> biObjLongTriple(T1 a1,
                                                                                 T2 a2,
                                                                                 long a3)

comparable

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjLongTriple.MutCompBiObjLongTriple<T1,T2> comparable(T1 a1,
                                                                                                                              T2 a2,
                                                                                                                              long a3)

immutable

public static <T1,T2> LBiObjLongTriple<T1,T2> immutable(T1 a1,
                                                        T2 a2,
                                                        long a3)

immComp

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjLongTriple.ComparableBiObjLongTriple immComp(T1 a1,
                                                                                                                       T2 a2,
                                                                                                                       long a3)

tuple

public static <T1,T2> LBiObjSrtTriple.MutBiObjSrtTriple<T1,T2> tuple(T1 a1,
                                                                     T2 a2,
                                                                     short a3)

biObjSrtTriple

public static <T1,T2> LBiObjSrtTriple.MutBiObjSrtTriple<T1,T2> biObjSrtTriple(T1 a1,
                                                                              T2 a2,
                                                                              short a3)

comparable

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjSrtTriple.MutCompBiObjSrtTriple<T1,T2> comparable(T1 a1,
                                                                                                                            T2 a2,
                                                                                                                            short a3)

immutable

public static <T1,T2> LBiObjSrtTriple<T1,T2> immutable(T1 a1,
                                                       T2 a2,
                                                       short a3)

immComp

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LBiObjSrtTriple.ComparableBiObjSrtTriple immComp(T1 a1,
                                                                                                                     T2 a2,
                                                                                                                     short a3)

tuple

public static <T> LObjBoolPair.MutObjBoolPair<T> tuple(T a1,
                                                       boolean a2)

objBoolPair

public static <T> LObjBoolPair.MutObjBoolPair<T> objBoolPair(T a1,
                                                             boolean a2)

comparable

public static <T extends Comparable<T>> LObjBoolPair.MutCompObjBoolPair<T> comparable(T a1,
                                                                                      boolean a2)

immutable

public static <T> LObjBoolPair<T> immutable(T a1,
                                            boolean a2)

immComp

public static <T extends Comparable<T>> LObjBoolPair.ComparableObjBoolPair immComp(T a1,
                                                                                   boolean a2)

tuple

public static <T> LObjBytePair.MutObjBytePair<T> tuple(T a1,
                                                       byte a2)

objBytePair

public static <T> LObjBytePair.MutObjBytePair<T> objBytePair(T a1,
                                                             byte a2)

comparable

public static <T extends Comparable<T>> LObjBytePair.MutCompObjBytePair<T> comparable(T a1,
                                                                                      byte a2)

immutable

public static <T> LObjBytePair<T> immutable(T a1,
                                            byte a2)

immComp

public static <T extends Comparable<T>> LObjBytePair.ComparableObjBytePair immComp(T a1,
                                                                                   byte a2)

tuple

public static <T> LObjCharPair.MutObjCharPair<T> tuple(T a1,
                                                       char a2)

objCharPair

public static <T> LObjCharPair.MutObjCharPair<T> objCharPair(T a1,
                                                             char a2)

comparable

public static <T extends Comparable<T>> LObjCharPair.MutCompObjCharPair<T> comparable(T a1,
                                                                                      char a2)

immutable

public static <T> LObjCharPair<T> immutable(T a1,
                                            char a2)

immComp

public static <T extends Comparable<T>> LObjCharPair.ComparableObjCharPair immComp(T a1,
                                                                                   char a2)

tuple

public static <T> LObjDblPair.MutObjDblPair<T> tuple(T a1,
                                                     double a2)

objDblPair

public static <T> LObjDblPair.MutObjDblPair<T> objDblPair(T a1,
                                                          double a2)

comparable

public static <T extends Comparable<T>> LObjDblPair.MutCompObjDblPair<T> comparable(T a1,
                                                                                    double a2)

immutable

public static <T> LObjDblPair<T> immutable(T a1,
                                           double a2)

immComp

public static <T extends Comparable<T>> LObjDblPair.ComparableObjDblPair immComp(T a1,
                                                                                 double a2)

tuple

public static <T> LObjFltPair.MutObjFltPair<T> tuple(T a1,
                                                     float a2)

objFltPair

public static <T> LObjFltPair.MutObjFltPair<T> objFltPair(T a1,
                                                          float a2)

comparable

public static <T extends Comparable<T>> LObjFltPair.MutCompObjFltPair<T> comparable(T a1,
                                                                                    float a2)

immutable

public static <T> LObjFltPair<T> immutable(T a1,
                                           float a2)

immComp

public static <T extends Comparable<T>> LObjFltPair.ComparableObjFltPair immComp(T a1,
                                                                                 float a2)

tuple

public static <T> LObjIntPair.MutObjIntPair<T> tuple(T a1,
                                                     int a2)

objIntPair

public static <T> LObjIntPair.MutObjIntPair<T> objIntPair(T a1,
                                                          int a2)

comparable

public static <T extends Comparable<T>> LObjIntPair.MutCompObjIntPair<T> comparable(T a1,
                                                                                    int a2)

immutable

public static <T> LObjIntPair<T> immutable(T a1,
                                           int a2)

immComp

public static <T extends Comparable<T>> LObjIntPair.ComparableObjIntPair immComp(T a1,
                                                                                 int a2)

tuple

public static <T> LObjLongPair.MutObjLongPair<T> tuple(T a1,
                                                       long a2)

objLongPair

public static <T> LObjLongPair.MutObjLongPair<T> objLongPair(T a1,
                                                             long a2)

comparable

public static <T extends Comparable<T>> LObjLongPair.MutCompObjLongPair<T> comparable(T a1,
                                                                                      long a2)

immutable

public static <T> LObjLongPair<T> immutable(T a1,
                                            long a2)

immComp

public static <T extends Comparable<T>> LObjLongPair.ComparableObjLongPair immComp(T a1,
                                                                                   long a2)

tuple

public static <T> LObjSrtPair.MutObjSrtPair<T> tuple(T a1,
                                                     short a2)

objSrtPair

public static <T> LObjSrtPair.MutObjSrtPair<T> objSrtPair(T a1,
                                                          short a2)

comparable

public static <T extends Comparable<T>> LObjSrtPair.MutCompObjSrtPair<T> comparable(T a1,
                                                                                    short a2)

immutable

public static <T> LObjSrtPair<T> immutable(T a1,
                                           short a2)

immComp

public static <T extends Comparable<T>> LObjSrtPair.ComparableObjSrtPair immComp(T a1,
                                                                                 short a2)

tuple

public static <T> LObjIntBoolTriple.MutObjIntBoolTriple<T> tuple(T a1,
                                                                 int a2,
                                                                 boolean a3)

objIntBoolTriple

public static <T> LObjIntBoolTriple.MutObjIntBoolTriple<T> objIntBoolTriple(T a1,
                                                                            int a2,
                                                                            boolean a3)

comparable

public static <T extends Comparable<T>> LObjIntBoolTriple.MutCompObjIntBoolTriple<T> comparable(T a1,
                                                                                                int a2,
                                                                                                boolean a3)

immutable

public static <T> LObjIntBoolTriple<T> immutable(T a1,
                                                 int a2,
                                                 boolean a3)

immComp

public static <T extends Comparable<T>> LObjIntBoolTriple.ComparableObjIntBoolTriple immComp(T a1,
                                                                                             int a2,
                                                                                             boolean a3)

tuple

public static <T> LObjIntByteTriple.MutObjIntByteTriple<T> tuple(T a1,
                                                                 int a2,
                                                                 byte a3)

objIntByteTriple

public static <T> LObjIntByteTriple.MutObjIntByteTriple<T> objIntByteTriple(T a1,
                                                                            int a2,
                                                                            byte a3)

comparable

public static <T extends Comparable<T>> LObjIntByteTriple.MutCompObjIntByteTriple<T> comparable(T a1,
                                                                                                int a2,
                                                                                                byte a3)

immutable

public static <T> LObjIntByteTriple<T> immutable(T a1,
                                                 int a2,
                                                 byte a3)

immComp

public static <T extends Comparable<T>> LObjIntByteTriple.ComparableObjIntByteTriple immComp(T a1,
                                                                                             int a2,
                                                                                             byte a3)

tuple

public static <T> LObjIntCharTriple.MutObjIntCharTriple<T> tuple(T a1,
                                                                 int a2,
                                                                 char a3)

objIntCharTriple

public static <T> LObjIntCharTriple.MutObjIntCharTriple<T> objIntCharTriple(T a1,
                                                                            int a2,
                                                                            char a3)

comparable

public static <T extends Comparable<T>> LObjIntCharTriple.MutCompObjIntCharTriple<T> comparable(T a1,
                                                                                                int a2,
                                                                                                char a3)

immutable

public static <T> LObjIntCharTriple<T> immutable(T a1,
                                                 int a2,
                                                 char a3)

immComp

public static <T extends Comparable<T>> LObjIntCharTriple.ComparableObjIntCharTriple immComp(T a1,
                                                                                             int a2,
                                                                                             char a3)

tuple

public static <T1,T2> LObjIntObjTriple.MutObjIntObjTriple<T1,T2> tuple(T1 a1,
                                                                       int a2,
                                                                       T2 a3)

objIntObjTriple

public static <T1,T2> LObjIntObjTriple.MutObjIntObjTriple<T1,T2> objIntObjTriple(T1 a1,
                                                                                 int a2,
                                                                                 T2 a3)

comparable

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LObjIntObjTriple.MutCompObjIntObjTriple<T1,T2> comparable(T1 a1,
                                                                                                                              int a2,
                                                                                                                              T2 a3)

immutable

public static <T1,T2> LObjIntObjTriple<T1,T2> immutable(T1 a1,
                                                        int a2,
                                                        T2 a3)

immComp

public static <T1 extends Comparable<T1>,T2 extends Comparable<T2>> LObjIntObjTriple.ComparableObjIntObjTriple immComp(T1 a1,
                                                                                                                       int a2,
                                                                                                                       T2 a3)

tuple

public static <T> LObjIntDblTriple.MutObjIntDblTriple<T> tuple(T a1,
                                                               int a2,
                                                               double a3)

objIntDblTriple

public static <T> LObjIntDblTriple.MutObjIntDblTriple<T> objIntDblTriple(T a1,
                                                                         int a2,
                                                                         double a3)

comparable

public static <T extends Comparable<T>> LObjIntDblTriple.MutCompObjIntDblTriple<T> comparable(T a1,
                                                                                              int a2,
                                                                                              double a3)

immutable

public static <T> LObjIntDblTriple<T> immutable(T a1,
                                                int a2,
                                                double a3)

immComp

public static <T extends Comparable<T>> LObjIntDblTriple.ComparableObjIntDblTriple immComp(T a1,
                                                                                           int a2,
                                                                                           double a3)

tuple

public static <T> LObjIntFltTriple.MutObjIntFltTriple<T> tuple(T a1,
                                                               int a2,
                                                               float a3)

objIntFltTriple

public static <T> LObjIntFltTriple.MutObjIntFltTriple<T> objIntFltTriple(T a1,
                                                                         int a2,
                                                                         float a3)

comparable

public static <T extends Comparable<T>> LObjIntFltTriple.MutCompObjIntFltTriple<T> comparable(T a1,
                                                                                              int a2,
                                                                                              float a3)

immutable

public static <T> LObjIntFltTriple<T> immutable(T a1,
                                                int a2,
                                                float a3)

immComp

public static <T extends Comparable<T>> LObjIntFltTriple.ComparableObjIntFltTriple immComp(T a1,
                                                                                           int a2,
                                                                                           float a3)

tuple

public static <T> LObjBiIntTriple.MutObjBiIntTriple<T> tuple(T a1,
                                                             int a2,
                                                             int a3)

objBiIntTriple

public static <T> LObjBiIntTriple.MutObjBiIntTriple<T> objBiIntTriple(T a1,
                                                                      int a2,
                                                                      int a3)

comparable

public static <T extends Comparable<T>> LObjBiIntTriple.MutCompObjBiIntTriple<T> comparable(T a1,
                                                                                            int a2,
                                                                                            int a3)

immutable

public static <T> LObjBiIntTriple<T> immutable(T a1,
                                               int a2,
                                               int a3)

immComp

public static <T extends Comparable<T>> LObjBiIntTriple.ComparableObjBiIntTriple immComp(T a1,
                                                                                         int a2,
                                                                                         int a3)

tuple

public static <T> LObjIntLongTriple.MutObjIntLongTriple<T> tuple(T a1,
                                                                 int a2,
                                                                 long a3)

objIntLongTriple

public static <T> LObjIntLongTriple.MutObjIntLongTriple<T> objIntLongTriple(T a1,
                                                                            int a2,
                                                                            long a3)

comparable

public static <T extends Comparable<T>> LObjIntLongTriple.MutCompObjIntLongTriple<T> comparable(T a1,
                                                                                                int a2,
                                                                                                long a3)

immutable

public static <T> LObjIntLongTriple<T> immutable(T a1,
                                                 int a2,
                                                 long a3)

immComp

public static <T extends Comparable<T>> LObjIntLongTriple.ComparableObjIntLongTriple immComp(T a1,
                                                                                             int a2,
                                                                                             long a3)

tuple

public static <T> LObjIntSrtTriple.MutObjIntSrtTriple<T> tuple(T a1,
                                                               int a2,
                                                               short a3)

objIntSrtTriple

public static <T> LObjIntSrtTriple.MutObjIntSrtTriple<T> objIntSrtTriple(T a1,
                                                                         int a2,
                                                                         short a3)

comparable

public static <T extends Comparable<T>> LObjIntSrtTriple.MutCompObjIntSrtTriple<T> comparable(T a1,
                                                                                              int a2,
                                                                                              short a3)

immutable

public static <T> LObjIntSrtTriple<T> immutable(T a1,
                                                int a2,
                                                short a3)

immComp

public static <T extends Comparable<T>> LObjIntSrtTriple.ComparableObjIntSrtTriple immComp(T a1,
                                                                                           int a2,
                                                                                           short a3)

tuple

public static LBoolTriple.MutBoolTriple tuple(boolean a1,
                                              boolean a2,
                                              boolean a3)

boolTriple

public static LBoolTriple.MutBoolTriple boolTriple(boolean a1,
                                                   boolean a2,
                                                   boolean a3)

comparable

public static LBoolTriple.MutCompBoolTriple comparable(boolean a1,
                                                       boolean a2,
                                                       boolean a3)

immutable

public static LBoolTriple immutable(boolean a1,
                                    boolean a2,
                                    boolean a3)

immComp

public static LBoolTriple.ComparableBoolTriple immComp(boolean a1,
                                                       boolean a2,
                                                       boolean a3)

tuple
```
public static LTuple.Void tuple()
```

Class Tuple4U

Method Summary

Methods inherited from class java.lang.Object

Method Detail

tuple

pair

comparable

immutable

immComp

tuple

single

comparable

immutable

immComp

tuple

triple

comparable

immutable

immComp

tuple

boolSingle

comparable

immutable

immComp

tuple

byteSingle

comparable

immutable

immComp

tuple

charSingle

comparable

immutable

immComp

tuple

dblSingle

comparable

immutable

immComp

tuple

fltSingle

comparable

immutable

immComp

tuple

intSingle

comparable

immutable

immComp

tuple

longSingle

comparable

immutable

immComp

tuple

srtSingle

comparable

immutable

immComp

tuple

boolPair

comparable

immutable

immComp

tuple

bytePair

comparable

immutable

immComp

tuple

charPair

comparable

immutable

immComp

tuple

dblPair

comparable

immutable

immComp

tuple