Create a {@code sin(num)} expression

<p>Returns the sine of an angle of num radians.</p>

@param num numeric expression
@return sin(num)
358696
public static <A extends Number & Comparable<?>> NumberExpression<Double> sin(Expression<A> num) {
        return Expressions.numberOperation(Double.class, Ops.MathOps.SIN, num);
    }
895699
public SDVariable arg(int num){
        SDVariable[] args = args();
        Preconditions.checkNotNull(args, "Arguments are null for function %s", this.getOwnName());
        Preconditions.checkArgument(num >= 0 && num < args.length, "Invalid index: must be 0 to numArgs (0 <= idx < %s)", args.length);
        return args[num];
    }
1123188
public Quaterniond rotationX(double angle) {
        double sin = Math.sin(angle * 0.5);
        double cos = Math.cosFromSin(sin, angle * 0.5);
        w = cos;
        x = sin;
        y = 0.0;
        z = 0.0;
        return this;
    }
24325
static public Angle sum(Angle angle1, Angle angle2) {
        return new Angle(angle1.value + angle2.value);
    }
602926
public static <A extends Number & Comparable<?>> NumberExpression<Double> atan(Expression<A> num) {
        return Expressions.numberOperation(Double.class, Ops.MathOps.ATAN, num);
    }
340116
public NumberExpression<Double> y() {
        if (y == null) {
            y = Expressions.numberOperation(Double.class, SpatialOps.Y, mixin);
        }
        return y;
    }
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);
                }

            };
        }
    }
933361
public static BigDecimal fen2yuan(String num) {
		if (StringUtils.isEmpty(num)) {
			return new BigDecimal(0);
		}
		return fen2yuan(new BigDecimal(num));
	}
1010342
public static ComplexNumber Pow(ComplexNumber z1, double n) {

        double norm = Math.pow(z1.getMagnitude(), n);
        double angle = 360 - Math.abs(Math.toDegrees(Math.atan(z1.imaginary / z1.real)));

        double common = n * angle;

        double r = norm * Math.cos(Math.toRadians(common));
        double i = norm * Math.sin(Math.toRadians(common));

        return new ComplexNumber(r, i);

    }
892863
public NumberExpression<Double> m() {
        if (m == null) {
            m = Expressions.numberOperation(Double.class, SpatialOps.M, mixin);
        }
        return m;
    }
911623
public static BigDecimal getBigDecimal(double num) {
        if (Double.isNaN(num)) {
            throw new ArithmeticException("Invalid input Double.NaN.");
        } else if(Double.isInfinite(num)) {
            throw new ArithmeticException("Invalid input Double.xxx_INFINITY.");
        }
        return new BigDecimal(String.valueOf(num));
    }
1181228
public static String format(final double num) {
		final NumberFormat dFormatter = new DecimalFormat("#0.00");
		final String sFformatter = dFormatter.format(num);
		return format(sFformatter + "");
	}
152020
static public double sine(Angle angle) {
        double result = lock(Math.sin(angle.value));
        return result;
    }
406183
function tan(angle) {
  utils.assertType(angle, 'unit', 'angle');

  var radians = angle.val;

  if (angle.type === 'deg') {
    radians *= Math.PI / 180;
  }

  var m = Math.pow(10, 9);

  var sin = Math.round(Math.sin(radians) * m) / m
    , cos = Math.round(Math.cos(radians) * m) / m
    , tan = Math.round(m * sin / cos ) / m;

  return new nodes.Unit(tan, '');
}
1172141
@Pure
	@Inline(value = "new Vector2dfx(Math.cos($1), Math.sin($1))", imported = {Vector2dfx.class})
	public static Vector2dfx toOrientationVector(double angle) {
		return new Vector2dfx(Math.cos(angle), Math.sin(angle));
	}
629458
public NumberExpression<T> round() {
        if (round == null) {
            round = Expressions.numberOperation(getType(), MathOps.ROUND, mixin);
        }
        return round;
    }
174076
public PolygonExpression<?> patchN(int n) {
        return GeometryExpressions.polygonOperation(SpatialOps.SURFACE, mixin, ConstantImpl.create(n));
    }