de.scravy.bedrock.Operators

public class Operators
extends Object

Constructor Summary

Constructors

Constructor Description

Operators()

Method Summary

Modifier and Type	Method	Description
`static IntUnaryOperator`	`and(int a)`
`static int`	`and(int a, int b)`
`static LongUnaryOperator`	`and(long a)`
`static long`	`and(long a, long b)`
`static UnaryOperator<Integer>`	`and(Integer a)`
`static Integer`	`and(Integer a, Integer b)`
`static UnaryOperator<Long>`	`and(Long a)`
`static Long`	`and(Long a, Long b)`
`static UnaryOperator<BigInteger>`	`and(BigInteger a)`
`static BigInteger`	`and(BigInteger a, BigInteger b)`
`static <N extends Number> UnaryOperator<N>`	`and(N a)`
`static <N extends Number> N`	`and(N a, N b)`
`static DoubleUnaryOperator`	`div(double b)`
`static double`	`div(double a, double b)`
`static IntUnaryOperator`	`div(int b)`
`static int`	`div(int a, int b)`
`static LongUnaryOperator`	`div(long b)`
`static long`	`div(long a, long b)`
`static UnaryOperator<Double>`	`div(Double b)`
`static Double`	`div(Double a, Double b)`
`static UnaryOperator<Integer>`	`div(Integer b)`
`static Integer`	`div(Integer a, Integer b)`
`static UnaryOperator<Long>`	`div(Long b)`
`static Long`	`div(Long a, Long b)`
`static UnaryOperator<BigDecimal>`	`div(BigDecimal b)`
`static BigDecimal`	`div(BigDecimal a, BigDecimal b)`
`static UnaryOperator<BigInteger>`	`div(BigInteger b)`
`static BigInteger`	`div(BigInteger a, BigInteger b)`
`static <N extends Number> UnaryOperator<N>`	`div(N b)`
`static <N extends Number> N`	`div(N a, N b)`
`static boolean`	`eq(boolean a, boolean b)`
`static boolean`	`eq(double a, double b)`
`static boolean`	`eq(int a, int b)`
`static boolean`	`eq(long a, long b)`
`static Boolean`	`eq(Object a, Object b)`
`static boolean`	`gt(double a, double b)`
`static boolean`	`gt(int a, int b)`
`static boolean`	`gt(long a, long b)`
`static <E extends Comparable<? super E>> Boolean`	`gt(E a, E b)`
`static Boolean`	`gt(Double a, Double b)`
`static Boolean`	`gt(Integer a, Integer b)`
`static Boolean`	`gt(Long a, Long b)`
`static boolean`	`gte(double a, double b)`
`static boolean`	`gte(int a, int b)`
`static boolean`	`gte(long a, long b)`
`static <E extends Comparable<? super E>> Boolean`	`gte(E a, E b)`
`static Boolean`	`gte(Double a, Double b)`
`static Boolean`	`gte(Integer a, Integer b)`
`static Boolean`	`gte(Long a, Long b)`
`static boolean`	`lt(double a, double b)`
`static boolean`	`lt(int a, int b)`
`static boolean`	`lt(long a, long b)`
`static <E extends Comparable<? super E>> Boolean`	`lt(E a, E b)`
`static Boolean`	`lt(Double a, Double b)`
`static Boolean`	`lt(Integer a, Integer b)`
`static Boolean`	`lt(Long a, Long b)`
`static boolean`	`lte(double a, double b)`
`static boolean`	`lte(int a, int b)`
`static boolean`	`lte(long a, long b)`
`static <E extends Comparable<? super E>> Boolean`	`lte(E a, E b)`
`static Boolean`	`lte(Double a, Double b)`
`static Boolean`	`lte(Integer a, Integer b)`
`static Boolean`	`lte(Long a, Long b)`
`static DoubleUnaryOperator`	`minus(double b)`
`static double`	`minus(double a, double b)`
`static IntUnaryOperator`	`minus(int b)`
`static int`	`minus(int a, int b)`
`static LongUnaryOperator`	`minus(long b)`
`static long`	`minus(long a, long b)`
`static UnaryOperator<Double>`	`minus(Double b)`
`static Double`	`minus(Double a, Double b)`
`static UnaryOperator<Integer>`	`minus(Integer b)`
`static Integer`	`minus(Integer a, Integer b)`
`static UnaryOperator<Long>`	`minus(Long b)`
`static Long`	`minus(Long a, Long b)`
`static UnaryOperator<BigDecimal>`	`minus(BigDecimal b)`
`static BigDecimal`	`minus(BigDecimal a, BigDecimal b)`
`static UnaryOperator<BigInteger>`	`minus(BigInteger b)`
`static BigInteger`	`minus(BigInteger a, BigInteger b)`
`static <N extends Number> UnaryOperator<N>`	`minus(N b)`
`static <N extends Number> N`	`minus(N a, N b)`
`static DoubleUnaryOperator`	`mod(double b)`
`static double`	`mod(double a, double b)`
`static IntUnaryOperator`	`mod(int b)`
`static int`	`mod(int a, int b)`
`static LongUnaryOperator`	`mod(long b)`
`static long`	`mod(long a, long b)`
`static UnaryOperator<Double>`	`mod(Double b)`
`static Double`	`mod(Double a, Double b)`
`static UnaryOperator<Integer>`	`mod(Integer b)`
`static Integer`	`mod(Integer a, Integer b)`
`static UnaryOperator<Long>`	`mod(Long b)`
`static Long`	`mod(Long a, Long b)`
`static UnaryOperator<BigInteger>`	`mod(BigInteger b)`
`static BigInteger`	`mod(BigInteger a, BigInteger b)`
`static <N extends Number> UnaryOperator<N>`	`mod(N b)`
`static <N extends Number> N`	`mod(N a, N b)`
`static boolean`	`neq(boolean a, boolean b)`
`static boolean`	`neq(double a, double b)`
`static boolean`	`neq(int a, int b)`
`static boolean`	`neq(long a, long b)`
`static Boolean`	`neq(Object a, Object b)`
`static IntUnaryOperator`	`or(int a)`
`static int`	`or(int a, int b)`
`static LongUnaryOperator`	`or(long a)`
`static long`	`or(long a, long b)`
`static UnaryOperator<Integer>`	`or(Integer a)`
`static Integer`	`or(Integer a, Integer b)`
`static UnaryOperator<Long>`	`or(Long a)`
`static Long`	`or(Long a, Long b)`
`static UnaryOperator<BigInteger>`	`or(BigInteger a)`
`static BigInteger`	`or(BigInteger a, BigInteger b)`
`static <N extends Number> UnaryOperator<N>`	`or(N a)`
`static <N extends Number> N`	`or(N a, N b)`
`static DoubleUnaryOperator`	`plus(double a)`
`static double`	`plus(double a, double b)`
`static IntUnaryOperator`	`plus(int a)`
`static int`	`plus(int a, int b)`
`static LongUnaryOperator`	`plus(long a)`
`static long`	`plus(long a, long b)`
`static UnaryOperator<Double>`	`plus(Double a)`
`static Double`	`plus(Double a, Double b)`
`static UnaryOperator<Integer>`	`plus(Integer a)`
`static Integer`	`plus(Integer a, Integer b)`
`static UnaryOperator<Long>`	`plus(Long a)`
`static Long`	`plus(Long a, Long b)`
`static UnaryOperator<BigDecimal>`	`plus(BigDecimal a)`
`static BigDecimal`	`plus(BigDecimal a, BigDecimal b)`
`static UnaryOperator<BigInteger>`	`plus(BigInteger a)`
`static BigInteger`	`plus(BigInteger a, BigInteger b)`
`static <N extends Number> UnaryOperator<N>`	`plus(N a)`
`static <N extends Number> N`	`plus(N a, N b)`
`static DoubleUnaryOperator`	`times(double a)`
`static double`	`times(double a, double b)`
`static IntUnaryOperator`	`times(int a)`
`static int`	`times(int a, int b)`
`static LongUnaryOperator`	`times(long a)`
`static long`	`times(long a, long b)`
`static UnaryOperator<Double>`	`times(Double a)`
`static Double`	`times(Double a, Double b)`
`static UnaryOperator<Integer>`	`times(Integer a)`
`static Integer`	`times(Integer a, Integer b)`
`static UnaryOperator<Long>`	`times(Long a)`
`static Long`	`times(Long a, Long b)`
`static UnaryOperator<BigDecimal>`	`times(BigDecimal a)`
`static BigDecimal`	`times(BigDecimal a, BigDecimal b)`
`static UnaryOperator<BigInteger>`	`times(BigInteger a)`
`static BigInteger`	`times(BigInteger a, BigInteger b)`
`static <N extends Number> UnaryOperator<N>`	`times(N a)`
`static <N extends Number> N`	`times(N a, N b)`
`static IntUnaryOperator`	`xor(int b)`
`static int`	`xor(int a, int b)`
`static LongUnaryOperator`	`xor(long b)`
`static long`	`xor(long a, long b)`
`static UnaryOperator<Integer>`	`xor(Integer b)`
`static Integer`	`xor(Integer a, Integer b)`
`static UnaryOperator<Long>`	`xor(Long b)`
`static Long`	`xor(Long a, Long b)`
`static UnaryOperator<BigInteger>`	`xor(BigInteger b)`
`static BigInteger`	`xor(BigInteger a, BigInteger b)`
`static <N extends Number> UnaryOperator<N>`	`xor(N b)`
`static <N extends Number> N`	`xor(N a, N b)`

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Details
- Operators
  
  public Operators()
