Binding for {@link java.lang.Math#tanh(double)}

@param   x The number whose hyperbolic tangent is to be returned.
@return  The hyperbolic tangent of {@code x}.
547159
public static DoubleBinding tanh(final ObservableDoubleValue x) {
        return createDoubleBinding(() -> Math.tanh(x.get()), x);
    }
1000875
public List<Double> x() {
        List<Double> result = new ArrayList<Double>(xy.size());
        for (Discrete.Pair pair : xy) {
            result.add(pair.x);
        }
        return result;
    }
41281
public static <A extends Number & Comparable<?>> NumberExpression<Double> sinh(Expression<A> num) {
        return Expressions.numberOperation(Double.class, Ops.MathOps.SINH, num);
    }
385660
public Date toDate(double x) {
        if (Double.isNaN(x)) {
            return null;
        }

        return new Date(Double.doubleToRawLongBits(x));
    }
947340
public NumberExpression<Double> x() {
        if (x == null) {
            x = Expressions.numberOperation(Double.class, SpatialOps.X, mixin);
        }
        return x;
    }
1123501
public static long sqrt(long x) {
		long y = 0;
		long b = (~Long.MAX_VALUE) >>> 1;
		while (b > 0) {
			if (x >= y + b) {
				x -= y + b;
				y >>= 1;
				y += b;
			} else {
				y >>= 1;
			}
			b >>= 2;
		}
		return y;
	}
963233
public double getValue(double x)
	{
		synchronized(interpolatingRationalFunctionsLazyInitLock) {
			if(interpolatingRationalFunctions == null) {
				doCreateRationalFunctions();
			}
		}

		// Get interpolating rational function for the given point x
		int pointIndex = java.util.Arrays.binarySearch(points, x);
		if(pointIndex >= 0) {
			return values[pointIndex];
		}

		int intervallIndex = -pointIndex-2;

		// Check for extrapolation
		if(intervallIndex < 0) {
			// Extrapolation
			if(this.extrapolationMethod == ExtrapolationMethod.CONSTANT) {
				return values[0];
			} else if(this.extrapolationMethod == ExtrapolationMethod.LINEAR) {
				return values[0]+(values[1]-values[0])/(points[1]-points[0])*(x-points[0]);
			} else {
				intervallIndex = 0;
			}
		}
		else if(intervallIndex > points.length-2) {
			// Extrapolation
			if(this.extrapolationMethod == ExtrapolationMethod.CONSTANT) {
				return values[points.length-1];
			} else if(this.extrapolationMethod == ExtrapolationMethod.LINEAR) {
				return values[points.length-1]+(values[points.length-2]-values[points.length-1])/(points[points.length-2]-points[points.length-1])*(x-points[points.length-1]);
			} else {
				intervallIndex = points.length-2;
			}
		}

		RationalFunction rationalFunction = interpolatingRationalFunctions[intervallIndex];

		// Calculate interpolating value
		return rationalFunction.getValue(x-points[intervallIndex]);
	}
533437
public static double toDouble(String x) throws NumberFormatException {
        if ("nan".equals(x)) {
            return Double.NaN;
        }
        if ("inf".equals(x)) {
            return Double.POSITIVE_INFINITY;
        }
        if ("-inf".equals(x)) {
            return Double.NEGATIVE_INFINITY;
        }

        return Double.parseDouble(x);
    }
1262670
@Pure
	public double toCenterX(double x) {
		final double adjustedX = this.invertX.get() ? -x : x;
		return adjustedX + this.translationX.get();
	}
808941
public static double phi(double x) {
        return Math.exp(-x*x / 2) / Math.sqrt(2 * Math.PI);
    }
836282
@Pure
	public double fx2docX(double x) {
		return this.centeringTransform.toGlobalX((x - this.canvasWidth.get() / 2.) / this.scale.get());
	}
440049
static public double myRound(double x) {
    return (Math.signum(x) * Math.round(Math.abs(x)));
  }
247832
public float getTangentX(int vertex) {
        if (!hasTangentsAndBitangents()) {
            throw new IllegalStateException("mesh has no tangents");
        }
        
        checkVertexIndexBounds(vertex);
        
        return m_tangents.getFloat(vertex * 3 * SIZEOF_FLOAT);
    }
272044
@Override 
    public double fromReal(double x) {
        long sign = POSITIVE;
        if (x < 0) {
            sign = NEGATIVE;
            x = -x;  
        }
        return compact(sign, FastMath.log(x));
    }
31367
public double toScreenX(double x)
    {
        Point2D src = srcPnt.get();
        Point2D dst = dstPnt.get();
        src.setLocation(x, 0);
        combinedTransform.transform(src, dst);
        return dst.getX();
        //return scaleX * x + xOff;
    }
1010103
public static double factorial(int x) {
    double result = 1.0;
    for (int i=x; i>1; i--) {
      result *= i;
    }
    return result;
  }
1109990
public static <A extends Number & Comparable<?>> NumberExpression<Double> tan(Expression<A> num) {
        return Expressions.numberOperation(Double.class, Ops.MathOps.TAN, num);
    }