Create a {@code asin(num)} expression

<p>Returns the principal value of the arc sine of num, expressed in radians.</p>

@param num numeric expression
@return asin(num)
436846
public static <A extends Number & Comparable<?>> NumberExpression<Double> asin(Expression<A> num) {
        return Expressions.numberOperation(Double.class, Ops.MathOps.ASIN, num);
    }
302141
public static DoubleBinding sin(final ObservableDoubleValue a) {
        return createDoubleBinding(() -> Math.sin(a.get()), a);
    }
602926
public static <A extends Number & Comparable<?>> NumberExpression<Double> atan(Expression<A> num) {
        return Expressions.numberOperation(Double.class, Ops.MathOps.ATAN, num);
    }
712284
public JcNumber asNumber() {
		JcNumber ret = new JcNumber(null, this, null);
		QueryRecorder.recordInvocationConditional(this, "asNumber", ret);
		return ret;
	}
1181228
public static String format(final double num) {
		final NumberFormat dFormatter = new DecimalFormat("#0.00");
		final String sFformatter = dFormatter.format(num);
		return format(sFformatter + "");
	}
473162
@Override
	protected Variable[] createVariablesSub(int num) {
		int[] tp = tpCreate(num);
		Variable[] ret = new Variable[num];
		for (int i = 0; i < tp.length; i++) {
			ret[i] = tPoints[tp[i]];			
		}
		return ret;
	}
70184
public static DoubleBinding asin(final ObservableDoubleValue a) {
        return createDoubleBinding(() -> Math.asin(a.get()), a);
    }
968335
public static <A extends Number & Comparable<?>> NumberExpression<Double> ln(Expression<A> num) {
        return Expressions.numberOperation(Double.class, Ops.MathOps.LN, num);
    }
48155
public static <T extends Number & Comparable<?>> NumberExpression<T> asNumber(Expression<T> expr) {
        Expression<T> underlyingMixin = ExpressionUtils.extract(expr);
        if (underlyingMixin instanceof PathImpl) {
            return new NumberPath<T>((PathImpl<T>) underlyingMixin);
        } else if (underlyingMixin instanceof OperationImpl) {
            return new NumberOperation<T>((OperationImpl<T>) underlyingMixin);
        } else if (underlyingMixin instanceof TemplateExpressionImpl) {
            return new NumberTemplate<T>((TemplateExpressionImpl<T>) underlyingMixin);
        } else {
            return new NumberExpression<T>(underlyingMixin) {

                private static final long serialVersionUID = -8712299418891960222L;

                @Override
                public <R, C> R accept(Visitor<R, C> v, C context) {
                    return this.mixin.accept(v, context);
                }

            };
        }
    }
229925
public static <A extends Number & Comparable<?>> NumberExpression<Double> degrees(Expression<A> num) {
        return Expressions.numberOperation(Double.class, Ops.MathOps.DEG, num);
    }
1309484
public double num()
    throws javax.xml.transform.TransformerException
  {

	throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NUM_NOT_SUPPORTED_XRTREEFRAGSELECTWRAPPER, null)); //"num() not supported by XRTreeFragSelectWrapper!");
  }
96521
public final <A extends Number & Comparable<?>> BooleanExpression goe(A right) {
        return goe(ConstantImpl.create(cast(right)));
    }
947340
public NumberExpression<Double> x() {
        if (x == null) {
            x = Expressions.numberOperation(Double.class, SpatialOps.X, mixin);
        }
        return x;
    }
538939
public final Number evaluateNumeric( Message message ) throws JMSException
    {
        Object value = evaluate(message);
        if (value == null)
            return null;
 
        if (value instanceof Number)
            return ArithmeticUtils.normalize((Number)value);
        
        throw new FFMQException("Expected a numeric but got : "+value.toString(),"INVALID_SELECTOR_EXPRESSION");
    }
908277
public static ComplexNumber Sin(ComplexNumber z1) {
        ComplexNumber result = new ComplexNumber();

        if (z1.imaginary == 0.0) {
            result.real = Math.sin(z1.real);
            result.imaginary = 0.0;
        } else {
            result.real = Math.sin(z1.real) * Math.cosh(z1.imaginary);
            result.imaginary = Math.cos(z1.real) * Math.sinh(z1.imaginary);
        }

        return result;
    }
531070
public static float roundToOneSignificantFigure(double num) {
        final float d = (float) Math.ceil((float) Math.log10(num < 0 ? -num : num));
        final int power = 1 - (int) d;
        final float magnitude = (float) Math.pow(10, power);
        final long shifted = Math.round(num * magnitude);
        return shifted / magnitude;
    }
579859
public JTSGeometryExpression<Geometry> geometryN(Integer n) {
        return JTSGeometryExpressions.geometryOperation(SpatialOps.GEOMETRYN, mixin, ConstantImpl.create(n));
    }