Method Details
- plus
  
  public static int plus(int a, int b)
- plus
  
  @Nonnull public static IntUnaryOperator plus(int a)
- plus
  
  public static long plus(long a, long b)
- plus
  
  @Nonnull public static LongUnaryOperator plus(long a)
- plus
  
  public static double plus(double a, double b)
- plus
  
  @Nonnull public static DoubleUnaryOperator plus(double a)
- plus
  
  public static Integer plus(@Nullable Integer a, @Nullable Integer b)
- plus
  
  @Nonnull public static UnaryOperator<Integer> plus(@Nullable Integer a)
- plus
  
  public static Long plus(@Nullable Long a, @Nullable Long b)
- plus
  
  @Nonnull public static UnaryOperator<Long> plus(@Nullable Long a)
- plus
  
  public static Double plus(@Nullable Double a, @Nullable Double b)
- plus
  
  @Nonnull public static UnaryOperator<Double> plus(@Nullable Double a)
- plus
  
  public static BigInteger plus(@Nullable BigInteger a, @Nullable BigInteger b)
- plus
  
  @Nonnull public static UnaryOperator<BigInteger> plus(@Nullable BigInteger a)
- plus
  
  public static BigDecimal plus(@Nullable BigDecimal a, @Nullable BigDecimal b)
