org.eclipse.xtext.xbase.lib.FloatExtensions Maven / Gradle / Ivy
/*******************************************************************************
* Copyright (c) 2012 itemis AG (http://www.itemis.eu) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*******************************************************************************/
package org.eclipse.xtext.xbase.lib;
import com.google.common.annotations.GwtCompatible;
/**
* This is an extension library for {@link Float} numbers.
*
* @author Jan Koehnlein - Code generator
* @since 2.3
*/
@GwtCompatible public class FloatExtensions {
// BEGIN generated code
/**
* The unary minus operator. This is the equivalent to the Java's - function.
*
* @param a a float.
* @return -a
* @since 2.3
*/
@Pure
@Inline("(-$1)")
public static float operator_minus(float a) {
return -a;
}
/**
* The binary plus operator. This is the equivalent to the Java + operator.
*
* @param a a float.
* @param b a double.
* @return a+b
* @since 2.3
*/
@Pure
@Inline("($1 + $2)")
public static double operator_plus(float a, double b) {
return a + b;
}
/**
* The binary minus operator. This is the equivalent to the Java - operator.
*
* @param a a float.
* @param b a double.
* @return a-b
* @since 2.3
*/
@Pure
@Inline("($1 - $2)")
public static double operator_minus(float a, double b) {
return a - b;
}
/**
* The binary multiply operator. This is the equivalent to the Java * operator.
*
* @param a a float.
* @param b a double.
* @return a*b
* @since 2.3
*/
@Pure
@Inline("($1 * $2)")
public static double operator_multiply(float a, double b) {
return a * b;
}
/**
* The binary divide operator. This is the equivalent to the Java / operator.
*
* @param a a float.
* @param b a double.
* @return a/b
* @since 2.3
*/
@Pure
@Inline("($1 / $2)")
public static double operator_divide(float a, double b) {
return a / b;
}
/**
* The binary modulo operator. This is the equivalent to the Java % operator.
*
* @param a a float.
* @param b a double.
* @return a%b
* @since 2.3
*/
@Pure
@Inline("($1 % $2)")
public static double operator_modulo(float a, double b) {
return a % b;
}
/**
* The binary lessThan operator. This is the equivalent to the Java < operator.
*
* @param a a float.
* @param b a double.
* @return a<b
* @since 2.3
*/
@Pure
@Inline("($1 < $2)")
public static boolean operator_lessThan(float a, double b) {
return a < b;
}
/**
* The binary lessEqualsThan operator. This is the equivalent to the Java <= operator.
*
* @param a a float.
* @param b a double.
* @return a<=b
* @since 2.3
*/
@Pure
@Inline("($1 <= $2)")
public static boolean operator_lessEqualsThan(float a, double b) {
return a <= b;
}
/**
* The binary greaterThan operator. This is the equivalent to the Java > operator.
*
* @param a a float.
* @param b a double.
* @return a>b
* @since 2.3
*/
@Pure
@Inline("($1 > $2)")
public static boolean operator_greaterThan(float a, double b) {
return a > b;
}
/**
* The binary greaterEqualsThan operator. This is the equivalent to the Java >= operator.
*
* @param a a float.
* @param b a double.
* @return a>=b
* @since 2.3
*/
@Pure
@Inline("($1 >= $2)")
public static boolean operator_greaterEqualsThan(float a, double b) {
return a >= b;
}
/**
* The binary equals operator. This is the equivalent to the Java == operator.
*
* @param a a float.
* @param b a double.
* @return a==b
* @since 2.3
*/
@Pure
@Inline("($1 == $2)")
public static boolean operator_equals(float a, double b) {
return a == b;
}
/**
* The binary notEquals operator. This is the equivalent to the Java != operator.
*
* @param a a float.
* @param b a double.
* @return a!=b
* @since 2.3
*/
@Pure
@Inline("($1 != $2)")
public static boolean operator_notEquals(float a, double b) {
return a != b;
}
/**
* The binary power operator. This is the equivalent to the Java's Math.pow() function.
*
* @param a a float.
* @param b a double.
* @return Math.pow(a, b)
* @since 2.3
*/
@Pure
@Inline(value="$3.pow($1, $2)", imported=Math.class)
public static double operator_power(float a, double b) {
return Math.pow(a, b);
}
/**
* The binary plus operator. This is the equivalent to the Java + operator.
*
* @param a a float.
* @param b a float.
* @return a+b
* @since 2.3
*/
@Pure
@Inline("($1 + $2)")
public static float operator_plus(float a, float b) {
return a + b;
}
/**
* The binary minus operator. This is the equivalent to the Java - operator.
*
* @param a a float.
* @param b a float.
* @return a-b
* @since 2.3
*/
@Pure
@Inline("($1 - $2)")
public static float operator_minus(float a, float b) {
return a - b;
}
/**
* The binary multiply operator. This is the equivalent to the Java * operator.
*
* @param a a float.
* @param b a float.
* @return a*b
* @since 2.3
*/
@Pure
@Inline("($1 * $2)")
public static float operator_multiply(float a, float b) {
return a * b;
}
/**
* The binary divide operator. This is the equivalent to the Java / operator.
*
* @param a a float.
* @param b a float.
* @return a/b
* @since 2.3
*/
@Pure
@Inline("($1 / $2)")
public static float operator_divide(float a, float b) {
return a / b;
}
/**
* The binary modulo operator. This is the equivalent to the Java % operator.
*
* @param a a float.
* @param b a float.
* @return a%b
* @since 2.3
*/
@Pure
@Inline("($1 % $2)")
public static float operator_modulo(float a, float b) {
return a % b;
}
/**
* The binary lessThan operator. This is the equivalent to the Java < operator.
*
* @param a a float.
* @param b a float.
* @return a<b
* @since 2.3
*/
@Pure
@Inline("($1 < $2)")
public static boolean operator_lessThan(float a, float b) {
return a < b;
}
/**
* The binary lessEqualsThan operator. This is the equivalent to the Java <= operator.
*
* @param a a float.
* @param b a float.
* @return a<=b
* @since 2.3
*/
@Pure
@Inline("($1 <= $2)")
public static boolean operator_lessEqualsThan(float a, float b) {
return a <= b;
}
/**
* The binary greaterThan operator. This is the equivalent to the Java > operator.
*
* @param a a float.
* @param b a float.
* @return a>b
* @since 2.3
*/
@Pure
@Inline("($1 > $2)")
public static boolean operator_greaterThan(float a, float b) {
return a > b;
}
/**
* The binary greaterEqualsThan operator. This is the equivalent to the Java >= operator.
*
* @param a a float.
* @param b a float.
* @return a>=b
* @since 2.3
*/
@Pure
@Inline("($1 >= $2)")
public static boolean operator_greaterEqualsThan(float a, float b) {
return a >= b;
}
/**
* The binary equals operator. This is the equivalent to the Java == operator.
*
* @param a a float.
* @param b a float.
* @return a==b
* @since 2.3
*/
@Pure
@Inline("($1 == $2)")
public static boolean operator_equals(float a, float b) {
return a == b;
}
/**
* The binary notEquals operator. This is the equivalent to the Java != operator.
*
* @param a a float.
* @param b a float.
* @return a!=b
* @since 2.3
*/
@Pure
@Inline("($1 != $2)")
public static boolean operator_notEquals(float a, float b) {
return a != b;
}
/**
* The binary power operator. This is the equivalent to the Java's Math.pow() function.
*
* @param a a float.
* @param b a float.
* @return Math.pow(a, b)
* @since 2.3
*/
@Pure
@Inline(value="$3.pow($1, $2)", imported=Math.class)
public static double operator_power(float a, float b) {
return Math.pow(a, b);
}
/**
* The binary plus operator. This is the equivalent to the Java + operator.
*
* @param a a float.
* @param b a long.
* @return a+b
* @since 2.3
*/
@Pure
@Inline("($1 + $2)")
public static float operator_plus(float a, long b) {
return a + b;
}
/**
* The binary minus operator. This is the equivalent to the Java - operator.
*
* @param a a float.
* @param b a long.
* @return a-b
* @since 2.3
*/
@Pure
@Inline("($1 - $2)")
public static float operator_minus(float a, long b) {
return a - b;
}
/**
* The binary multiply operator. This is the equivalent to the Java * operator.
*
* @param a a float.
* @param b a long.
* @return a*b
* @since 2.3
*/
@Pure
@Inline("($1 * $2)")
public static float operator_multiply(float a, long b) {
return a * b;
}
/**
* The binary divide operator. This is the equivalent to the Java / operator.
*
* @param a a float.
* @param b a long.
* @return a/b
* @since 2.3
*/
@Pure
@Inline("($1 / $2)")
public static float operator_divide(float a, long b) {
return a / b;
}
/**
* The binary modulo operator. This is the equivalent to the Java % operator.
*
* @param a a float.
* @param b a long.
* @return a%b
* @since 2.3
*/
@Pure
@Inline("($1 % $2)")
public static float operator_modulo(float a, long b) {
return a % b;
}
/**
* The binary lessThan operator. This is the equivalent to the Java < operator.
*
* @param a a float.
* @param b a long.
* @return a<b
* @since 2.3
*/
@Pure
@Inline("($1 < $2)")
public static boolean operator_lessThan(float a, long b) {
return a < b;
}
/**
* The binary lessEqualsThan operator. This is the equivalent to the Java <= operator.
*
* @param a a float.
* @param b a long.
* @return a<=b
* @since 2.3
*/
@Pure
@Inline("($1 <= $2)")
public static boolean operator_lessEqualsThan(float a, long b) {
return a <= b;
}
/**
* The binary greaterThan operator. This is the equivalent to the Java > operator.
*
* @param a a float.
* @param b a long.
* @return a>b
* @since 2.3
*/
@Pure
@Inline("($1 > $2)")
public static boolean operator_greaterThan(float a, long b) {
return a > b;
}
/**
* The binary greaterEqualsThan operator. This is the equivalent to the Java >= operator.
*
* @param a a float.
* @param b a long.
* @return a>=b
* @since 2.3
*/
@Pure
@Inline("($1 >= $2)")
public static boolean operator_greaterEqualsThan(float a, long b) {
return a >= b;
}
/**
* The binary equals operator. This is the equivalent to the Java == operator.
*
* @param a a float.
* @param b a long.
* @return a==b
* @since 2.3
*/
@Pure
@Inline("($1 == $2)")
public static boolean operator_equals(float a, long b) {
return a == b;
}
/**
* The binary notEquals operator. This is the equivalent to the Java != operator.
*
* @param a a float.
* @param b a long.
* @return a!=b
* @since 2.3
*/
@Pure
@Inline("($1 != $2)")
public static boolean operator_notEquals(float a, long b) {
return a != b;
}
/**
* The binary power operator. This is the equivalent to the Java's Math.pow() function.
*
* @param a a float.
* @param b a long.
* @return Math.pow(a, b)
* @since 2.3
*/
@Pure
@Inline(value="$3.pow($1, $2)", imported=Math.class)
public static double operator_power(float a, long b) {
return Math.pow(a, b);
}
/**
* The binary plus operator. This is the equivalent to the Java + operator.
*
* @param a a float.
* @param b an integer.
* @return a+b
* @since 2.3
*/
@Pure
@Inline("($1 + $2)")
public static float operator_plus(float a, int b) {
return a + b;
}
/**
* The binary minus operator. This is the equivalent to the Java - operator.
*
* @param a a float.
* @param b an integer.
* @return a-b
* @since 2.3
*/
@Pure
@Inline("($1 - $2)")
public static float operator_minus(float a, int b) {
return a - b;
}
/**
* The binary multiply operator. This is the equivalent to the Java * operator.
*
* @param a a float.
* @param b an integer.
* @return a*b
* @since 2.3
*/
@Pure
@Inline("($1 * $2)")
public static float operator_multiply(float a, int b) {
return a * b;
}
/**
* The binary divide operator. This is the equivalent to the Java / operator.
*
* @param a a float.
* @param b an integer.
* @return a/b
* @since 2.3
*/
@Pure
@Inline("($1 / $2)")
public static float operator_divide(float a, int b) {
return a / b;
}
/**
* The binary modulo operator. This is the equivalent to the Java % operator.
*
* @param a a float.
* @param b an integer.
* @return a%b
* @since 2.3
*/
@Pure
@Inline("($1 % $2)")
public static float operator_modulo(float a, int b) {
return a % b;
}
/**
* The binary lessThan operator. This is the equivalent to the Java < operator.
*
* @param a a float.
* @param b an integer.
* @return a<b
* @since 2.3
*/
@Pure
@Inline("($1 < $2)")
public static boolean operator_lessThan(float a, int b) {
return a < b;
}
/**
* The binary lessEqualsThan operator. This is the equivalent to the Java <= operator.
*
* @param a a float.
* @param b an integer.
* @return a<=b
* @since 2.3
*/
@Pure
@Inline("($1 <= $2)")
public static boolean operator_lessEqualsThan(float a, int b) {
return a <= b;
}
/**
* The binary greaterThan operator. This is the equivalent to the Java > operator.
*
* @param a a float.
* @param b an integer.
* @return a>b
* @since 2.3
*/
@Pure
@Inline("($1 > $2)")
public static boolean operator_greaterThan(float a, int b) {
return a > b;
}
/**
* The binary greaterEqualsThan operator. This is the equivalent to the Java >= operator.
*
* @param a a float.
* @param b an integer.
* @return a>=b
* @since 2.3
*/
@Pure
@Inline("($1 >= $2)")
public static boolean operator_greaterEqualsThan(float a, int b) {
return a >= b;
}
/**
* The binary equals operator. This is the equivalent to the Java == operator.
*
* @param a a float.
* @param b an integer.
* @return a==b
* @since 2.3
*/
@Pure
@Inline("($1 == $2)")
public static boolean operator_equals(float a, int b) {
return a == b;
}
/**
* The binary notEquals operator. This is the equivalent to the Java != operator.
*
* @param a a float.
* @param b an integer.
* @return a!=b
* @since 2.3
*/
@Pure
@Inline("($1 != $2)")
public static boolean operator_notEquals(float a, int b) {
return a != b;
}
/**
* The binary power operator. This is the equivalent to the Java's Math.pow() function.
*
* @param a a float.
* @param b an integer.
* @return Math.pow(a, b)
* @since 2.3
*/
@Pure
@Inline(value="$3.pow($1, $2)", imported=Math.class)
public static double operator_power(float a, int b) {
return Math.pow(a, b);
}
/**
* The binary plus operator. This is the equivalent to the Java + operator.
*
* @param a a float.
* @param b a character.
* @return a+b
* @since 2.3
*/
@Pure
@Inline("($1 + $2)")
public static float operator_plus(float a, char b) {
return a + b;
}
/**
* The binary minus operator. This is the equivalent to the Java - operator.
*
* @param a a float.
* @param b a character.
* @return a-b
* @since 2.3
*/
@Pure
@Inline("($1 - $2)")
public static float operator_minus(float a, char b) {
return a - b;
}
/**
* The binary multiply operator. This is the equivalent to the Java * operator.
*
* @param a a float.
* @param b a character.
* @return a*b
* @since 2.3
*/
@Pure
@Inline("($1 * $2)")
public static float operator_multiply(float a, char b) {
return a * b;
}
/**
* The binary divide operator. This is the equivalent to the Java / operator.
*
* @param a a float.
* @param b a character.
* @return a/b
* @since 2.3
*/
@Pure
@Inline("($1 / $2)")
public static float operator_divide(float a, char b) {
return a / b;
}
/**
* The binary modulo operator. This is the equivalent to the Java % operator.
*
* @param a a float.
* @param b a character.
* @return a%b
* @since 2.3
*/
@Pure
@Inline("($1 % $2)")
public static float operator_modulo(float a, char b) {
return a % b;
}
/**
* The binary lessThan operator. This is the equivalent to the Java < operator.
*
* @param a a float.
* @param b a character.
* @return a<b
* @since 2.3
*/
@Pure
@Inline("($1 < $2)")
public static boolean operator_lessThan(float a, char b) {
return a < b;
}
/**
* The binary lessEqualsThan operator. This is the equivalent to the Java <= operator.
*
* @param a a float.
* @param b a character.
* @return a<=b
* @since 2.3
*/
@Pure
@Inline("($1 <= $2)")
public static boolean operator_lessEqualsThan(float a, char b) {
return a <= b;
}
/**
* The binary greaterThan operator. This is the equivalent to the Java > operator.
*
* @param a a float.
* @param b a character.
* @return a>b
* @since 2.3
*/
@Pure
@Inline("($1 > $2)")
public static boolean operator_greaterThan(float a, char b) {
return a > b;
}
/**
* The binary greaterEqualsThan operator. This is the equivalent to the Java >= operator.
*
* @param a a float.
* @param b a character.
* @return a>=b
* @since 2.3
*/
@Pure
@Inline("($1 >= $2)")
public static boolean operator_greaterEqualsThan(float a, char b) {
return a >= b;
}
/**
* The binary equals operator. This is the equivalent to the Java == operator.
*
* @param a a float.
* @param b a character.
* @return a==b
* @since 2.3
*/
@Pure
@Inline("($1 == $2)")
public static boolean operator_equals(float a, char b) {
return a == b;
}
/**
* The binary notEquals operator. This is the equivalent to the Java != operator.
*
* @param a a float.
* @param b a character.
* @return a!=b
* @since 2.3
*/
@Pure
@Inline("($1 != $2)")
public static boolean operator_notEquals(float a, char b) {
return a != b;
}
/**
* The binary power operator. This is the equivalent to the Java's Math.pow() function.
*
* @param a a float.
* @param b a character.
* @return Math.pow(a, b)
* @since 2.3
*/
@Pure
@Inline(value="$3.pow($1, $2)", imported=Math.class)
public static double operator_power(float a, char b) {
return Math.pow(a, b);
}
/**
* The binary plus operator. This is the equivalent to the Java + operator.
*
* @param a a float.
* @param b a short.
* @return a+b
* @since 2.3
*/
@Pure
@Inline("($1 + $2)")
public static float operator_plus(float a, short b) {
return a + b;
}
/**
* The binary minus operator. This is the equivalent to the Java - operator.
*
* @param a a float.
* @param b a short.
* @return a-b
* @since 2.3
*/
@Pure
@Inline("($1 - $2)")
public static float operator_minus(float a, short b) {
return a - b;
}
/**
* The binary multiply operator. This is the equivalent to the Java * operator.
*
* @param a a float.
* @param b a short.
* @return a*b
* @since 2.3
*/
@Pure
@Inline("($1 * $2)")
public static float operator_multiply(float a, short b) {
return a * b;
}
/**
* The binary divide operator. This is the equivalent to the Java / operator.
*
* @param a a float.
* @param b a short.
* @return a/b
* @since 2.3
*/
@Pure
@Inline("($1 / $2)")
public static float operator_divide(float a, short b) {
return a / b;
}
/**
* The binary modulo operator. This is the equivalent to the Java % operator.
*
* @param a a float.
* @param b a short.
* @return a%b
* @since 2.3
*/
@Pure
@Inline("($1 % $2)")
public static float operator_modulo(float a, short b) {
return a % b;
}
/**
* The binary lessThan operator. This is the equivalent to the Java < operator.
*
* @param a a float.
* @param b a short.
* @return a<b
* @since 2.3
*/
@Pure
@Inline("($1 < $2)")
public static boolean operator_lessThan(float a, short b) {
return a < b;
}
/**
* The binary lessEqualsThan operator. This is the equivalent to the Java <= operator.
*
* @param a a float.
* @param b a short.
* @return a<=b
* @since 2.3
*/
@Pure
@Inline("($1 <= $2)")
public static boolean operator_lessEqualsThan(float a, short b) {
return a <= b;
}
/**
* The binary greaterThan operator. This is the equivalent to the Java > operator.
*
* @param a a float.
* @param b a short.
* @return a>b
* @since 2.3
*/
@Pure
@Inline("($1 > $2)")
public static boolean operator_greaterThan(float a, short b) {
return a > b;
}
/**
* The binary greaterEqualsThan operator. This is the equivalent to the Java >= operator.
*
* @param a a float.
* @param b a short.
* @return a>=b
* @since 2.3
*/
@Pure
@Inline("($1 >= $2)")
public static boolean operator_greaterEqualsThan(float a, short b) {
return a >= b;
}
/**
* The binary equals operator. This is the equivalent to the Java == operator.
*
* @param a a float.
* @param b a short.
* @return a==b
* @since 2.3
*/
@Pure
@Inline("($1 == $2)")
public static boolean operator_equals(float a, short b) {
return a == b;
}
/**
* The binary notEquals operator. This is the equivalent to the Java != operator.
*
* @param a a float.
* @param b a short.
* @return a!=b
* @since 2.3
*/
@Pure
@Inline("($1 != $2)")
public static boolean operator_notEquals(float a, short b) {
return a != b;
}
/**
* The binary power operator. This is the equivalent to the Java's Math.pow() function.
*
* @param a a float.
* @param b a short.
* @return Math.pow(a, b)
* @since 2.3
*/
@Pure
@Inline(value="$3.pow($1, $2)", imported=Math.class)
public static double operator_power(float a, short b) {
return Math.pow(a, b);
}
/**
* The binary plus operator. This is the equivalent to the Java + operator.
*
* @param a a float.
* @param b a byte.
* @return a+b
* @since 2.3
*/
@Pure
@Inline("($1 + $2)")
public static float operator_plus(float a, byte b) {
return a + b;
}
/**
* The binary minus operator. This is the equivalent to the Java - operator.
*
* @param a a float.
* @param b a byte.
* @return a-b
* @since 2.3
*/
@Pure
@Inline("($1 - $2)")
public static float operator_minus(float a, byte b) {
return a - b;
}
/**
* The binary multiply operator. This is the equivalent to the Java * operator.
*
* @param a a float.
* @param b a byte.
* @return a*b
* @since 2.3
*/
@Pure
@Inline("($1 * $2)")
public static float operator_multiply(float a, byte b) {
return a * b;
}
/**
* The binary divide operator. This is the equivalent to the Java / operator.
*
* @param a a float.
* @param b a byte.
* @return a/b
* @since 2.3
*/
@Pure
@Inline("($1 / $2)")
public static float operator_divide(float a, byte b) {
return a / b;
}
/**
* The binary modulo operator. This is the equivalent to the Java % operator.
*
* @param a a float.
* @param b a byte.
* @return a%b
* @since 2.3
*/
@Pure
@Inline("($1 % $2)")
public static float operator_modulo(float a, byte b) {
return a % b;
}
/**
* The binary lessThan operator. This is the equivalent to the Java < operator.
*
* @param a a float.
* @param b a byte.
* @return a<b
* @since 2.3
*/
@Pure
@Inline("($1 < $2)")
public static boolean operator_lessThan(float a, byte b) {
return a < b;
}
/**
* The binary lessEqualsThan operator. This is the equivalent to the Java <= operator.
*
* @param a a float.
* @param b a byte.
* @return a<=b
* @since 2.3
*/
@Pure
@Inline("($1 <= $2)")
public static boolean operator_lessEqualsThan(float a, byte b) {
return a <= b;
}
/**
* The binary greaterThan operator. This is the equivalent to the Java > operator.
*
* @param a a float.
* @param b a byte.
* @return a>b
* @since 2.3
*/
@Pure
@Inline("($1 > $2)")
public static boolean operator_greaterThan(float a, byte b) {
return a > b;
}
/**
* The binary greaterEqualsThan operator. This is the equivalent to the Java >= operator.
*
* @param a a float.
* @param b a byte.
* @return a>=b
* @since 2.3
*/
@Pure
@Inline("($1 >= $2)")
public static boolean operator_greaterEqualsThan(float a, byte b) {
return a >= b;
}
/**
* The binary equals operator. This is the equivalent to the Java == operator.
*
* @param a a float.
* @param b a byte.
* @return a==b
* @since 2.3
*/
@Pure
@Inline("($1 == $2)")
public static boolean operator_equals(float a, byte b) {
return a == b;
}
/**
* The binary notEquals operator. This is the equivalent to the Java != operator.
*
* @param a a float.
* @param b a byte.
* @return a!=b
* @since 2.3
*/
@Pure
@Inline("($1 != $2)")
public static boolean operator_notEquals(float a, byte b) {
return a != b;
}
/**
* The binary power operator. This is the equivalent to the Java's Math.pow() function.
*
* @param a a float.
* @param b a byte.
* @return Math.pow(a, b)
* @since 2.3
*/
@Pure
@Inline(value="$3.pow($1, $2)", imported=Math.class)
public static double operator_power(float a, byte b) {
return Math.pow(a, b);
}
// END generated code
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy