HJavaDefaultOperators (Hadra Language Standard Library 0.1.0 API)

java.lang.Object
- net.hl.lang.ext.HJavaDefaultOperators

public class HJavaDefaultOperators
extends Object

Constructor Summary

Constructors
Constructor and Description

HJavaDefaultOperators()

Constructors
Constructor and Description
`HJavaDefaultOperators()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`and(boolean a, boolean b)`
`static int`	`binaryAnd(int a, int b)`
`static long`	`binaryAnd(long a, long b)`
`static int`	`binaryOr(int a, int b)`
`static long`	`binaryOr(long a, long b)`
`static int`	`compare(double a, double b)`
`static int`	`compare(float a, float b)`
`static int`	`compare(int a, int b)`
`static int`	`compare(long a, long b)`
`static int`	`div(byte a, byte b)`
`static double`	`div(byte a, double b)`
`static float`	`div(byte a, float b)`
`static int`	`div(byte a, int b)`
`static long`	`div(byte a, long b)`
`static int`	`div(byte a, short b)`
`static double`	`div(double a, byte b)`
`static double`	`div(double a, double b)`
`static double`	`div(double a, float b)`
`static double`	`div(double a, int b)`
`static double`	`div(double a, long b)`
`static double`	`div(double a, short b)`
`static float`	`div(float a, byte b)`
`static double`	`div(float a, double b)`
`static float`	`div(float a, float b)`
`static float`	`div(float a, int b)`
`static float`	`div(float a, long b)`
`static float`	`div(float a, short b)`
`static int`	`div(int a, byte b)`
`static double`	`div(int a, double b)`
`static float`	`div(int a, float b)`
`static int`	`div(int a, int b)`
`static long`	`div(int a, long b)`
`static int`	`div(int a, short b)`
`static long`	`div(long a, byte b)`
`static double`	`div(long a, double b)`
`static float`	`div(long a, float b)`
`static long`	`div(long a, int b)`
`static long`	`div(long a, long b)`
`static long`	`div(long a, short b)`
`static int`	`div(short a, byte b)`
`static double`	`div(short a, double b)`
`static float`	`div(short a, float b)`
`static int`	`div(short a, int b)`
`static long`	`div(short a, long b)`
`static int`	`div(short a, short b)`
`static int`	`minus(byte a)`
`static int`	`minus(byte a, byte b)`
`static double`	`minus(byte a, double b)`
`static float`	`minus(byte a, float b)`
`static int`	`minus(byte a, int b)`
`static long`	`minus(byte a, long b)`
`static int`	`minus(byte a, short b)`
`static double`	`minus(double a)`
`static double`	`minus(double a, byte b)`
`static double`	`minus(double a, double b)`
`static double`	`minus(double a, float b)`
`static double`	`minus(double a, int b)`
`static double`	`minus(double a, long b)`
`static double`	`minus(double a, short b)`
`static float`	`minus(float a)`
`static float`	`minus(float a, byte b)`
`static double`	`minus(float a, double b)`
`static float`	`minus(float a, float b)`
`static float`	`minus(float a, int b)`
`static float`	`minus(float a, long b)`
`static float`	`minus(float a, short b)`
`static int`	`minus(int a)`
`static int`	`minus(int a, byte b)`
`static double`	`minus(int a, double b)`
`static float`	`minus(int a, float b)`
`static int`	`minus(int a, int b)`
`static long`	`minus(int a, long b)`
`static int`	`minus(int a, short b)`
`static long`	`minus(long a)`
`static long`	`minus(long a, byte b)`
`static double`	`minus(long a, double b)`
`static float`	`minus(long a, float b)`
`static long`	`minus(long a, int b)`
`static long`	`minus(long a, long b)`
`static long`	`minus(long a, short b)`
`static int`	`minus(short a)`
`static int`	`minus(short a, byte b)`
`static double`	`minus(short a, double b)`
`static float`	`minus(short a, float b)`
`static int`	`minus(short a, int b)`
`static long`	`minus(short a, long b)`
`static int`	`minus(short a, short b)`
`static int`	`mul(byte a, byte b)`
`static double`	`mul(byte a, double b)`
`static float`	`mul(byte a, float b)`
`static int`	`mul(byte a, int b)`
`static long`	`mul(byte a, long b)`
`static int`	`mul(byte a, short b)`
`static double`	`mul(double a, byte b)`
`static double`	`mul(double a, double b)`
`static double`	`mul(double a, float b)`
`static double`	`mul(double a, int b)`
`static double`	`mul(double a, long b)`
`static double`	`mul(double a, short b)`
`static float`	`mul(float a, byte b)`
`static double`	`mul(float a, double b)`
`static float`	`mul(float a, float b)`
`static float`	`mul(float a, int b)`
`static float`	`mul(float a, long b)`
`static float`	`mul(float a, short b)`
`static int`	`mul(int a, byte b)`
`static double`	`mul(int a, double b)`
`static float`	`mul(int a, float b)`
`static int`	`mul(int a, int b)`
`static long`	`mul(int a, long b)`
`static int`	`mul(int a, short b)`
`static long`	`mul(long a, byte b)`
`static double`	`mul(long a, double b)`
`static float`	`mul(long a, float b)`
`static long`	`mul(long a, int b)`
`static long`	`mul(long a, long b)`
`static long`	`mul(long a, short b)`
`static int`	`mul(short a, byte b)`
`static double`	`mul(short a, double b)`
`static float`	`mul(short a, float b)`
`static int`	`mul(short a, int b)`
`static long`	`mul(short a, long b)`
`static int`	`mul(short a, short b)`
`static double`	`newPrimitiveDouble(byte a)`
`static double`	`newPrimitiveDouble(float a)`
`static double`	`newPrimitiveDouble(int a)`
`static double`	`newPrimitiveDouble(long a)`
`static double`	`newPrimitiveDouble(short a)`
`static int`	`newPrimitiveInt(byte a)`
`static int`	`newPrimitiveInt(short a)`
`static long`	`newPrimitiveLong(byte a)`
`static long`	`newPrimitiveLong(int a)`
`static long`	`newPrimitiveLong(short a)`
`static short`	`newPrimitiveShort(byte a)`
`static boolean`	`not(boolean a)`
`static boolean`	`or(boolean a, boolean b)`
`static int`	`plus(byte a, byte b)`
`static double`	`plus(byte a, double b)`
`static float`	`plus(byte a, float b)`
`static int`	`plus(byte a, int b)`
`static long`	`plus(byte a, long b)`
`static int`	`plus(byte a, short b)`
`static double`	`plus(double a, byte b)`
`static double`	`plus(double a, double b)`
`static double`	`plus(double a, float b)`
`static double`	`plus(double a, int b)`
`static double`	`plus(double a, long b)`
`static double`	`plus(double a, short b)`
`static float`	`plus(float a, byte b)`
`static double`	`plus(float a, double b)`
`static float`	`plus(float a, float b)`
`static float`	`plus(float a, int b)`
`static float`	`plus(float a, long b)`
`static float`	`plus(float a, short b)`
`static int`	`plus(int a, byte b)`
`static double`	`plus(int a, double b)`
`static float`	`plus(int a, float b)`
`static int`	`plus(int a, int b)`
`static long`	`plus(int a, long b)`
`static int`	`plus(int a, short b)`
`static long`	`plus(long a, byte b)`
`static double`	`plus(long a, double b)`
`static float`	`plus(long a, float b)`
`static long`	`plus(long a, int b)`
`static long`	`plus(long a, long b)`
`static long`	`plus(long a, short b)`
`static String`	`plus(Object a, String b)`
`static int`	`plus(short a, byte b)`
`static double`	`plus(short a, double b)`
`static float`	`plus(short a, float b)`
`static int`	`plus(short a, int b)`
`static long`	`plus(short a, long b)`
`static int`	`plus(short a, short b)`
`static String`	`plus(String a, Object b)`
`static int`	`rem(byte a, byte b)`
`static double`	`rem(byte a, double b)`
`static float`	`rem(byte a, float b)`
`static int`	`rem(byte a, int b)`
`static long`	`rem(byte a, long b)`
`static int`	`rem(byte a, short b)`
`static double`	`rem(double a, byte b)`
`static double`	`rem(double a, double b)`
`static double`	`rem(double a, float b)`
`static double`	`rem(double a, int b)`
`static double`	`rem(double a, long b)`
`static double`	`rem(double a, short b)`
`static float`	`rem(float a, byte b)`
`static double`	`rem(float a, double b)`
`static float`	`rem(float a, float b)`
`static float`	`rem(float a, int b)`
`static float`	`rem(float a, long b)`
`static float`	`rem(float a, short b)`
`static int`	`rem(int a, byte b)`
`static double`	`rem(int a, double b)`
`static float`	`rem(int a, float b)`
`static int`	`rem(int a, int b)`
`static long`	`rem(int a, long b)`
`static int`	`rem(int a, short b)`
`static long`	`rem(long a, byte b)`
`static double`	`rem(long a, double b)`
`static float`	`rem(long a, float b)`
`static long`	`rem(long a, int b)`
`static long`	`rem(long a, long b)`
`static long`	`rem(long a, short b)`
`static int`	`rem(short a, byte b)`
`static double`	`rem(short a, double b)`
`static float`	`rem(short a, float b)`
`static int`	`rem(short a, int b)`
`static long`	`rem(short a, long b)`
`static int`	`rem(short a, short b)`
`static int`	`tilde(byte a)`
`static int`	`tilde(int a)`
`static long`	`tilde(long a)`
`static int`	`tilde(short a)`

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

Constructor Detail
- HJavaDefaultOperators
```
public HJavaDefaultOperators()
```

Method Detail

minus
```
public static int minus(byte a)
```

minus
```
public static int minus(short a)
```

minus
```
public static int minus(int a)
```

minus
```
public static long minus(long a)
```

minus
```
public static float minus(float a)
```

minus
```
public static double minus(double a)
```

tilde
```
public static int tilde(byte a)
```

tilde
```
public static int tilde(short a)
```

tilde
```
public static int tilde(int a)
```

tilde
```
public static long tilde(long a)
```

or

public static boolean or(boolean a,
                         boolean b)

binaryOr

public static int binaryOr(int a,
                           int b)

binaryOr

public static long binaryOr(long a,
                            long b)

binaryAnd

public static int binaryAnd(int a,
                            int b)

binaryAnd

public static long binaryAnd(long a,
                             long b)

and

public static boolean and(boolean a,
                          boolean b)

plus

public static String plus(String a,
                          Object b)

plus

public static String plus(Object a,
                          String b)

plus

public static int plus(byte a,
                       byte b)

plus

public static int plus(byte a,
                       short b)

plus

public static int plus(byte a,
                       int b)

plus

public static long plus(byte a,
                        long b)

plus

public static float plus(byte a,
                         float b)

plus

public static double plus(byte a,
                          double b)

plus

public static int plus(short a,
                       byte b)

plus

public static int plus(short a,
                       short b)

plus

public static int plus(short a,
                       int b)

plus

public static long plus(short a,
                        long b)

plus

public static float plus(short a,
                         float b)

plus

public static double plus(short a,
                          double b)

plus

public static int plus(int a,
                       byte b)

plus

public static int plus(int a,
                       short b)

plus

public static int plus(int a,
                       int b)

plus

public static long plus(int a,
                        long b)

plus

public static float plus(int a,
                         float b)

plus

public static double plus(int a,
                          double b)

plus

public static long plus(long a,
                        byte b)

plus

public static long plus(long a,
                        short b)

plus

public static long plus(long a,
                        int b)

plus

public static long plus(long a,
                        long b)

plus

public static float plus(long a,
                         float b)

plus

public static double plus(long a,
                          double b)

plus

public static float plus(float a,
                         byte b)

plus

public static float plus(float a,
                         short b)

plus

public static float plus(float a,
                         int b)

plus

public static float plus(float a,
                         long b)

plus

public static float plus(float a,
                         float b)

plus

public static double plus(float a,
                          double b)

plus

public static double plus(double a,
                          byte b)

plus

public static double plus(double a,
                          short b)

plus

public static double plus(double a,
                          int b)

plus

public static double plus(double a,
                          long b)

plus

public static double plus(double a,
                          float b)

plus

public static double plus(double a,
                          double b)

rem

public static int rem(byte a,
                      byte b)

rem

public static int rem(byte a,
                      short b)

rem

public static int rem(byte a,
                      int b)

rem

public static long rem(byte a,
                       long b)

rem

public static float rem(byte a,
                        float b)

rem

public static double rem(byte a,
                         double b)

rem

public static int rem(short a,
                      byte b)

rem

public static int rem(short a,
                      short b)

rem

public static int rem(short a,
                      int b)

rem

public static long rem(short a,
                       long b)

rem

public static float rem(short a,
                        float b)

rem

public static double rem(short a,
                         double b)

rem

public static int rem(int a,
                      byte b)

rem

public static int rem(int a,
                      short b)

rem

public static int rem(int a,
                      int b)

rem

public static long rem(int a,
                       long b)

rem

public static float rem(int a,
                        float b)

rem

public static double rem(int a,
                         double b)

rem

public static long rem(long a,
                       byte b)

rem

public static long rem(long a,
                       short b)

rem

public static long rem(long a,
                       int b)

rem

public static long rem(long a,
                       long b)

rem

public static float rem(long a,
                        float b)

rem

public static double rem(long a,
                         double b)

rem

public static float rem(float a,
                        byte b)

rem

public static float rem(float a,
                        short b)

rem

public static float rem(float a,
                        int b)

rem

public static float rem(float a,
                        long b)

rem

public static float rem(float a,
                        float b)

rem

public static double rem(float a,
                         double b)

rem

public static double rem(double a,
                         byte b)

rem

public static double rem(double a,
                         short b)

rem

public static double rem(double a,
                         int b)

rem

public static double rem(double a,
                         long b)

rem

public static double rem(double a,
                         float b)

rem

public static double rem(double a,
                         double b)

minus

public static int minus(byte a,
                        byte b)

minus

public static int minus(byte a,
                        short b)

minus

public static int minus(byte a,
                        int b)

minus

public static long minus(byte a,
                         long b)

minus

public static float minus(byte a,
                          float b)

minus

public static double minus(byte a,
                           double b)

minus

public static int minus(short a,
                        byte b)

minus

public static int minus(short a,
                        short b)

minus

public static int minus(short a,
                        int b)

minus

public static long minus(short a,
                         long b)

minus

public static float minus(short a,
                          float b)

minus

public static double minus(short a,
                           double b)

minus

public static int minus(int a,
                        byte b)

minus

public static int minus(int a,
                        short b)

minus

public static int minus(int a,
                        int b)

minus

public static long minus(int a,
                         long b)

minus

public static float minus(int a,
                          float b)

minus

public static double minus(int a,
                           double b)

minus

public static long minus(long a,
                         byte b)

minus

public static long minus(long a,
                         short b)

minus

public static long minus(long a,
                         int b)

minus

public static long minus(long a,
                         long b)

minus

public static float minus(long a,
                          float b)

minus

public static double minus(long a,
                           double b)

minus

public static float minus(float a,
                          byte b)

minus

public static float minus(float a,
                          short b)

minus

public static float minus(float a,
                          int b)

minus

public static float minus(float a,
                          long b)

minus

public static float minus(float a,
                          float b)

minus

public static double minus(float a,
                           double b)

minus

public static double minus(double a,
                           byte b)

minus

public static double minus(double a,
                           short b)

minus

public static double minus(double a,
                           int b)

minus

public static double minus(double a,
                           long b)

minus

public static double minus(double a,
                           float b)

minus

public static double minus(double a,
                           double b)

mul

public static int mul(byte a,
                      byte b)

mul

public static int mul(byte a,
                      short b)

mul

public static int mul(byte a,
                      int b)

mul

public static long mul(byte a,
                       long b)

mul

public static float mul(byte a,
                        float b)

mul

public static double mul(byte a,
                         double b)

mul

public static int mul(short a,
                      byte b)

mul

public static int mul(short a,
                      short b)

mul

public static int mul(short a,
                      int b)

mul

public static long mul(short a,
                       long b)

mul

public static float mul(short a,
                        float b)

mul

public static double mul(short a,
                         double b)

mul

public static int mul(int a,
                      byte b)

mul

public static int mul(int a,
                      short b)

mul

public static int mul(int a,
                      int b)

mul

public static long mul(int a,
                       long b)

mul

public static float mul(int a,
                        float b)

mul

public static double mul(int a,
                         double b)

mul

public static long mul(long a,
                       byte b)

mul

public static long mul(long a,
                       short b)

mul

public static long mul(long a,
                       int b)

mul

public static long mul(long a,
                       long b)

mul

public static float mul(long a,
                        float b)

mul

public static double mul(long a,
                         double b)

mul

public static float mul(float a,
                        byte b)

mul

public static float mul(float a,
                        short b)

mul

public static float mul(float a,
                        int b)

mul

public static float mul(float a,
                        long b)

mul

public static float mul(float a,
                        float b)

mul

public static double mul(float a,
                         double b)

mul

public static double mul(double a,
                         byte b)

mul

public static double mul(double a,
                         short b)

mul

public static double mul(double a,
                         int b)

mul

public static double mul(double a,
                         long b)

mul

public static double mul(double a,
                         float b)

mul

public static double mul(double a,
                         double b)

div

public static int div(byte a,
                      byte b)

div

public static int div(byte a,
                      short b)

div

public static int div(byte a,
                      int b)

div

public static long div(byte a,
                       long b)

div

public static float div(byte a,
                        float b)

div

public static double div(byte a,
                         double b)

div

public static int div(short a,
                      byte b)

div

public static int div(short a,
                      short b)

div

public static int div(short a,
                      int b)

div

public static long div(short a,
                       long b)

div

public static float div(short a,
                        float b)

div

public static double div(short a,
                         double b)

div

public static int div(int a,
                      byte b)

div

public static int div(int a,
                      short b)

div

public static int div(int a,
                      int b)

div

public static long div(int a,
                       long b)

div

public static float div(int a,
                        float b)

div

public static double div(int a,
                         double b)

div

public static long div(long a,
                       byte b)

div

public static long div(long a,
                       short b)

div

public static long div(long a,
                       int b)

div

public static long div(long a,
                       long b)

div

public static float div(long a,
                        float b)

div

public static double div(long a,
                         double b)

div

public static float div(float a,
                        byte b)

div

public static float div(float a,
                        short b)

div

public static float div(float a,
                        int b)

div

public static float div(float a,
                        long b)

div

public static float div(float a,
                        float b)

div

public static double div(float a,
                         double b)

div

public static double div(double a,
                         byte b)

div

public static double div(double a,
                         short b)

div

public static double div(double a,
                         int b)

div

public static double div(double a,
                         long b)

div

public static double div(double a,
                         float b)

div

public static double div(double a,
                         double b)

compare

public static int compare(int a,
                          int b)

compare

public static int compare(long a,
                          long b)

compare

public static int compare(float a,
                          float b)

compare

public static int compare(double a,
                          double b)

newPrimitiveDouble

public static double newPrimitiveDouble(byte a)

newPrimitiveDouble

public static double newPrimitiveDouble(short a)

newPrimitiveDouble

public static double newPrimitiveDouble(int a)

newPrimitiveDouble

public static double newPrimitiveDouble(long a)

newPrimitiveDouble

public static double newPrimitiveDouble(float a)

newPrimitiveShort

public static short newPrimitiveShort(byte a)

newPrimitiveInt

public static int newPrimitiveInt(byte a)

newPrimitiveInt

public static int newPrimitiveInt(short a)

newPrimitiveLong

public static long newPrimitiveLong(byte a)

newPrimitiveLong

public static long newPrimitiveLong(short a)

newPrimitiveLong

public static long newPrimitiveLong(int a)

not
```
public static boolean not(boolean a)
```

Class HJavaDefaultOperators

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

HJavaDefaultOperators

Method Detail

minus

minus

minus

minus

minus

minus

tilde

tilde

tilde

tilde

or

binaryOr

binaryOr

binaryAnd

binaryAnd

and

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

plus

rem

rem

rem

rem

rem

rem

rem

rem

rem

rem

rem

rem

rem

rem

rem

rem

rem

rem

rem