- plus
  
  @Nonnull public static UnaryOperator<BigDecimal> plus(@Nullable BigDecimal a)
- plus
  
  public static <N extends Number> N plus(@Nullable N a, @Nullable N b)
- plus
  
  @Nonnull public static <N extends Number> UnaryOperator<N> plus(@Nullable N a)
- or
  
  public static int or(int a, int b)
- or
  
  @Nonnull public static IntUnaryOperator or(int a)
- or
  
  public static long or(long a, long b)
- or
  
  @Nonnull public static LongUnaryOperator or(long a)
- or
  
  public static Integer or(@Nullable Integer a, @Nullable Integer b)
- or
  
  @Nonnull public static UnaryOperator<Integer> or(@Nullable Integer a)
- or
  
  public static Long or(@Nullable Long a, @Nullable Long b)
- or
  
  @Nonnull public static UnaryOperator<Long> or(@Nullable Long a)
- or
  
  public static BigInteger or(@Nullable BigInteger a, @Nullable BigInteger b)
- or
  
  @Nonnull public static UnaryOperator<BigInteger> or(@Nullable BigInteger a)
- or
  
  public static <N extends Number> N or(@Nullable N a, @Nullable N b)
- or
  
  @Nonnull public static <N extends Number> UnaryOperator<N> or(@Nullable N a)
- minus
  
  public static int minus(int a, int b)
- minus
  
  @Nonnull public static IntUnaryOperator minus(int b)
- minus
  
  public static long minus(long a, long b)
- minus
  
  @Nonnull public static LongUnaryOperator minus(long b)
- minus
  
  public static double minus(double a, double b)
- minus
  
  @Nonnull public static DoubleUnaryOperator minus(double b)
- minus
  
  public static Integer minus(@Nullable Integer a, @Nullable Integer b)
- minus
  
  @Nonnull public static UnaryOperator<Integer> minus(@Nullable Integer b)
- minus
  
  public static Long minus(@Nullable Long a, @Nullable Long b)
- minus
  
  @Nonnull public static UnaryOperator<Long> minus(@Nullable Long b)
- minus
  
  public static Double minus(@Nullable Double a, @Nullable Double b)
- minus
  
  @Nonnull public static UnaryOperator<Double> minus(@Nullable Double b)
- minus
  
  public static BigInteger minus(@Nullable BigInteger a, @Nullable BigInteger b)
- minus
  
  @Nonnull public static UnaryOperator<BigInteger> minus(@Nullable BigInteger b)
- minus
  
  public static BigDecimal minus(@Nullable BigDecimal a, @Nullable BigDecimal b)
