java.lang.Object
- com.speedment.runtime.compute.expression.Expressions

```
public final class Expressions
extends Object
```
Common mathematical expressions often used on Speedment entities.

Since:

3.1.0

Author:

Emil Forslund

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static <T> ToByte<T>`	`abs(ToByte<T> expression)`	Returns an expression that takes an expression and returns its absolute (removing the negation sign if any).
`static <T> ToDouble<T>`	`abs(ToDouble<T> expression)`	Returns an expression that takes an expression and returns its absolute (removing the negation sign if any).
`static <T> ToFloat<T>`	`abs(ToFloat<T> expression)`	Returns an expression that takes an expression and returns its absolute (removing the negation sign if any).
`static <T> ToInt<T>`	`abs(ToInt<T> expression)`	Returns an expression that takes an expression and returns its absolute (removing the negation sign if any).
`static <T> ToLong<T>`	`abs(ToLong<T> expression)`	Returns an expression that takes an expression and returns its absolute (removing the negation sign if any).
`static <T> ToShort<T>`	`abs(ToShort<T> expression)`	Returns an expression that takes an expression and returns its absolute (removing the negation sign if any).
`static <T> ToByteNullable<T>`	`absOrNull(ToByteNullable<T> expression)`	Returns an expression that takes an expression and returns its absolute (removing the negation sign if any).
`static <T> ToDoubleNullable<T>`	`absOrNull(ToDoubleNullable<T> expression)`	Returns an expression that takes an expression and returns its absolute (removing the negation sign if any).
`static <T> ToFloatNullable<T>`	`absOrNull(ToFloatNullable<T> expression)`	Returns an expression that takes an expression and returns its absolute (removing the negation sign if any).
`static <T> ToIntNullable<T>`	`absOrNull(ToIntNullable<T> expression)`	Returns an expression that takes an expression and returns its absolute (removing the negation sign if any).
`static <T> ToLongNullable<T>`	`absOrNull(ToLongNullable<T> expression)`	Returns an expression that takes an expression and returns its absolute (removing the negation sign if any).
`static <T> ToShortNullable<T>`	`absOrNull(ToShortNullable<T> expression)`	Returns an expression that takes an expression and returns its absolute (removing the negation sign if any).
`static <T> ToDouble<T>`	`byteToDouble(ToByte<T> expression)`	Creates and returns an expression that converts the result of the specified expression into a `double` by casting.
`static <T> ToDoubleNullable<T>`	`byteToDoubleNullable(ToByteNullable<T> expression)`	Creates and returns an expression that converts the result of the specified expression into a `double` by casting.
`static <T> ToDouble<T>`	`divide(ToByte<T> first, double second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToByte<T> first, int second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToByte<T> first, long second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToByte<T> first, ToDouble<T> second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToByte<T> first, ToInt<T> second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToByte<T> first, ToLong<T> second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToDouble<T> first, double second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToDouble<T> first, int second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToDouble<T> first, long second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToDouble<T> first, ToDouble<T> second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToDouble<T> first, ToInt<T> second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToDouble<T> first, ToLong<T> second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToFloat<T> first, double second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToFloat<T> first, int second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToFloat<T> first, long second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToFloat<T> first, ToDouble<T> second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToFloat<T> first, ToInt<T> second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToFloat<T> first, ToLong<T> second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToInt<T> first, double second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToInt<T> first, int second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToInt<T> first, long second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToInt<T> first, ToDouble<T> second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToInt<T> first, ToInt<T> second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToInt<T> first, ToLong<T> second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToLong<T> first, double second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToLong<T> first, int second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToLong<T> first, long second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToLong<T> first, ToDouble<T> second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToLong<T> first, ToInt<T> second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToLong<T> first, ToLong<T> second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToShort<T> first, double second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToShort<T> first, int second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToShort<T> first, long second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToShort<T> first, ToDouble<T> second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToShort<T> first, ToInt<T> second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`divide(ToShort<T> first, ToLong<T> second)`	Returns an expression that takes the result from the first expression and divides it with the result of the second expression.
`static <T> ToDouble<T>`	`floatToDouble(ToFloat<T> expression)`	Creates and returns an expression that converts the result of the specified expression into a `double` by casting.
`static <T> ToDoubleNullable<T>`	`floatToDoubleNullable(ToFloatNullable<T> expression)`	Creates and returns an expression that converts the result of the specified expression into a `double` by casting.
`static <T> ToDouble<T>`	`intToDouble(ToInt<T> expression)`	Creates and returns an expression that converts the result of the specified expression into a `double` by casting.
`static <T> ToDoubleNullable<T>`	`intToDoubleNullable(ToIntNullable<T> expression)`	Creates and returns an expression that converts the result of the specified expression into a `double` by casting.
`static <T> ToString<T>`	`joining(ToString<T>... expressions)`	Returns an expression that represents the result of all the specified expressions joined together, forming a single string.
`static <T> ToString<T>`	`joining(ToString<T> first, ToString<T> second)`	Returns an expression that represents the result of the two specified expressions joined together, forming a single string.
`static <T> ToString<T>`	`joining(CharSequence separator, ToString<T>... expressions)`	Returns an expression that represents the result of all the specified expressions joined together with separators between them, forming a single string.
`static <T> ToString<T>`	`joining(CharSequence separator, ToString<T> first, ToString<T> second)`	Returns an expression that represents the result of the two specified expressions joined together with a separator between them, forming a single string.
`static <T> ToString<T>`	`joining(CharSequence separator, CharSequence prefix, CharSequence suffix, ToString<T>... expressions)`	Returns an expression that represents the result of all the specified expressions joined together with separators between them, with a prefix before the entire result and a suffix after it, forming a single string.
`static <T> ToString<T>`	`joining(CharSequence separator, CharSequence prefix, CharSequence suffix, ToString<T> first, ToString<T> second)`	Returns an expression that represents the result of the two specified expressions joined together with a separator between them, with a prefix before the entire result and a suffix after it, forming a single string.
`static <T> ToDouble<T>`	`longToDouble(ToLong<T> expression)`	Creates and returns an expression that converts the result of the specified expression into a `double` by casting.
`static <T> ToDoubleNullable<T>`	`longToDoubleNullable(ToLongNullable<T> expression)`	Creates and returns an expression that converts the result of the specified expression into a `double` by casting.
`static <T> ToShort<T>`	`minus(ToByte<T> first, byte second)`	Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
`static <T> ToInt<T>`	`minus(ToByte<T> first, int second)`	Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
`static <T> ToLong<T>`	`minus(ToByte<T> first, long second)`	Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
`static <T> ToShort<T>`	`minus(ToByte<T> first, ToByte<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the difference.
`static <T> ToDouble<T>`	`minus(ToDouble<T> first, double second)`	Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
`static <T> ToDouble<T>`	`minus(ToDouble<T> first, int second)`	Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
`static <T> ToDouble<T>`	`minus(ToDouble<T> first, long second)`	Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
`static <T> ToDouble<T>`	`minus(ToDouble<T> first, ToDouble<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the difference.
`static <T> ToDouble<T>`	`minus(ToDouble<T> first, ToInt<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the difference.
`static <T> ToDouble<T>`	`minus(ToDouble<T> first, ToLong<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the difference.
`static <T> ToFloat<T>`	`minus(ToFloat<T> first, float second)`	Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
`static <T> ToFloat<T>`	`minus(ToFloat<T> first, int second)`	Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
`static <T> ToDouble<T>`	`minus(ToFloat<T> first, long second)`	Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
`static <T> ToFloat<T>`	`minus(ToFloat<T> first, ToFloat<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the difference.
`static <T> ToFloat<T>`	`minus(ToFloat<T> first, ToInt<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the difference.
`static <T> ToDouble<T>`	`minus(ToFloat<T> first, ToLong<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the difference.
`static <T> ToInt<T>`	`minus(ToInt<T> first, byte second)`	Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
`static <T> ToInt<T>`	`minus(ToInt<T> first, int second)`	Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
`static <T> ToLong<T>`	`minus(ToInt<T> first, long second)`	Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
`static <T> ToInt<T>`	`minus(ToInt<T> first, ToByte<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the difference.
`static <T> ToInt<T>`	`minus(ToInt<T> first, ToInt<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the difference.
`static <T> ToLong<T>`	`minus(ToLong<T> first, byte second)`	Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
`static <T> ToLong<T>`	`minus(ToLong<T> first, int second)`	Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
`static <T> ToLong<T>`	`minus(ToLong<T> first, long second)`	Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
`static <T> ToLong<T>`	`minus(ToLong<T> first, ToInt<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the difference.
`static <T> ToLong<T>`	`minus(ToLong<T> first, ToLong<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the difference.
`static <T> ToInt<T>`	`minus(ToShort<T> first, byte second)`	Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
`static <T> ToInt<T>`	`minus(ToShort<T> first, int second)`	Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
`static <T> ToLong<T>`	`minus(ToShort<T> first, long second)`	Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
`static <T> ToShort<T>`	`minus(ToShort<T> first, ToShort<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the difference.
`static <T> ToInt<T>`	`multiply(ToByte<T> first, byte second)`	Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
`static <T> ToInt<T>`	`multiply(ToByte<T> first, int second)`	Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
`static <T> ToLong<T>`	`multiply(ToByte<T> first, long second)`	Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
`static <T> ToInt<T>`	`multiply(ToByte<T> first, ToByte<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the product.
`static <T> ToDouble<T>`	`multiply(ToDouble<T> first, double second)`	Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
`static <T> ToDouble<T>`	`multiply(ToDouble<T> first, int second)`	Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
`static <T> ToDouble<T>`	`multiply(ToDouble<T> first, long second)`	Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
`static <T> ToDouble<T>`	`multiply(ToDouble<T> first, ToDouble<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the product.
`static <T> ToDouble<T>`	`multiply(ToDouble<T> first, ToInt<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the product.
`static <T> ToDouble<T>`	`multiply(ToDouble<T> first, ToLong<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the product.
`static <T> ToFloat<T>`	`multiply(ToFloat<T> first, float second)`	Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
`static <T> ToFloat<T>`	`multiply(ToFloat<T> first, int second)`	Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
`static <T> ToDouble<T>`	`multiply(ToFloat<T> first, long second)`	Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
`static <T> ToFloat<T>`	`multiply(ToFloat<T> first, ToFloat<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the product.
`static <T> ToFloat<T>`	`multiply(ToFloat<T> first, ToInt<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the product.
`static <T> ToDouble<T>`	`multiply(ToFloat<T> first, ToLong<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the product.
`static <T> ToInt<T>`	`multiply(ToInt<T> first, byte second)`	Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
`static <T> ToInt<T>`	`multiply(ToInt<T> first, int second)`	Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
`static <T> ToLong<T>`	`multiply(ToInt<T> first, long second)`	Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
`static <T> ToInt<T>`	`multiply(ToInt<T> first, ToByte<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the product.
`static <T> ToInt<T>`	`multiply(ToInt<T> first, ToInt<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the product.
`static <T> ToLong<T>`	`multiply(ToLong<T> first, byte second)`	Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
`static <T> ToLong<T>`	`multiply(ToLong<T> first, int second)`	Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
`static <T> ToLong<T>`	`multiply(ToLong<T> first, long second)`	Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
`static <T> ToLong<T>`	`multiply(ToLong<T> first, ToInt<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the product.
`static <T> ToLong<T>`	`multiply(ToLong<T> first, ToLong<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the product.
`static <T> ToInt<T>`	`multiply(ToShort<T> first, byte second)`	Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
`static <T> ToInt<T>`	`multiply(ToShort<T> first, int second)`	Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
`static <T> ToLong<T>`	`multiply(ToShort<T> first, long second)`	Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
`static <T> ToInt<T>`	`multiply(ToShort<T> first, ToShort<T> second)`	Creates and returns an expression that takes the result of the two expressions and computes the product.
`static <T> ToBigDecimal<T>`	`negate(ToBigDecimal<T> expression)`	Creates and returns an expression that will compute the negative result of the specified expression.
`static <T> ToBoolean<T>`	`negate(ToBoolean<T> expression)`	Creates and returns an expression that will compute the negative result of the specified expression.
`static <T> ToByte<T>`	`negate(ToByte<T> expression)`	Creates and returns an expression that will compute the negative result of the specified expression.
`static <T> ToDouble<T>`	`negate(ToDouble<T> expression)`	Creates and returns an expression that will compute the negative result of the specified expression.
`static <T> ToFloat<T>`	`negate(ToFloat<T> expression)`	Creates and returns an expression that will compute the negative result of the specified expression.
`static <T> ToInt<T>`	`negate(ToInt<T> expression)`	Creates and returns an expression that will compute the negative result of the specified expression.
`static <T> ToLong<T>`	`negate(ToLong<T> expression)`	Creates and returns an expression that will compute the negative result of the specified expression.
`static <T> ToShort<T>`	`negate(ToShort<T> expression)`	Creates and returns an expression that will compute the negative result of the specified expression.
`static <T> ToBooleanNullable<T>`	`negateOrNull(ToBooleanNullable<T> expression)`	Creates and returns an expression that will compute the negative result of the specified expression.
`static <T> ToByteNullable<T>`	`negateOrNull(ToByteNullable<T> expression)`	Creates and returns an expression that will compute the negative result of the specified expression.
`static <T> ToDoubleNullable<T>`	`negateOrNull(ToDoubleNullable<T> expression)`	Creates and returns an expression that will compute the negative result of the specified expression.
`static <T> ToFloatNullable<T>`	`negateOrNull(ToFloatNullable<T> expression)`	Creates and returns an expression that will compute the negative result of the specified expression.
`static <T> ToIntNullable<T>`	`negateOrNull(ToIntNullable<T> expression)`	Creates and returns an expression that will compute the negative result of the specified expression.
`static <T> ToLongNullable<T>`	`negateOrNull(ToLongNullable<T> expression)`	Creates and returns an expression that will compute the negative result of the specified expression.
`static <T> ToShortNullable<T>`	`negateOrNull(ToShortNullable<T> expression)`	Creates and returns an expression that will compute the negative result of the specified expression.
`static <T> ToShort<T>`	`plus(ToByte<T> first, byte second)`	Creates and returns an expression that takes the result of the expression and adds a constant to it.
`static <T> ToInt<T>`	`plus(ToByte<T> first, int second)`	Creates and returns an expression that takes the result of the expression and adds a constant to it.
`static <T> ToLong<T>`	`plus(ToByte<T> first, long second)`	Creates and returns an expression that takes the result of the expression and adds a constant to it.
`static <T> ToShort<T>`	`plus(ToByte<T> first, ToByte<T> second)`	Creates and returns an expression that takes the result of the two expressions and add them together.
`static <T> ToDouble<T>`	`plus(ToDouble<T> first, double second)`	Creates and returns an expression that takes the result of the expression and adds a constant to it.
`static <T> ToDouble<T>`	`plus(ToDouble<T> first, int second)`	Creates and returns an expression that takes the result of the expression and adds a constant to it.
`static <T> ToDouble<T>`	`plus(ToDouble<T> first, long second)`	Creates and returns an expression that takes the result of the expression and adds a constant to it.
`static <T> ToDouble<T>`	`plus(ToDouble<T> first, ToDouble<T> second)`	Creates and returns an expression that takes the result of the two expressions and add them together.
`static <T> ToDouble<T>`	`plus(ToDouble<T> first, ToInt<T> second)`	Creates and returns an expression that takes the result of the two expressions and add them together.
`static <T> ToDouble<T>`	`plus(ToDouble<T> first, ToLong<T> second)`	Creates and returns an expression that takes the result of the two expressions and add them together.
`static <T> ToFloat<T>`	`plus(ToFloat<T> first, float second)`	Creates and returns an expression that takes the result of the expression and adds a constant to it.
`static <T> ToFloat<T>`	`plus(ToFloat<T> first, int second)`	Creates and returns an expression that takes the result of the expression and adds a constant to it.
`static <T> ToDouble<T>`	`plus(ToFloat<T> first, long second)`	Creates and returns an expression that takes the result of the expression and adds a constant to it.
`static <T> ToFloat<T>`	`plus(ToFloat<T> first, ToFloat<T> second)`	Creates and returns an expression that takes the result of the two expressions and add them together.
`static <T> ToFloat<T>`	`plus(ToFloat<T> first, ToInt<T> second)`	Creates and returns an expression that takes the result of the two expressions and add them together.
`static <T> ToDouble<T>`	`plus(ToFloat<T> first, ToLong<T> second)`	Creates and returns an expression that takes the result of the two expressions and add them together.
`static <T> ToInt<T>`	`plus(ToInt<T> first, byte second)`	Creates and returns an expression that takes the result of the expression and adds a constant to it.
`static <T> ToInt<T>`	`plus(ToInt<T> first, int second)`	Creates and returns an expression that takes the result of the expression and adds a constant to it.
`static <T> ToLong<T>`	`plus(ToInt<T> first, long second)`	Creates and returns an expression that takes the result of the expression and adds a constant to it.
`static <T> ToInt<T>`	`plus(ToInt<T> first, ToByte<T> second)`	Creates and returns an expression that takes the result of the two expressions and add them together.
`static <T> ToInt<T>`	`plus(ToInt<T> first, ToInt<T> second)`	Creates and returns an expression that takes the result of the two expressions and add them together.
`static <T> ToLong<T>`	`plus(ToLong<T> first, byte second)`	Creates and returns an expression that takes the result of the expression and adds a constant to it.
`static <T> ToLong<T>`	`plus(ToLong<T> first, int second)`	Creates and returns an expression that takes the result of the expression and adds a constant to it.
`static <T> ToLong<T>`	`plus(ToLong<T> first, long second)`	Creates and returns an expression that takes the result of the expression and adds a constant to it.
`static <T> ToLong<T>`	`plus(ToLong<T> first, ToInt<T> second)`	Creates and returns an expression that takes the result of the two expressions and add them together.
`static <T> ToLong<T>`	`plus(ToLong<T> first, ToLong<T> second)`	Creates and returns an expression that takes the result of the two expressions and add them together.
`static <T> ToInt<T>`	`plus(ToShort<T> first, byte second)`	Creates and returns an expression that takes the result of the expression and adds a constant to it.
`static <T> ToInt<T>`	`plus(ToShort<T> first, int second)`	Creates and returns an expression that takes the result of the expression and adds a constant to it.
`static <T> ToLong<T>`	`plus(ToShort<T> first, long second)`	Creates and returns an expression that takes the result of the expression and adds a constant to it.
`static <T> ToShort<T>`	`plus(ToShort<T> first, ToShort<T> second)`	Creates and returns an expression that takes the result of the two expressions and add them together.
`static <T> ToDouble<T>`	`pow(ToByte<T> expression, double power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDouble<T>`	`pow(ToByte<T> expression, int power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDouble<T>`	`pow(ToByte<T> expression, ToDouble<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDouble<T>`	`pow(ToByte<T> expression, ToInt<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDouble<T>`	`pow(ToDouble<T> expression, double power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDouble<T>`	`pow(ToDouble<T> expression, int power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDouble<T>`	`pow(ToDouble<T> expression, ToDouble<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDouble<T>`	`pow(ToDouble<T> expression, ToInt<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDouble<T>`	`pow(ToFloat<T> expression, double power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDouble<T>`	`pow(ToFloat<T> expression, int power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDouble<T>`	`pow(ToFloat<T> expression, ToDouble<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDouble<T>`	`pow(ToFloat<T> expression, ToInt<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDouble<T>`	`pow(ToInt<T> expression, double power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDouble<T>`	`pow(ToInt<T> expression, int power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDouble<T>`	`pow(ToInt<T> expression, ToDouble<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDouble<T>`	`pow(ToInt<T> expression, ToInt<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDouble<T>`	`pow(ToLong<T> expression, double power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDouble<T>`	`pow(ToLong<T> expression, int power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDouble<T>`	`pow(ToLong<T> expression, ToDouble<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDouble<T>`	`pow(ToLong<T> expression, ToInt<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDouble<T>`	`pow(ToShort<T> expression, double power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDouble<T>`	`pow(ToShort<T> expression, int power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDouble<T>`	`pow(ToShort<T> expression, ToDouble<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDouble<T>`	`pow(ToShort<T> expression, ToInt<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToByteNullable<T> expression, double power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToByteNullable<T> expression, int power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToByteNullable<T> expression, ToDouble<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToByteNullable<T> expression, ToInt<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToDoubleNullable<T> expression, double power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToDoubleNullable<T> expression, int power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToDoubleNullable<T> expression, ToDouble<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToDoubleNullable<T> expression, ToInt<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToFloatNullable<T> expression, double power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToFloatNullable<T> expression, int power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToFloatNullable<T> expression, ToDouble<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToFloatNullable<T> expression, ToInt<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToIntNullable<T> expression, double power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToIntNullable<T> expression, int power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToIntNullable<T> expression, ToDouble<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToIntNullable<T> expression, ToInt<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToLongNullable<T> expression, double power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToLongNullable<T> expression, int power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToLongNullable<T> expression, ToDouble<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToLongNullable<T> expression, ToInt<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToShortNullable<T> expression, double power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToShortNullable<T> expression, int power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself `power` times.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToShortNullable<T> expression, ToDouble<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDoubleNullable<T>`	`powOrNull(ToShortNullable<T> expression, ToInt<T> power)`	Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying `power` to the input.
`static <T> ToDouble<T>`	`shortToDouble(ToShort<T> expression)`	Creates and returns an expression that converts the result of the specified expression into a `double` by casting.
`static <T> ToDoubleNullable<T>`	`shortToDoubleNullable(ToShortNullable<T> expression)`	Creates and returns an expression that converts the result of the specified expression into a `double` by casting.
`static <T> ToByte<T>`	`sign(ToBigDecimal<T> expression)`	Creates and returns an expression that returns `1` if the result of the input expression is positive, `-1` if the result of the input expression is negative and `0` if the result of the input expression is `0`.
`static <T> ToByte<T>`	`sign(ToByte<T> expression)`	Creates and returns an expression that returns `1` if the result of the input expression is positive, `-1` if the result of the input expression is negative and `0` if the result of the input expression is `0`.
`static <T> ToByte<T>`	`sign(ToDouble<T> expression)`	Creates and returns an expression that returns `1` if the result of the input expression is positive, `-1` if the result of the input expression is negative and `0` if the result of the input expression is `0`.
`static <T> ToByte<T>`	`sign(ToFloat<T> expression)`	Creates and returns an expression that returns `1` if the result of the input expression is positive, `-1` if the result of the input expression is negative and `0` if the result of the input expression is `0`.
`static <T> ToByte<T>`	`sign(ToInt<T> expression)`	Creates and returns an expression that returns `1` if the result of the input expression is positive, `-1` if the result of the input expression is negative and `0` if the result of the input expression is `0`.
`static <T> ToByte<T>`	`sign(ToLong<T> expression)`	Creates and returns an expression that returns `1` if the result of the input expression is positive, `-1` if the result of the input expression is negative and `0` if the result of the input expression is `0`.
`static <T> ToByte<T>`	`sign(ToShort<T> expression)`	Creates and returns an expression that returns `1` if the result of the input expression is positive, `-1` if the result of the input expression is negative and `0` if the result of the input expression is `0`.
`static <T> ToByteNullable<T>`	`signOrNull(ToByteNullable<T> expression)`	Creates and returns an expression that returns `1` if the result of the input expression is positive, `-1` if the result of the input expression is negative and `0` if the result of the input expression is `0`.
`static <T> ToByteNullable<T>`	`signOrNull(ToDoubleNullable<T> expression)`	Creates and returns an expression that returns `1` if the result of the input expression is positive, `-1` if the result of the input expression is negative and `0` if the result of the input expression is `0`.
`static <T> ToByteNullable<T>`	`signOrNull(ToFloatNullable<T> expression)`	Creates and returns an expression that returns `1` if the result of the input expression is positive, `-1` if the result of the input expression is negative and `0` if the result of the input expression is `0`.
`static <T> ToByteNullable<T>`	`signOrNull(ToIntNullable<T> expression)`	Creates and returns an expression that returns `1` if the result of the input expression is positive, `-1` if the result of the input expression is negative and `0` if the result of the input expression is `0`.
`static <T> ToByteNullable<T>`	`signOrNull(ToLongNullable<T> expression)`	Creates and returns an expression that returns `1` if the result of the input expression is positive, `-1` if the result of the input expression is negative and `0` if the result of the input expression is `0`.
`static <T> ToByteNullable<T>`	`signOrNull(ToShortNullable<T> expression)`	Creates and returns an expression that returns `1` if the result of the input expression is positive, `-1` if the result of the input expression is negative and `0` if the result of the input expression is `0`.
`static <T> ToDouble<T>`	`sqrt(ToByte<T> expression)`	Creates and returns an expression that returns the square root of the result from the input expression.
`static <T> ToDouble<T>`	`sqrt(ToDouble<T> expression)`	Creates and returns an expression that returns the square root of the result from the input expression.
`static <T> ToDouble<T>`	`sqrt(ToFloat<T> expression)`	Creates and returns an expression that returns the square root of the result from the input expression.
`static <T> ToDouble<T>`	`sqrt(ToInt<T> expression)`	Creates and returns an expression that returns the square root of the result from the input expression.
`static <T> ToDouble<T>`	`sqrt(ToLong<T> expression)`	Creates and returns an expression that returns the square root of the result from the input expression.
`static <T> ToDouble<T>`	`sqrt(ToShort<T> expression)`	Creates and returns an expression that returns the square root of the result from the input expression.
`static <T> ToDoubleNullable<T>`	`sqrtOrNull(ToByteNullable<T> expression)`	Creates and returns an expression that returns the square root of the result from the input expression.
`static <T> ToDoubleNullable<T>`	`sqrtOrNull(ToDoubleNullable<T> expression)`	Creates and returns an expression that returns the square root of the result from the input expression.
`static <T> ToDoubleNullable<T>`	`sqrtOrNull(ToFloatNullable<T> expression)`	Creates and returns an expression that returns the square root of the result from the input expression.
`static <T> ToDoubleNullable<T>`	`sqrtOrNull(ToIntNullable<T> expression)`	Creates and returns an expression that returns the square root of the result from the input expression.
`static <T> ToDoubleNullable<T>`	`sqrtOrNull(ToLongNullable<T> expression)`	Creates and returns an expression that returns the square root of the result from the input expression.
`static <T> ToDoubleNullable<T>`	`sqrtOrNull(ToShortNullable<T> expression)`	Creates and returns an expression that returns the square root of the result from the input expression.

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

- Method Detail
  - byteToDouble
```
public static <T> ToDouble<T> byteToDouble(ToByte<T> expression)
```
    Creates and returns an expression that converts the result of the specified expression into a double by casting.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the initial expression
    
    Returns:
    
    the new expression
  - shortToDouble
```
public static <T> ToDouble<T> shortToDouble(ToShort<T> expression)
```
    Creates and returns an expression that converts the result of the specified expression into a double by casting.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the initial expression
    
    Returns:
    
    the new expression
  - intToDouble
```
public static <T> ToDouble<T> intToDouble(ToInt<T> expression)
```
    Creates and returns an expression that converts the result of the specified expression into a double by casting.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the initial expression
    
    Returns:
    
    the new expression
  - longToDouble
```
public static <T> ToDouble<T> longToDouble(ToLong<T> expression)
```
    Creates and returns an expression that converts the result of the specified expression into a double by casting.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the initial expression
    
    Returns:
    
    the new expression
  - floatToDouble
```
public static <T> ToDouble<T> floatToDouble(ToFloat<T> expression)
```
    Creates and returns an expression that converts the result of the specified expression into a double by casting.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the initial expression
    
    Returns:
    
    the new expression
  - byteToDoubleNullable
```
public static <T> ToDoubleNullable<T> byteToDoubleNullable(ToByteNullable<T> expression)
```
    Creates and returns an expression that converts the result of the specified expression into a double by casting. If the result of the input is null, then the new expression will also return null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the initial expression
    
    Returns:
    
    the new expression
  - shortToDoubleNullable
```
public static <T> ToDoubleNullable<T> shortToDoubleNullable(ToShortNullable<T> expression)
```
    Creates and returns an expression that converts the result of the specified expression into a double by casting. If the result of the input is null, then the new expression will also return null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the initial expression
    
    Returns:
    
    the new expression
  - intToDoubleNullable
```
public static <T> ToDoubleNullable<T> intToDoubleNullable(ToIntNullable<T> expression)
```
    Creates and returns an expression that converts the result of the specified expression into a double by casting. If the result of the input is null, then the new expression will also return null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the initial expression
    
    Returns:
    
    the new expression
  - longToDoubleNullable
```
public static <T> ToDoubleNullable<T> longToDoubleNullable(ToLongNullable<T> expression)
```
    Creates and returns an expression that converts the result of the specified expression into a double by casting. If the result of the input is null, then the new expression will also return null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the initial expression
    
    Returns:
    
    the new expression
  - floatToDoubleNullable
```
public static <T> ToDoubleNullable<T> floatToDoubleNullable(ToFloatNullable<T> expression)
```
    Creates and returns an expression that converts the result of the specified expression into a double by casting. If the result of the input is null, then the new expression will also return null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the initial expression
    
    Returns:
    
    the new expression
  - abs
```
public static <T> ToByte<T> abs(ToByte<T> expression)
```
    Returns an expression that takes an expression and returns its absolute (removing the negation sign if any).
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - abs
```
public static <T> ToShort<T> abs(ToShort<T> expression)
```
    Returns an expression that takes an expression and returns its absolute (removing the negation sign if any).
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - abs
```
public static <T> ToInt<T> abs(ToInt<T> expression)
```
    Returns an expression that takes an expression and returns its absolute (removing the negation sign if any).
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - abs
```
public static <T> ToLong<T> abs(ToLong<T> expression)
```
    Returns an expression that takes an expression and returns its absolute (removing the negation sign if any).
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - abs
```
public static <T> ToFloat<T> abs(ToFloat<T> expression)
```
    Returns an expression that takes an expression and returns its absolute (removing the negation sign if any).
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - abs
```
public static <T> ToDouble<T> abs(ToDouble<T> expression)
```
    Returns an expression that takes an expression and returns its absolute (removing the negation sign if any).
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - absOrNull
```
public static <T> ToByteNullable<T> absOrNull(ToByteNullable<T> expression)
```
    Returns an expression that takes an expression and returns its absolute (removing the negation sign if any). If the result of the original expression is null, then the new expression will also return null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - absOrNull
```
public static <T> ToShortNullable<T> absOrNull(ToShortNullable<T> expression)
```
    Returns an expression that takes an expression and returns its absolute (removing the negation sign if any). If the result of the original expression is null, then the new expression will also return null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - absOrNull
```
public static <T> ToIntNullable<T> absOrNull(ToIntNullable<T> expression)
```
    Returns an expression that takes an expression and returns its absolute (removing the negation sign if any). If the result of the original expression is null, then the new expression will also return null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - absOrNull
```
public static <T> ToLongNullable<T> absOrNull(ToLongNullable<T> expression)
```
    Returns an expression that takes an expression and returns its absolute (removing the negation sign if any). If the result of the original expression is null, then the new expression will also return null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - absOrNull
```
public static <T> ToFloatNullable<T> absOrNull(ToFloatNullable<T> expression)
```
    Returns an expression that takes an expression and returns its absolute (removing the negation sign if any). If the result of the original expression is null, then the new expression will also return null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - absOrNull
```
public static <T> ToDoubleNullable<T> absOrNull(ToDoubleNullable<T> expression)
```
    Returns an expression that takes an expression and returns its absolute (removing the negation sign if any). If the result of the original expression is null, then the new expression will also return null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sign
```
public static <T> ToByte<T> sign(ToByte<T> expression)
```
    Creates and returns an expression that returns 1 if the result of the input expression is positive, -1 if the result of the input expression is negative and 0 if the result of the input expression is 0.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sign
```
public static <T> ToByte<T> sign(ToShort<T> expression)
```
    Creates and returns an expression that returns 1 if the result of the input expression is positive, -1 if the result of the input expression is negative and 0 if the result of the input expression is 0.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sign
```
public static <T> ToByte<T> sign(ToInt<T> expression)
```
    Creates and returns an expression that returns 1 if the result of the input expression is positive, -1 if the result of the input expression is negative and 0 if the result of the input expression is 0.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sign
```
public static <T> ToByte<T> sign(ToLong<T> expression)
```
    Creates and returns an expression that returns 1 if the result of the input expression is positive, -1 if the result of the input expression is negative and 0 if the result of the input expression is 0.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sign
```
public static <T> ToByte<T> sign(ToFloat<T> expression)
```
    Creates and returns an expression that returns 1 if the result of the input expression is positive, -1 if the result of the input expression is negative and 0 if the result of the input expression is 0.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sign
```
public static <T> ToByte<T> sign(ToDouble<T> expression)
```
    Creates and returns an expression that returns 1 if the result of the input expression is positive, -1 if the result of the input expression is negative and 0 if the result of the input expression is 0.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sign
```
public static <T> ToByte<T> sign(ToBigDecimal<T> expression)
```
    Creates and returns an expression that returns 1 if the result of the input expression is positive, -1 if the result of the input expression is negative and 0 if the result of the input expression is 0.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - signOrNull
```
public static <T> ToByteNullable<T> signOrNull(ToByteNullable<T> expression)
```
    Creates and returns an expression that returns 1 if the result of the input expression is positive, -1 if the result of the input expression is negative and 0 if the result of the input expression is 0. If the result of the given expression is null, then the result of this expression will also be null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - signOrNull
```
public static <T> ToByteNullable<T> signOrNull(ToShortNullable<T> expression)
```
    Creates and returns an expression that returns 1 if the result of the input expression is positive, -1 if the result of the input expression is negative and 0 if the result of the input expression is 0. If the result of the given expression is null, then the result of this expression will also be null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - signOrNull
```
public static <T> ToByteNullable<T> signOrNull(ToIntNullable<T> expression)
```
    Creates and returns an expression that returns 1 if the result of the input expression is positive, -1 if the result of the input expression is negative and 0 if the result of the input expression is 0. If the result of the given expression is null, then the result of this expression will also be null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - signOrNull
```
public static <T> ToByteNullable<T> signOrNull(ToLongNullable<T> expression)
```
    Creates and returns an expression that returns 1 if the result of the input expression is positive, -1 if the result of the input expression is negative and 0 if the result of the input expression is 0. If the result of the given expression is null, then the result of this expression will also be null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - signOrNull
```
public static <T> ToByteNullable<T> signOrNull(ToFloatNullable<T> expression)
```
    Creates and returns an expression that returns 1 if the result of the input expression is positive, -1 if the result of the input expression is negative and 0 if the result of the input expression is 0. If the result of the given expression is null, then the result of this expression will also be null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - signOrNull
```
public static <T> ToByteNullable<T> signOrNull(ToDoubleNullable<T> expression)
```
    Creates and returns an expression that returns 1 if the result of the input expression is positive, -1 if the result of the input expression is negative and 0 if the result of the input expression is 0. If the result of the given expression is null, then the result of this expression will also be null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sqrt
```
public static <T> ToDouble<T> sqrt(ToByte<T> expression)
```
    Creates and returns an expression that returns the square root of the result from the input expression.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sqrt
```
public static <T> ToDouble<T> sqrt(ToShort<T> expression)
```
    Creates and returns an expression that returns the square root of the result from the input expression.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sqrt
```
public static <T> ToDouble<T> sqrt(ToInt<T> expression)
```
    Creates and returns an expression that returns the square root of the result from the input expression.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sqrt
```
public static <T> ToDouble<T> sqrt(ToLong<T> expression)
```
    Creates and returns an expression that returns the square root of the result from the input expression.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sqrt
```
public static <T> ToDouble<T> sqrt(ToFloat<T> expression)
```
    Creates and returns an expression that returns the square root of the result from the input expression.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sqrt
```
public static <T> ToDouble<T> sqrt(ToDouble<T> expression)
```
    Creates and returns an expression that returns the square root of the result from the input expression.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sqrtOrNull
```
public static <T> ToDoubleNullable<T> sqrtOrNull(ToByteNullable<T> expression)
```
    Creates and returns an expression that returns the square root of the result from the input expression. If the result of the input expression is null, then the result of the new expression will also be null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sqrtOrNull
```
public static <T> ToDoubleNullable<T> sqrtOrNull(ToShortNullable<T> expression)
```
    Creates and returns an expression that returns the square root of the result from the input expression. If the result of the input expression is null, then the result of the new expression will also be null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sqrtOrNull
```
public static <T> ToDoubleNullable<T> sqrtOrNull(ToIntNullable<T> expression)
```
    Creates and returns an expression that returns the square root of the result from the input expression. If the result of the input expression is null, then the result of the new expression will also be null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sqrtOrNull
```
public static <T> ToDoubleNullable<T> sqrtOrNull(ToLongNullable<T> expression)
```
    Creates and returns an expression that returns the square root of the result from the input expression. If the result of the input expression is null, then the result of the new expression will also be null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sqrtOrNull
```
public static <T> ToDoubleNullable<T> sqrtOrNull(ToFloatNullable<T> expression)
```
    Creates and returns an expression that returns the square root of the result from the input expression. If the result of the input expression is null, then the result of the new expression will also be null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - sqrtOrNull
```
public static <T> ToDoubleNullable<T> sqrtOrNull(ToDoubleNullable<T> expression)
```
    Creates and returns an expression that returns the square root of the result from the input expression. If the result of the input expression is null, then the result of the new expression will also be null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToByte<T> expression,
                                  int power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToByte<T> expression,
                                  double power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToByte<T> expression,
                                  ToInt<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToByte<T> expression,
                                  ToDouble<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToByteNullable<T> expression,
                                                int power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToByteNullable<T> expression,
                                                double power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToByteNullable<T> expression,
                                                ToInt<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToByteNullable<T> expression,
                                                ToDouble<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToShort<T> expression,
                                  int power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToShort<T> expression,
                                  double power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToShort<T> expression,
                                  ToInt<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToShort<T> expression,
                                  ToDouble<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToShortNullable<T> expression,
                                                int power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToShortNullable<T> expression,
                                                double power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToShortNullable<T> expression,
                                                ToInt<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToShortNullable<T> expression,
                                                ToDouble<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToInt<T> expression,
                                  int power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToInt<T> expression,
                                  double power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToInt<T> expression,
                                  ToInt<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToInt<T> expression,
                                  ToDouble<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToIntNullable<T> expression,
                                                int power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToIntNullable<T> expression,
                                                double power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToIntNullable<T> expression,
                                                ToInt<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToIntNullable<T> expression,
                                                ToDouble<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToLong<T> expression,
                                  int power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToLong<T> expression,
                                  double power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToLong<T> expression,
                                  ToInt<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToLong<T> expression,
                                  ToDouble<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToLongNullable<T> expression,
                                                int power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToLongNullable<T> expression,
                                                double power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToLongNullable<T> expression,
                                                ToInt<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToLongNullable<T> expression,
                                                ToDouble<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToFloat<T> expression,
                                  int power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToFloat<T> expression,
                                  double power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToFloat<T> expression,
                                  ToInt<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToFloat<T> expression,
                                  ToDouble<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToFloatNullable<T> expression,
                                                int power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToFloatNullable<T> expression,
                                                double power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToFloatNullable<T> expression,
                                                ToInt<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToFloatNullable<T> expression,
                                                ToDouble<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToDouble<T> expression,
                                  int power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToDouble<T> expression,
                                  double power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToDouble<T> expression,
                                  ToInt<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - pow
```
public static <T> ToDouble<T> pow(ToDouble<T> expression,
                                  ToDouble<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToDoubleNullable<T> expression,
                                                int power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToDoubleNullable<T> expression,
                                                double power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself power times.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToDoubleNullable<T> expression,
                                                ToInt<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - powOrNull
```
public static <T> ToDoubleNullable<T> powOrNull(ToDoubleNullable<T> expression,
                                                ToDouble<T> power)
```
    Creates and returns an expression that takes the result of an input expression and multiplies it with itself as many times as the result of applying power to the input.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    power - the power
    
    Returns:
    
    the new expression
  - negate
```
public static <T> ToByte<T> negate(ToByte<T> expression)
```
    Creates and returns an expression that will compute the negative result of the specified expression.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - negate
```
public static <T> ToShort<T> negate(ToShort<T> expression)
```
    Creates and returns an expression that will compute the negative result of the specified expression.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - negate
```
public static <T> ToInt<T> negate(ToInt<T> expression)
```
    Creates and returns an expression that will compute the negative result of the specified expression.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - negate
```
public static <T> ToLong<T> negate(ToLong<T> expression)
```
    Creates and returns an expression that will compute the negative result of the specified expression.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - negate
```
public static <T> ToFloat<T> negate(ToFloat<T> expression)
```
    Creates and returns an expression that will compute the negative result of the specified expression.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - negate
```
public static <T> ToDouble<T> negate(ToDouble<T> expression)
```
    Creates and returns an expression that will compute the negative result of the specified expression.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - negate
```
public static <T> ToBigDecimal<T> negate(ToBigDecimal<T> expression)
```
    Creates and returns an expression that will compute the negative result of the specified expression.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - negate
```
public static <T> ToBoolean<T> negate(ToBoolean<T> expression)
```
    Creates and returns an expression that will compute the negative result of the specified expression.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - negateOrNull
```
public static <T> ToByteNullable<T> negateOrNull(ToByteNullable<T> expression)
```
    Creates and returns an expression that will compute the negative result of the specified expression. If the specified expression results in null, then the new expression will also return null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - negateOrNull
```
public static <T> ToShortNullable<T> negateOrNull(ToShortNullable<T> expression)
```
    Creates and returns an expression that will compute the negative result of the specified expression. If the specified expression results in null, then the new expression will also return null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - negateOrNull
```
public static <T> ToIntNullable<T> negateOrNull(ToIntNullable<T> expression)
```
    Creates and returns an expression that will compute the negative result of the specified expression. If the specified expression results in null, then the new expression will also return null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - negateOrNull
```
public static <T> ToLongNullable<T> negateOrNull(ToLongNullable<T> expression)
```
    Creates and returns an expression that will compute the negative result of the specified expression. If the specified expression results in null, then the new expression will also return null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - negateOrNull
```
public static <T> ToFloatNullable<T> negateOrNull(ToFloatNullable<T> expression)
```
    Creates and returns an expression that will compute the negative result of the specified expression. If the specified expression results in null, then the new expression will also return null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - negateOrNull
```
public static <T> ToDoubleNullable<T> negateOrNull(ToDoubleNullable<T> expression)
```
    Creates and returns an expression that will compute the negative result of the specified expression. If the specified expression results in null, then the new expression will also return null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - negateOrNull
```
public static <T> ToBooleanNullable<T> negateOrNull(ToBooleanNullable<T> expression)
```
    Creates and returns an expression that will compute the negative result of the specified expression. If the specified expression results in null, then the new expression will also return null.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    expression - the input expression
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToShort<T> plus(ToByte<T> first,
                                  byte second)
```
    Creates and returns an expression that takes the result of the expression and adds a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToInt<T> plus(ToByte<T> first,
                                int second)
```
    Creates and returns an expression that takes the result of the expression and adds a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToLong<T> plus(ToByte<T> first,
                                 long second)
```
    Creates and returns an expression that takes the result of the expression and adds a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToShort<T> plus(ToByte<T> first,
                                  ToByte<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and add them together.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToInt<T> plus(ToShort<T> first,
                                byte second)
```
    Creates and returns an expression that takes the result of the expression and adds a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToInt<T> plus(ToShort<T> first,
                                int second)
```
    Creates and returns an expression that takes the result of the expression and adds a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToLong<T> plus(ToShort<T> first,
                                 long second)
```
    Creates and returns an expression that takes the result of the expression and adds a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToShort<T> plus(ToShort<T> first,
                                  ToShort<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and add them together.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToInt<T> plus(ToInt<T> first,
                                byte second)
```
    Creates and returns an expression that takes the result of the expression and adds a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToInt<T> plus(ToInt<T> first,
                                int second)
```
    Creates and returns an expression that takes the result of the expression and adds a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToLong<T> plus(ToInt<T> first,
                                 long second)
```
    Creates and returns an expression that takes the result of the expression and adds a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToInt<T> plus(ToInt<T> first,
                                ToByte<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and add them together.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToInt<T> plus(ToInt<T> first,
                                ToInt<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and add them together.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToLong<T> plus(ToLong<T> first,
                                 byte second)
```
    Creates and returns an expression that takes the result of the expression and adds a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToLong<T> plus(ToLong<T> first,
                                 int second)
```
    Creates and returns an expression that takes the result of the expression and adds a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToLong<T> plus(ToLong<T> first,
                                 long second)
```
    Creates and returns an expression that takes the result of the expression and adds a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToLong<T> plus(ToLong<T> first,
                                 ToInt<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and add them together.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToLong<T> plus(ToLong<T> first,
                                 ToLong<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and add them together.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToFloat<T> plus(ToFloat<T> first,
                                  int second)
```
    Creates and returns an expression that takes the result of the expression and adds a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToDouble<T> plus(ToFloat<T> first,
                                   long second)
```
    Creates and returns an expression that takes the result of the expression and adds a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToFloat<T> plus(ToFloat<T> first,
                                  float second)
```
    Creates and returns an expression that takes the result of the expression and adds a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToFloat<T> plus(ToFloat<T> first,
                                  ToInt<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and add them together.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToDouble<T> plus(ToFloat<T> first,
                                   ToLong<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and add them together.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToFloat<T> plus(ToFloat<T> first,
                                  ToFloat<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and add them together.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToDouble<T> plus(ToDouble<T> first,
                                   int second)
```
    Creates and returns an expression that takes the result of the expression and adds a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToDouble<T> plus(ToDouble<T> first,
                                   long second)
```
    Creates and returns an expression that takes the result of the expression and adds a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToDouble<T> plus(ToDouble<T> first,
                                   double second)
```
    Creates and returns an expression that takes the result of the expression and adds a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToDouble<T> plus(ToDouble<T> first,
                                   ToInt<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and add them together.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToDouble<T> plus(ToDouble<T> first,
                                   ToLong<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and add them together.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - plus
```
public static <T> ToDouble<T> plus(ToDouble<T> first,
                                   ToDouble<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and add them together.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToShort<T> minus(ToByte<T> first,
                                   byte second)
```
    Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToInt<T> minus(ToByte<T> first,
                                 int second)
```
    Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToLong<T> minus(ToByte<T> first,
                                  long second)
```
    Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToShort<T> minus(ToByte<T> first,
                                   ToByte<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the difference.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToInt<T> minus(ToShort<T> first,
                                 byte second)
```
    Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToInt<T> minus(ToShort<T> first,
                                 int second)
```
    Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToLong<T> minus(ToShort<T> first,
                                  long second)
```
    Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToShort<T> minus(ToShort<T> first,
                                   ToShort<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the difference.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToInt<T> minus(ToInt<T> first,
                                 byte second)
```
    Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToInt<T> minus(ToInt<T> first,
                                 int second)
```
    Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToLong<T> minus(ToInt<T> first,
                                  long second)
```
    Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToInt<T> minus(ToInt<T> first,
                                 ToByte<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the difference.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToInt<T> minus(ToInt<T> first,
                                 ToInt<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the difference.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToLong<T> minus(ToLong<T> first,
                                  byte second)
```
    Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToLong<T> minus(ToLong<T> first,
                                  int second)
```
    Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToLong<T> minus(ToLong<T> first,
                                  long second)
```
    Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToLong<T> minus(ToLong<T> first,
                                  ToInt<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the difference.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToLong<T> minus(ToLong<T> first,
                                  ToLong<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the difference.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToFloat<T> minus(ToFloat<T> first,
                                   int second)
```
    Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToDouble<T> minus(ToFloat<T> first,
                                    long second)
```
    Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToFloat<T> minus(ToFloat<T> first,
                                   float second)
```
    Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToFloat<T> minus(ToFloat<T> first,
                                   ToInt<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the difference.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToDouble<T> minus(ToFloat<T> first,
                                    ToLong<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the difference.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToFloat<T> minus(ToFloat<T> first,
                                   ToFloat<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the difference.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToDouble<T> minus(ToDouble<T> first,
                                    int second)
```
    Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToDouble<T> minus(ToDouble<T> first,
                                    long second)
```
    Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToDouble<T> minus(ToDouble<T> first,
                                    double second)
```
    Creates and returns an expression that takes the result of the expression and subtracts a constant from it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToDouble<T> minus(ToDouble<T> first,
                                    ToInt<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the difference.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToDouble<T> minus(ToDouble<T> first,
                                    ToLong<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the difference.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - minus
```
public static <T> ToDouble<T> minus(ToDouble<T> first,
                                    ToDouble<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the difference.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToInt<T> multiply(ToByte<T> first,
                                    byte second)
```
    Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToInt<T> multiply(ToByte<T> first,
                                    int second)
```
    Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToLong<T> multiply(ToByte<T> first,
                                     long second)
```
    Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToInt<T> multiply(ToByte<T> first,
                                    ToByte<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the product.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToInt<T> multiply(ToShort<T> first,
                                    byte second)
```
    Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToInt<T> multiply(ToShort<T> first,
                                    int second)
```
    Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToLong<T> multiply(ToShort<T> first,
                                     long second)
```
    Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToInt<T> multiply(ToShort<T> first,
                                    ToShort<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the product.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToInt<T> multiply(ToInt<T> first,
                                    byte second)
```
    Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToInt<T> multiply(ToInt<T> first,
                                    int second)
```
    Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToLong<T> multiply(ToInt<T> first,
                                     long second)
```
    Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToInt<T> multiply(ToInt<T> first,
                                    ToByte<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the product.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToInt<T> multiply(ToInt<T> first,
                                    ToInt<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the product.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToLong<T> multiply(ToLong<T> first,
                                     byte second)
```
    Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToLong<T> multiply(ToLong<T> first,
                                     int second)
```
    Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToLong<T> multiply(ToLong<T> first,
                                     long second)
```
    Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToLong<T> multiply(ToLong<T> first,
                                     ToInt<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the product.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToLong<T> multiply(ToLong<T> first,
                                     ToLong<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the product.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToFloat<T> multiply(ToFloat<T> first,
                                      int second)
```
    Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToDouble<T> multiply(ToFloat<T> first,
                                       long second)
```
    Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToFloat<T> multiply(ToFloat<T> first,
                                      float second)
```
    Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToFloat<T> multiply(ToFloat<T> first,
                                      ToInt<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the product.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToDouble<T> multiply(ToFloat<T> first,
                                       ToLong<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the product.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToFloat<T> multiply(ToFloat<T> first,
                                      ToFloat<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the product.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToDouble<T> multiply(ToDouble<T> first,
                                       int second)
```
    Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToDouble<T> multiply(ToDouble<T> first,
                                       long second)
```
    Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToDouble<T> multiply(ToDouble<T> first,
                                       double second)
```
    Creates and returns an expression that takes the result of the expression and multiplies a constant to it.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input constant
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToDouble<T> multiply(ToDouble<T> first,
                                       ToInt<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the product.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToDouble<T> multiply(ToDouble<T> first,
                                       ToLong<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the product.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - multiply
```
public static <T> ToDouble<T> multiply(ToDouble<T> first,
                                       ToDouble<T> second)
```
    Creates and returns an expression that takes the result of the two expressions and computes the product.
    
    Type Parameters:
    
    T - the input type
    
    Parameters:
    
    first - the first input expression
    
    second - the second input expression
    
    Returns:
    
    the new expression
  - divide
```
public static <T> ToDouble<T> divide(ToByte<T> first,
                                     int second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToByte<T> first,
                                     long second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToByte<T> first,
                                     double second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToByte<T> first,
                                     ToInt<T> second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToByte<T> first,
                                     ToLong<T> second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToByte<T> first,
                                     ToDouble<T> second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToShort<T> first,
                                     int second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToShort<T> first,
                                     long second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToShort<T> first,
                                     double second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToShort<T> first,
                                     ToInt<T> second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToShort<T> first,
                                     ToLong<T> second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToShort<T> first,
                                     ToDouble<T> second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToInt<T> first,
                                     int second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToInt<T> first,
                                     long second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToInt<T> first,
                                     double second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToInt<T> first,
                                     ToInt<T> second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToInt<T> first,
                                     ToLong<T> second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToInt<T> first,
                                     ToDouble<T> second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToLong<T> first,
                                     int second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToLong<T> first,
                                     long second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToLong<T> first,
                                     double second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToLong<T> first,
                                     ToInt<T> second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToLong<T> first,
                                     ToLong<T> second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToLong<T> first,
                                     ToDouble<T> second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToFloat<T> first,
                                     int second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToFloat<T> first,
                                     long second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToFloat<T> first,
                                     double second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToFloat<T> first,
                                     ToInt<T> second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToFloat<T> first,
                                     ToLong<T> second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToFloat<T> first,
                                     ToDouble<T> second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToDouble<T> first,
                                     int second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToDouble<T> first,
                                     long second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToDouble<T> first,
                                     double second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToDouble<T> first,
                                     ToInt<T> second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToDouble<T> first,
                                     ToLong<T> second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - divide
```
public static <T> ToDouble<T> divide(ToDouble<T> first,
                                     ToDouble<T> second)
```
    Returns an expression that takes the result from the first expression and divides it with the result of the second expression. The second expression must never return 0!
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the division expression
  - joining
```
public static <T> ToString<T> joining(ToString<T> first,
                                      ToString<T> second)
```
    Returns an expression that represents the result of the two specified expressions joined together, forming a single string.
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the joined expression
  - joining
```
public static <T> ToString<T> joining(CharSequence separator,
                                      ToString<T> first,
                                      ToString<T> second)
```
    Returns an expression that represents the result of the two specified expressions joined together with a separator between them, forming a single string.
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    separator - the separator (may be empty but never null)
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the joined expression
  - joining
```
public static <T> ToString<T> joining(CharSequence separator,
                                      CharSequence prefix,
                                      CharSequence suffix,
                                      ToString<T> first,
                                      ToString<T> second)
```
    Returns an expression that represents the result of the two specified expressions joined together with a separator between them, with a prefix before the entire result and a suffix after it, forming a single string.
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    separator - the separator (may be empty but never null)
    
    prefix - the prefix to put before the whole result
    
    suffix - the suffix to put after the whole result
    
    first - the first expression
    
    second - the second expression
    
    Returns:
    
    the joined expression
  - joining
```
@SafeVarargs
public static <T> ToString<T> joining(ToString<T>... expressions)
```
    Returns an expression that represents the result of all the specified expressions joined together, forming a single string.
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    expressions - the array of expressions to join
    
    Returns:
    
    the joined expression
  - joining
```
@SafeVarargs
public static <T> ToString<T> joining(CharSequence separator,
                                      ToString<T>... expressions)
```
    Returns an expression that represents the result of all the specified expressions joined together with separators between them, forming a single string.
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    separator - the separator (may be empty but never null)
    
    expressions - the array of expressions to join
    
    Returns:
    
    the joined expression
  - joining
```
@SafeVarargs
public static <T> ToString<T> joining(CharSequence separator,
                                      CharSequence prefix,
                                      CharSequence suffix,
                                      ToString<T>... expressions)
```
    Returns an expression that represents the result of all the specified expressions joined together with separators between them, with a prefix before the entire result and a suffix after it, forming a single string.
    
    Type Parameters:
    
    T - the input entity type
    
    Parameters:
    
    separator - the separator (may be empty but never null)
    
    prefix - the prefix to put before the whole result
    
    suffix - the suffix to put after the whole result
    
    expressions - the array of expressions to join
    
    Returns:
    
    the joined expression

Class Expressions

Method Summary

Methods inherited from class java.lang.Object

Method Detail

byteToDouble

shortToDouble

intToDouble

longToDouble

floatToDouble

byteToDoubleNullable

shortToDoubleNullable

intToDoubleNullable

longToDoubleNullable

floatToDoubleNullable

abs

abs

abs

abs

abs

abs

absOrNull

absOrNull

absOrNull

absOrNull

absOrNull

absOrNull

sign

sign

sign

sign

sign

sign

sign

signOrNull

signOrNull

signOrNull

signOrNull

signOrNull

signOrNull

sqrt

sqrt

sqrt

sqrt

sqrt

sqrt

sqrtOrNull

sqrtOrNull

sqrtOrNull

sqrtOrNull

sqrtOrNull

sqrtOrNull

pow

pow

pow

pow

powOrNull

powOrNull

powOrNull

powOrNull

pow

pow

pow

pow

powOrNull

powOrNull

powOrNull

powOrNull

pow

pow

pow

pow

powOrNull

powOrNull

powOrNull

powOrNull

pow

pow

pow

pow

powOrNull