- minus
  
  @Nonnull public static UnaryOperator<BigDecimal> minus(@Nullable BigDecimal b)
- minus
  
  public static <N extends Number> N minus(@Nullable N a, @Nullable N b)
- minus
  
  @Nonnull public static <N extends Number> UnaryOperator<N> minus(@Nullable N b)
- times
  
  public static int times(int a, int b)
- times
  
  @Nonnull public static IntUnaryOperator times(int a)
- times
  
  public static long times(long a, long b)
- times
  
  @Nonnull public static LongUnaryOperator times(long a)
- times
  
  public static double times(double a, double b)
- times
  
  @Nonnull public static DoubleUnaryOperator times(double a)
- times
  
  public static Integer times(Integer a, Integer b)
- times
  
  @Nonnull public static UnaryOperator<Integer> times(@Nullable Integer a)
- times
  
  public static Long times(Long a, Long b)
- times
  
  @Nonnull public static UnaryOperator<Long> times(@Nullable Long a)
- times
  
  public static Double times(Double a, Double b)
- times
  
  @Nonnull public static UnaryOperator<Double> times(@Nullable Double a)
- times
  
  public static BigInteger times(BigInteger a, BigInteger b)
- times
  
  @Nonnull public static UnaryOperator<BigInteger> times(@Nullable BigInteger a)
- times
  
  public static BigDecimal times(BigDecimal a, BigDecimal b)
- times
  
  @Nonnull public static UnaryOperator<BigDecimal> times(@Nullable BigDecimal a)
- times
  
  public static <N extends Number> N times(@Nullable N a, @Nullable N b)
- times
  
  @Nonnull public static <N extends Number> UnaryOperator<N> times(@Nullable N a)
- and
  
  public static int and(int a, int b)
- and
  
  @Nonnull public static IntUnaryOperator and(int a)
- and
  
  public static long and(long a, long b)
- and
  
  @Nonnull public static LongUnaryOperator and(long a)
- and
  
  public static Integer and(@Nullable Integer a, @Nullable Integer b)
- and
  
  @Nonnull public static UnaryOperator<Integer> and(@Nullable Integer a)
- and
  
  public static Long and(@Nullable Long a, @Nullable Long b)
- and
  
  @Nonnull public static UnaryOperator<Long> and(@Nullable Long a)
- and
  
  public static BigInteger and(@Nullable BigInteger a, @Nullable BigInteger b)
- and
  
  @Nonnull public static UnaryOperator<BigInteger> and(@Nullable BigInteger a)
- and
  
  public static <N extends Number> N and(@Nullable N a, @Nullable N b)
- and
  
  @Nonnull public static <N extends Number> UnaryOperator<N> and(@Nullable N a)
- div
  
  public static int div(int a, int b)
- div
  
  @Nonnull public static IntUnaryOperator div(int b)
- div
  
  public static long div(long a, long b)
- div
  
  @Nonnull public static LongUnaryOperator div(long b)
- div
  
  public static double div(double a, double b)
- div
  
  @Nonnull public static DoubleUnaryOperator div(double b)
- div
  
  public static Integer div(@Nullable Integer a, @Nullable Integer b)
- div
  
  @Nonnull public static UnaryOperator<Integer> div(@Nullable Integer b)
- div
  
  public static Long div(@Nullable Long a, @Nullable Long b)
- div
  
  @Nonnull public static UnaryOperator<Long> div(@Nullable Long b)
- div
  
  public static Double div(@Nullable Double a, @Nullable Double b)
- div
  
  @Nonnull public static UnaryOperator<Double> div(@Nullable Double b)
- div
  
  public static BigInteger div(@Nullable BigInteger a, @Nullable BigInteger b)
- div
  
  @Nonnull public static UnaryOperator<BigInteger> div(@Nullable BigInteger b)
- div
  
  public static BigDecimal div(@Nullable BigDecimal a, @Nullable BigDecimal b)
- div
  
  @Nonnull public static UnaryOperator<BigDecimal> div(@Nullable BigDecimal b)
- div
  
  public static <N extends Number> N div(@Nullable N a, @Nullable N b)
- div
  
  @Nonnull public static <N extends Number> UnaryOperator<N> div(@Nullable N b)
- mod
  
  public static int mod(int a, int b)
- mod
  
  @Nonnull public static IntUnaryOperator mod(int b)
- mod
  
  public static long mod(long a, long b)
- mod
  
  @Nonnull public static LongUnaryOperator mod(long b)
- mod
  
  public static double mod(double a, double b)
- mod
  
  @Nonnull public static DoubleUnaryOperator mod(double b)
- mod
  
  public static Integer mod(@Nullable Integer a, @Nullable Integer b)
- mod
  
  @Nonnull public static UnaryOperator<Integer> mod(@Nullable Integer b)
- mod
  
  public static Long mod(@Nullable Long a, @Nullable Long b)
- mod
  
  @Nonnull public static UnaryOperator<Long> mod(@Nullable Long b)
- mod
  
  public static Double mod(Double a, Double b)
- mod
  
  @Nonnull public static UnaryOperator<Double> mod(@Nullable Double b)
- mod
  
  public static BigInteger mod(BigInteger a, BigInteger b)
- mod
  
  @Nonnull public static UnaryOperator<BigInteger> mod(@Nullable BigInteger b)
- mod
  
  public static <N extends Number> N mod(@Nullable N a, @Nullable N b)
- mod
  
  @Nonnull public static <N extends Number> UnaryOperator<N> mod(@Nullable N b)
- xor
  
  public static int xor(int a, int b)
- xor
  
  @Nonnull public static IntUnaryOperator xor(int b)
- xor
  
  public static long xor(long a, long b)
- xor
  
  @Nonnull public static LongUnaryOperator xor(long b)
- xor
  
  public static Integer xor(@Nullable Integer a, @Nullable Integer b)
- xor
  
  @Nonnull public static UnaryOperator<Integer> xor(@Nullable Integer b)
- xor
  
  public static Long xor(@Nullable Long a, @Nullable Long b)
- xor
  
  @Nonnull public static UnaryOperator<Long> xor(@Nullable Long b)
- xor
  
  public static BigInteger xor(@Nullable BigInteger a, @Nullable BigInteger b)
- xor
  
  @Nonnull public static UnaryOperator<BigInteger> xor(@Nullable BigInteger b)
- xor
  
  public static <N extends Number> N xor(@Nullable N a, @Nullable N b)
- xor
  
  @Nonnull public static <N extends Number> UnaryOperator<N> xor(@Nullable N b)
- neq
  
  public static boolean neq(boolean a, boolean b)
- neq
  
  public static boolean neq(int a, int b)
- neq
  
  public static boolean neq(long a, long b)
- neq
  
  public static boolean neq(double a, double b)
- neq
  
  public static Boolean neq(@Nullable Object a, @Nullable Object b)
- eq
  
  public static boolean eq(boolean a, boolean b)
- eq
  
  public static boolean eq(int a, int b)
- eq
  
  public static boolean eq(long a, long b)
- eq
  
  public static boolean eq(double a, double b)
- eq
  
  public static Boolean eq(@Nullable Object a, @Nullable Object b)
- lt
  
  public static boolean lt(int a, int b)
- lt
  
  public static boolean lt(long a, long b)
- lt
  
  public static boolean lt(double a, double b)
- lt
  
  public static Boolean lt(Integer a, Integer b)
- lt
  
  public static Boolean lt(Long a, Long b)
- lt
  
  public static Boolean lt(Double a, Double b)
- lt
  
  public static <E extends Comparable<? super E>> Boolean lt(E a, E b)
- lte
  
  public static boolean lte(int a, int b)
- lte
  
  public static boolean lte(long a, long b)
- lte
  
  public static boolean lte(double a, double b)
- lte
  
  public static Boolean lte(Integer a, Integer b)
- lte
  
  public static Boolean lte(Long a, Long b)
- lte
  
  public static Boolean lte(Double a, Double b)
- lte
  
  public static <E extends Comparable<? super E>> Boolean lte(E a, E b)
- gt
  
  public static boolean gt(int a, int b)
- gt
  
  public static boolean gt(long a, long b)
- gt
  
  public static boolean gt(double a, double b)
- gt
  
  public static Boolean gt(Integer a, Integer b)
- gt
  
  public static Boolean gt(Long a, Long b)
- gt
  
  public static Boolean gt(Double a, Double b)
- gt
  
  public static <E extends Comparable<? super E>> Boolean gt(E a, E b)
- gte
  
  public static boolean gte(int a, int b)
- gte
  
  public static boolean gte(long a, long b)
- gte
  
  public static boolean gte(double a, double b)
- gte
  
  public static Boolean gte(Integer a, Integer b)
- gte
  
  public static Boolean gte(Long a, Long b)
- gte
  
  public static Boolean gte(Double a, Double b)
- gte
  
  public static <E extends Comparable<? super E>> Boolean gte(E a, E b)

Class Operators

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Details

Method Details