/** * <u>Berechnen des Kotangens der komplexen Zahl</u><br> * * @param comp Komplexe Zahl * @return Rückgabe eines Objektes vom Typ Complex mit Lösung aus cot(<u>z</u>) */ public static Complex cot(Complex comp) { double nn = Math.pow(Math.sin(comp.real) * Math.cosh(comp.imag), 2) + Math.pow(Math.cos(comp.real) * Math.sinh(comp.imag), 2); return new Complex( (Math.cos(comp.real) * Math.sin(comp.real)) / nn, (Math.cosh(comp.imag) * Math.sinh(comp.imag)) / nn); }

/** * <u>Berechnen des Kotangens der komplexen Zahl</u><br> * * @return Rückgabe eines Objektes vom Typ Complex mit Lösung aus cot(<u>z</u>) */ public Complex cot() { double nn = Math.pow(Math.sin(this.real) * Math.cosh(this.imag), 2) + Math.pow(Math.cos(this.real) * Math.sinh(this.imag), 2); return new Complex( (Math.cos(this.real) * Math.sin(this.real)) / nn, (Math.cosh(this.imag) * Math.sinh(this.imag)) / nn); }

@Override public Intent execute(Context context) { String[] titles = new String[] {"sin + cos"}; List<double[]> x = new ArrayList<double[]>(); List<double[]> values = new ArrayList<double[]>(); int step = 4; int count = 360 / step + 1; x.add(new double[count]); double[] sinValues = new double[count]; values.add(sinValues); for (int i = 0; i < count; i++) { int angle = i * step; x.get(0)[i] = angle; double rAngle = Math.toRadians(angle); sinValues[i] = Math.sinh(rAngle); } int[] colors = new int[] {Color.RED}; PointStyle[] styles = new PointStyle[] {PointStyle.POINT}; XYMultipleSeriesRenderer renderer = buildRenderer(colors, styles); setChartSettings( renderer, "Trigonometric functions", "X (in degrees)", "Y", 0, 360, -2, 2, Color.GRAY, Color.LTGRAY); renderer.setXLabels(20); renderer.setYLabels(10); return ChartFactory.getLineChartIntent(context, buildDataset(titles, x, values), renderer); }

/** {@inheritDoc} */ public OpenMapRealVector mapSinhToSelf() { Iterator iter = entries.iterator(); while (iter.hasNext()) { iter.advance(); entries.put(iter.key(), Math.sinh(iter.value())); } return this; }

/** * @param args the function arguments which must be either one object of type Double or Long * @return the result of the function evaluation which is the natural logarithm of the first * argument */ public Object evaluateFunction(final Object[] args) { final double angleInRadians; try { angleInRadians = FunctionUtil.getArgAsDouble(args[0]); } catch (final Exception e) { throw new IllegalArgumentException( "can't convert \"" + args[0] + "\" to an angle in radians in a call to TANH()."); } return Math.sinh(angleInRadians) / Math.cosh(angleInRadians); }

/** * draws the inside of the hyperobola part * * @param center center * @param v1 1st eigenvector * @param v2 2nd eigenvector * @param a 1st eigenvalue * @param b 2nd eigenvalue * @param tMin t min * @param tMax t max */ public void hyperbolaPart( Coords center, Coords v1, Coords v2, double a, double b, double tMin, double tMax) { manager.startGeometry(Manager.Type.TRIANGLE_FAN); manager.texture(0, 0); manager.normal(v1.crossProduct(v2)); int longitude = manager.getLongitudeDefault(); Coords m; float dt = (float) (tMax - tMin) / longitude; float u, v; // first point on the branch u = (float) Math.cosh(tMin); v = (float) Math.sinh(tMin); m = v1.mul(a * u).add(v2.mul(b * v)); // center of the fan is midpoint of branch ends u = (float) Math.cosh(tMax); v = (float) Math.sinh(tMax); manager.triangleFanApex(center.add((m.add(v1.mul(a * u).add(v2.mul(b * v)))).mul(0.5))); // first point manager.triangleFanVertex(center.add(m)); for (int i = 1; i <= longitude; i++) { u = (float) Math.cosh(tMin + i * dt); v = (float) Math.sinh(tMin + i * dt); m = v1.mul(a * u).add(v2.mul(b * v)); manager.triangleFanVertex(center.add(m)); } manager.endGeometry(); }

public LuaValue call(LuaValue arg) { switch (opcode) { case 0: return valueOf(Math.acos(arg.checkdouble())); case 1: return valueOf(Math.asin(arg.checkdouble())); case 2: return valueOf(Math.atan(arg.checkdouble())); case 3: return valueOf(Math.cosh(arg.checkdouble())); case 4: return valueOf(Math.exp(arg.checkdouble())); case 5: return valueOf(Math.log(arg.checkdouble())); case 6: return valueOf(Math.log10(arg.checkdouble())); case 7: return valueOf(Math.sinh(arg.checkdouble())); case 8: return valueOf(Math.tanh(arg.checkdouble())); } return NIL; }

protected double call(double d) { return Math.sinh(d); }

@Override protected boolean updateForItSelf() { Renderer renderer = getView3D().getRenderer(); GeoQuadric3D quadric = (GeoQuadric3D) getGeoElement(); PlotterSurface surface; int type = quadric.getType(); double min, max; switch (type) { case GeoQuadricNDConstants.QUADRIC_SPHERE: Coords center = quadric.getMidpoint3D(); double radius = quadric.getHalfAxis(0); boundsMin.setValues(center, 3); boundsMax.setValues(center, 3); boundsMin.addInside(-radius); boundsMax.addInside(radius); checkSphereVisible(center, radius); if (visible != Visible.TOTALLY_OUTSIDE) { surface = renderer.getGeometryManager().getSurface(); surface.start(getReusableSurfaceIndex()); scale = getView3D().getScale(); longitude = surface.calcSphereLongitudesNeeded(radius, scale); drawSphere(surface, center, radius); setSurfaceIndex(surface.end()); } else { setSurfaceIndex(-1); } break; case GeoQuadricNDConstants.QUADRIC_ELLIPSOID: center = quadric.getMidpoint3D(); double r0 = quadric.getHalfAxis(0); double r1 = quadric.getHalfAxis(1); double r2 = quadric.getHalfAxis(2); surface = renderer.getGeometryManager().getSurface(); surface.start(getReusableSurfaceIndex()); scale = getView3D().getScale(); radius = Math.max(r0, Math.max(r1, r2)); longitude = surface.calcSphereLongitudesNeeded(radius, scale); Coords ev0 = quadric.getEigenvec3D(0); Coords ev1 = quadric.getEigenvec3D(1); Coords ev2 = quadric.getEigenvec3D(2); surface.drawEllipsoid(center, ev0, ev1, ev2, r0, r1, r2, longitude); setSurfaceIndex(surface.end()); break; case GeoQuadricNDConstants.QUADRIC_HYPERBOLOID_ONE_SHEET: center = quadric.getMidpoint3D(); r0 = quadric.getHalfAxis(0); r1 = quadric.getHalfAxis(1); r2 = quadric.getHalfAxis(2); surface = renderer.getGeometryManager().getSurface(); surface.start(getReusableSurfaceIndex()); ev0 = quadric.getEigenvec3D(0); ev1 = quadric.getEigenvec3D(1); ev2 = quadric.getEigenvec3D(2); if (vMinMax == null) { vMinMax = new double[2]; } vMinMax[0] = Double.POSITIVE_INFINITY; vMinMax[1] = Double.NEGATIVE_INFINITY; getView3D().getMinIntervalOutsideClipping(vMinMax, center, ev2.mul(r2)); scale = getView3D().getScale(); // get radius at max radius = Math.max(r0, r1) * Math.max(Math.abs(vMinMax[0]), Math.max(Math.abs(vMinMax[1]), 1)) / r2; longitude = surface.calcSphereLongitudesNeeded(radius, scale); min = DrawConic3D.asinh(vMinMax[0]); max = DrawConic3D.asinh(vMinMax[1]); surface.drawHyperboloidOneSheet( center, ev0, ev1, ev2, r0, r1, r2, longitude, min, max, !getView3D().useClippingCube()); setSurfaceIndex(surface.end()); break; case GeoQuadricNDConstants.QUADRIC_HYPERBOLOID_TWO_SHEETS: center = quadric.getMidpoint3D(); r0 = quadric.getHalfAxis(0); r1 = quadric.getHalfAxis(1); r2 = quadric.getHalfAxis(2); surface = renderer.getGeometryManager().getSurface(); surface.start(getReusableSurfaceIndex()); ev0 = quadric.getEigenvec3D(0); ev1 = quadric.getEigenvec3D(1); ev2 = quadric.getEigenvec3D(2); if (vMinMax == null) { vMinMax = new double[2]; } vMinMax[0] = Double.POSITIVE_INFINITY; vMinMax[1] = Double.NEGATIVE_INFINITY; getView3D().getMinIntervalOutsideClipping(vMinMax, center, ev2.mul(r2)); scale = getView3D().getScale(); // get radius at max radius = Math.max(r0, r1) * Math.max(Math.abs(vMinMax[0]), Math.abs(vMinMax[1])) / r2; longitude = surface.calcSphereLongitudesNeeded(radius, scale); if (vMinMax[0] < -1) { // bottom exists min = -DrawConic3D.acosh(-vMinMax[0]); } else if (vMinMax[0] <= 1) { // top ends at pole min = 0; } else { // top pole is cut min = DrawConic3D.acosh(vMinMax[0]); } if (vMinMax[1] > 1) { // top exists max = DrawConic3D.acosh(vMinMax[1]); } else if (vMinMax[1] >= -1) { // bottom ends at pole max = 0; } else { // bottom pole is cut max = -DrawConic3D.acosh(-vMinMax[1]); } surface.drawHyperboloidTwoSheets( center, ev0, ev1, ev2, r0, r1, r2, longitude, min, max, !getView3D().useClippingCube()); setSurfaceIndex(surface.end()); break; case GeoQuadricNDConstants.QUADRIC_PARABOLOID: center = quadric.getMidpoint3D(); r0 = quadric.getHalfAxis(0); r1 = quadric.getHalfAxis(1); surface = renderer.getGeometryManager().getSurface(); surface.start(getReusableSurfaceIndex()); ev0 = quadric.getEigenvec3D(0); ev1 = quadric.getEigenvec3D(1); ev2 = quadric.getEigenvec3D(2); if (quadric.getHalfAxis(2) < 0) { ev0 = ev0.mul(-1); ev2 = ev2.mul(-1); } if (vMinMax == null) { vMinMax = new double[2]; } vMinMax[0] = Double.POSITIVE_INFINITY; vMinMax[1] = Double.NEGATIVE_INFINITY; getView3D().getMinIntervalOutsideClipping(vMinMax, center, ev2); if (vMinMax[1] < 0) { // nothing to draw setSurfaceIndex(surface.end()); } else { scale = getView3D().getScale(); // get radius at max if (vMinMax[0] <= 0) { vMinMax[0] = 0; } else { vMinMax[0] = Math.sqrt(vMinMax[0]); } vMinMax[1] = Math.sqrt(vMinMax[1]); radius = Math.max(r0, r1) * vMinMax[1]; longitude = surface.calcSphereLongitudesNeeded(radius, scale); surface.drawParaboloid( center, ev0, ev1, ev2, r0, r1, longitude, vMinMax[0], vMinMax[1], !getView3D().useClippingCube()); setSurfaceIndex(surface.end()); } break; case GeoQuadricNDConstants.QUADRIC_HYPERBOLIC_PARABOLOID: center = quadric.getMidpoint3D(); r0 = quadric.getHalfAxis(0); r1 = quadric.getHalfAxis(1); surface = renderer.getGeometryManager().getSurface(); surface.start(getReusableSurfaceIndex()); ev0 = quadric.getEigenvec3D(0); ev1 = quadric.getEigenvec3D(1); ev2 = quadric.getEigenvec3D(2); if (uMinMax == null) { uMinMax = new double[2]; } uMinMax[0] = Double.POSITIVE_INFINITY; uMinMax[1] = Double.NEGATIVE_INFINITY; getView3D().getMinIntervalOutsideClipping(uMinMax, center, ev0); if (vMinMax == null) { vMinMax = new double[2]; } vMinMax[0] = Double.POSITIVE_INFINITY; vMinMax[1] = Double.NEGATIVE_INFINITY; getView3D().getMinIntervalOutsideClipping(vMinMax, center, ev1); surface.drawHyperbolicParaboloid( center, ev0, ev1, ev2, r0, r1, uMinMax[0], uMinMax[1], vMinMax[0], vMinMax[1], !getView3D().useClippingCube()); setSurfaceIndex(surface.end()); break; case GeoQuadricNDConstants.QUADRIC_PARABOLIC_CYLINDER: center = quadric.getMidpoint3D(); r2 = quadric.getHalfAxis(2); surface = renderer.getGeometryManager().getSurface(); surface.start(getReusableSurfaceIndex()); ev0 = quadric.getEigenvec3D(0); ev1 = quadric.getEigenvec3D(1); ev2 = quadric.getEigenvec3D(2); if (uMinMax == null) { uMinMax = new double[2]; } uMinMax[0] = Double.POSITIVE_INFINITY; uMinMax[1] = Double.NEGATIVE_INFINITY; if (vMinMax == null) { vMinMax = new double[2]; } vMinMax[0] = Double.POSITIVE_INFINITY; vMinMax[1] = Double.NEGATIVE_INFINITY; getView3D().getMinIntervalOutsideClipping(vMinMax, center, ev0); if (vMinMax[1] < 0) { // nothing to draw setSurfaceIndex(surface.end()); } else { scale = getView3D().getScale(); // get radius at max if (vMinMax[0] <= 0) { vMinMax[0] = 0; } else { vMinMax[0] = Math.sqrt(vMinMax[0]); } vMinMax[1] = Math.sqrt(vMinMax[1]); getView3D().getMinIntervalOutsideClipping(uMinMax, center, ev1); surface.drawParabolicCylinder( center, ev0, ev1, ev2, r2, vMinMax[0], vMinMax[1], uMinMax[0], uMinMax[1], !getView3D().useClippingCube()); setSurfaceIndex(surface.end()); } break; case GeoQuadricNDConstants.QUADRIC_HYPERBOLIC_CYLINDER: center = quadric.getMidpoint3D(); r0 = quadric.getHalfAxis(0); r1 = quadric.getHalfAxis(1); surface = renderer.getGeometryManager().getSurface(); surface.start(getReusableSurfaceIndex()); ev0 = quadric.getEigenvec3D(0); ev1 = quadric.getEigenvec3D(1); ev2 = quadric.getEigenvec3D(2); if (uMinMax == null) { uMinMax = new double[2]; } uMinMax[0] = Double.POSITIVE_INFINITY; uMinMax[1] = Double.NEGATIVE_INFINITY; getView3D().getMinIntervalOutsideClipping(uMinMax, center, ev0.mul(r0)); scale = getView3D().getScale(); if (uMinMax[0] < -1) { // bottom exists min = -DrawConic3D.acosh(-uMinMax[0]); } else if (uMinMax[0] <= 1) { // top ends at pole min = 0; } else { // top pole is cut min = DrawConic3D.acosh(uMinMax[0]); } if (uMinMax[1] > 1) { // top exists max = DrawConic3D.acosh(uMinMax[1]); } else if (uMinMax[1] >= -1) { // bottom ends at pole max = 0; } else { // bottom pole is cut max = -DrawConic3D.acosh(-uMinMax[1]); } if (vMinMax == null) { vMinMax = new double[2]; } vMinMax[0] = Double.POSITIVE_INFINITY; vMinMax[1] = Double.NEGATIVE_INFINITY; getView3D().getMinIntervalOutsideClipping(vMinMax, center, ev2); if (min < 0) { surface.drawHyperbolicCylinder( center, ev0.mul(-1), ev1.mul(-1), ev2, r0, r1, -max, -min, vMinMax[0], vMinMax[1], !getView3D().useClippingCube()); } if (max > 0) { surface.drawHyperbolicCylinder( center, ev0, ev1, ev2, r0, r1, min, max, vMinMax[0], vMinMax[1], !getView3D().useClippingCube()); } uMinMax[0] = Math.sinh(min); uMinMax[1] = Math.sinh(max); setSurfaceIndex(surface.end()); break; case GeoQuadricNDConstants.QUADRIC_CONE: surface = renderer.getGeometryManager().getSurface(); surface.start(getReusableSurfaceIndex()); if (quadric instanceof GeoQuadric3DPart) { // simple cone double height = ((GeoQuadric3DPart) quadric).getBottomParameter() - ((GeoQuadric3DPart) quadric).getTopParameter(); Coords top = quadric.getMidpoint3D(); ev1 = quadric.getEigenvec3D(0); ev2 = quadric.getEigenvec3D(1); radius = quadric.getHalfAxis(0); double radius2 = quadric.getHalfAxis(1); Coords bottomCenter = surface.cone( top, ev1, ev2, quadric.getEigenvec3D(2), radius, radius2, 0, 2 * Math.PI, height, 1f); boundsMin.setValues(top, 3); boundsMax.setValues(top, 3); radius *= height; enlargeBoundsToDiagonal(boundsMin, boundsMax, bottomCenter, ev1, ev2, radius, radius2); } else { // infinite cone if (vMinMax == null) { vMinMax = new double[2]; } vMinMax[0] = Double.POSITIVE_INFINITY; vMinMax[1] = Double.NEGATIVE_INFINITY; getMinMax(vMinMax); min = vMinMax[0]; max = vMinMax[1]; // min -= delta; // max += delta; // App.debug(min+","+max); center = quadric.getMidpoint3D(); ev1 = quadric.getEigenvec3D(0); ev2 = quadric.getEigenvec3D(1); Coords ev3 = quadric.getEigenvec3D(2); r1 = quadric.getHalfAxis(0); r2 = quadric.getHalfAxis(1); if (min * max < 0) { if (getView3D().useClippingCube()) { surface.cone(center, ev1, ev2, ev3, r1, r2, 0, 2 * Math.PI, min, 1f); surface.cone(center, ev1, ev2, ev3, r1, r2, 0, 2 * Math.PI, max, 1f); } else { surface.cone( center, ev1, ev2, ev3, r1, r2, 0, 2 * Math.PI, min, (float) ((-9 * min - max) / (min - max))); surface.cone( center, ev1, ev2, ev3, r1, r2, 0, 2 * Math.PI, max, (float) ((-9 * max - min) / (max - min))); } } else { if (getView3D().useClippingCube()) { surface.cone(center, ev1, ev2, ev3, r1, r2, 0, 2 * Math.PI, min, max, false, false); } else { double delta = (max - min) / 10; surface.cone( center, ev1, ev2, ev3, r1, r2, 0, 2 * Math.PI, min + delta, max - delta, false, false); surface.cone( center, ev1, ev2, ev3, r1, r2, 0, 2 * Math.PI, min, min + delta, true, false); surface.cone( center, ev1, ev2, ev3, r1, r2, 0, 2 * Math.PI, max - delta, max, false, true); } } } setSurfaceIndex(surface.end()); break; case GeoQuadricNDConstants.QUADRIC_CYLINDER: center = quadric.getMidpoint3D(); ev1 = quadric.getEigenvec3D(0); ev2 = quadric.getEigenvec3D(1); Coords ev3 = quadric.getEigenvec3D(2); surface = renderer.getGeometryManager().getSurface(); surface.start(getReusableSurfaceIndex()); if (quadric instanceof GeoQuadric3DPart) { // simple cylinder radius = quadric.getHalfAxis(0); double radius2 = quadric.getHalfAxis(1); longitude = renderer.getGeometryManager().getLongitude(radius, getView3D().getScale()); Coords bottomCenter = surface.cylinder( center, ev1, ev2, ev3, radius, radius2, 0, 2 * Math.PI, quadric.getMinParameter(1), quadric.getMaxParameter(1), false, false, longitude); boundsMin.set(Double.POSITIVE_INFINITY); boundsMax.set(Double.NEGATIVE_INFINITY); enlargeBoundsToDiagonal(boundsMin, boundsMax, center, ev1, ev2, radius, radius); enlargeBoundsToDiagonal(boundsMin, boundsMax, bottomCenter, ev1, ev2, radius, radius); } else { if (vMinMax == null) { vMinMax = new double[2]; } vMinMax[0] = Double.POSITIVE_INFINITY; vMinMax[1] = Double.NEGATIVE_INFINITY; getMinMax(vMinMax); min = vMinMax[0]; max = vMinMax[1]; r1 = quadric.getHalfAxis(0); r2 = quadric.getHalfAxis(1); radius = Math.max(r1, r2); longitude = renderer.getGeometryManager().getLongitude(radius, getView3D().getScale()); if (getView3D().useClippingCube()) { surface.cylinder( center, ev1, ev2, ev3, r1, r2, 0, 2 * Math.PI, min, max, false, false, longitude); } else { double delta = (max - min) / 10; surface.cylinder( center, ev1, ev2, ev3, r1, r2, 0, 2 * Math.PI, min + delta, max - delta, false, false, longitude); surface.cylinder( center, ev1, ev2, ev3, r1, r2, 0, 2 * Math.PI, min, min + delta, true, false, longitude); surface.cylinder( center, ev1, ev2, ev3, r1, r2, 0, 2 * Math.PI, max - delta, max, false, true, longitude); } } setSurfaceIndex(surface.end()); break; case GeoQuadricNDConstants.QUADRIC_SINGLE_POINT: surface = renderer.getGeometryManager().getSurface(); surface.start(getReusableSurfaceIndex()); Coords m = quadric.getMidpoint3D(); double thickness = quadric.getLineThickness() / getView3D().getScale() * DrawPoint3D.DRAW_POINT_FACTOR; surface.drawSphere(quadric.getLineThickness(), m, thickness); setSurfaceIndex(surface.end()); boundsMin.setValues(m, 3); boundsMax.setValues(m, 3); boundsMin.addInside(-thickness); boundsMax.addInside(thickness); break; case GeoQuadricNDConstants.QUADRIC_PARALLEL_PLANES: case GeoQuadricNDConstants.QUADRIC_INTERSECTING_PLANES: initDrawPlanes(quadric); drawPlanes[0].updateForItSelf(); drawPlanes[1].updateForItSelf(); break; case GeoQuadricNDConstants.QUADRIC_PLANE: initDrawPlanes(quadric); drawPlanes[0].updateForItSelf(); break; case GeoQuadricNDConstants.QUADRIC_LINE: initDrawLine(quadric); drawLine.updateForItSelf(); break; default: setSurfaceIndex(-1); } return true; }

public static IntervalDouble math_sinh(IntervalDouble a) { IntervalDouble res = new IntervalDouble(Math.sinh(a.value), DoubleInterval.sinh(a.interval), a.isUnStable); return res; }

@Override public Object visit(RealUnaryExpression n, Void arg) { Double doubleObject = (Double) n.getOperand().accept(this, null); double doubleVal = doubleObject.doubleValue(); Operator op = n.getOperator(); switch (op) { case ABS: return Math.abs(doubleVal); case ACOS: return Math.acos(doubleVal); case ASIN: return Math.asin(doubleVal); case ATAN: return Math.atan(doubleVal); case CBRT: return Math.cbrt(doubleVal); case CEIL: return Math.ceil(doubleVal); case COS: return Math.cos(doubleVal); case COSH: return Math.cosh(doubleVal); case EXP: return Math.exp(doubleVal); case EXPM1: return Math.expm1(doubleVal); case FLOOR: return Math.floor(doubleVal); case LOG: return Math.log(doubleVal); case LOG10: return Math.log10(doubleVal); case LOG1P: return Math.log1p(doubleVal); case NEG: return -doubleVal; case NEXTUP: return Math.nextUp(doubleVal); case RINT: return Math.rint(doubleVal); case SIGNUM: return Math.signum(doubleVal); case SIN: return Math.sin(doubleVal); case SINH: return Math.sinh(doubleVal); case SQRT: return Math.sqrt(doubleVal); case TAN: return Math.tan(doubleVal); case TANH: return Math.tanh(doubleVal); case TODEGREES: return Math.toDegrees(doubleVal); case TORADIANS: return Math.toRadians(doubleVal); case ULP: return Math.ulp(doubleVal); default: log.warn("RealUnaryExpression: unimplemented operator: " + op); return null; } }

@Override public O compute(I x, O output) { double value = Math.sinh(x.getRealDouble()); output.setReal(value); return output; }

// To add/remove functions change evaluateOperator() and registration public double evaluateFunction(String fncnam, ArgParser fncargs) throws ArithmeticException { switch (Character.toLowerCase(fncnam.charAt(0))) { case 'a': { if (fncnam.equalsIgnoreCase("abs")) { return Math.abs(fncargs.next()); } if (fncnam.equalsIgnoreCase("acos")) { return Math.acos(fncargs.next()); } if (fncnam.equalsIgnoreCase("asin")) { return Math.asin(fncargs.next()); } if (fncnam.equalsIgnoreCase("atan")) { return Math.atan(fncargs.next()); } } break; case 'c': { if (fncnam.equalsIgnoreCase("cbrt")) { return Math.cbrt(fncargs.next()); } if (fncnam.equalsIgnoreCase("ceil")) { return Math.ceil(fncargs.next()); } if (fncnam.equalsIgnoreCase("cos")) { return Math.cos(fncargs.next()); } if (fncnam.equalsIgnoreCase("cosh")) { return Math.cosh(fncargs.next()); } } break; case 'e': { if (fncnam.equalsIgnoreCase("exp")) { return Math.exp(fncargs.next()); } if (fncnam.equalsIgnoreCase("expm1")) { return Math.expm1(fncargs.next()); } } break; case 'f': { if (fncnam.equalsIgnoreCase("floor")) { return Math.floor(fncargs.next()); } } break; case 'g': { // if(fncnam.equalsIgnoreCase("getExponent" )) { return // Math.getExponent(fncargs.next()); } needs Java 6 } break; case 'l': { if (fncnam.equalsIgnoreCase("log")) { return Math.log(fncargs.next()); } if (fncnam.equalsIgnoreCase("log10")) { return Math.log10(fncargs.next()); } if (fncnam.equalsIgnoreCase("log1p")) { return Math.log1p(fncargs.next()); } } break; case 'm': { if (fncnam.equalsIgnoreCase("max")) { return Math.max(fncargs.next(), fncargs.next()); } if (fncnam.equalsIgnoreCase("min")) { return Math.min(fncargs.next(), fncargs.next()); } } break; case 'n': { // if(fncnam.equalsIgnoreCase("nextUp" )) { return Math.nextUp // (fncargs.next()); } needs Java 6 } break; case 'r': { if (fncnam.equalsIgnoreCase("random")) { return Math.random(); } // impure if (fncnam.equalsIgnoreCase("round")) { return Math.round(fncargs.next()); } if (fncnam.equalsIgnoreCase("roundHE")) { return Math.rint(fncargs.next()); } // round half-even } break; case 's': { if (fncnam.equalsIgnoreCase("signum")) { return Math.signum(fncargs.next()); } if (fncnam.equalsIgnoreCase("sin")) { return Math.sin(fncargs.next()); } if (fncnam.equalsIgnoreCase("sinh")) { return Math.sinh(fncargs.next()); } if (fncnam.equalsIgnoreCase("sqrt")) { return Math.sqrt(fncargs.next()); } } break; case 't': { if (fncnam.equalsIgnoreCase("tan")) { return Math.tan(fncargs.next()); } if (fncnam.equalsIgnoreCase("tanh")) { return Math.tanh(fncargs.next()); } if (fncnam.equalsIgnoreCase("toDegrees")) { return Math.toDegrees(fncargs.next()); } if (fncnam.equalsIgnoreCase("toRadians")) { return Math.toRadians(fncargs.next()); } } break; case 'u': { if (fncnam.equalsIgnoreCase("ulp")) { return Math.ulp(fncargs.next()); } } break; // no default } throw new UnsupportedOperationException( "MathEval internal function setup is incorrect - internal function \"" + fncnam + "\" not handled"); }

/** * Evaluates the Jacobian elliptic functions sn(u|m), cn(u|m), and dn(u|m) of parameter m between * 0 and 1, and real argument u. (based on the function from the Cephes Math Library) * * @param u * @param m * @return an array containing the values of the functions sn(u|m), cn(u|m), dn(u|m) and phi, the * amplitude of u */ public static double[] calculateJacobianEllipticFunctionsValues(double u, double m) { double ai, b, phi, t, twon; double sn, cn, ph, dn; double[] a = new double[9]; double[] c = new double[9]; int i; // Check for special cases if (m < 0.0 || m > 1.0 || Double.isNaN(m)) throw new IllegalArgumentException("m should be in <0,1>"); if (m < 1.0e-9) { t = Math.sin(u); b = Math.cos(u); ai = 0.25 * m * (u - t * b); sn = t - ai * b; cn = b + ai * t; ph = u - ai; dn = 1.0 - 0.5 * m * t * t; return new double[] {sn, cn, dn, ph}; } if (m >= 0.9999999999) { ai = 0.25 * (1.0 - m); b = Math.cosh(u); t = Math.tanh(u); phi = 1.0 / b; twon = b * Math.sinh(u); sn = t + ai * (twon - u) / (b * b); ph = 2.0 * Math.atan(Math.exp(u)) - Math.PI / 2 + ai * (twon - u) / b; ai *= t * phi; cn = phi - ai * (twon - u); dn = phi + ai * (twon + u); return new double[] {sn, cn, dn, ph}; } // A. G. M. scale a[0] = 1.0; b = Math.sqrt(1.0 - m); c[0] = Math.sqrt(m); twon = 1.0; i = 0; while (Math.abs(c[i] / a[i]) > getMachineEpsilon()) { if (i > 7) throw new IllegalArgumentException( "Jacobian elliptic functions cannot be calculated due to overflow range error"); ai = a[i]; i++; c[i] = (ai - b) / 2.0; t = Math.sqrt(ai * b); a[i] = (ai + b) / 2.0; b = t; twon *= 2.0; } // backward recurrence phi = twon * a[i] * u; do { t = c[i] * Math.sin(phi) / a[i]; b = phi; phi = (Math.asin(t) + phi) / 2.0; i--; } while (i > 0); sn = Math.sin(phi); t = Math.cos(phi); cn = t; dn = t / Math.cos(phi - b); ph = phi; return new double[] {sn, cn, dn, ph}; }

public static double gamma(double n) { return Math.sqrt(2.0 * Math.PI / n) * Math.pow( (n / Math.E) * Math.sqrt(n * Math.sinh((1.0 / n) + (1 / 810 * Math.pow(n, 6)))), n); }

@Override protected double compute(double value) { return Double.isNaN(value) ? Double.NaN : Math.sinh(value); }

// return a new Complex object whose value is the complex cosine of this public Complex cos() { return new Complex(Math.cos(re) * Math.cosh(im), -Math.sin(re) * Math.sinh(im)); }

/** * <u>Berechnen der e-Funktion der komplexen Zahl</u><br> * * @return Rückgabe eines Objektes vom Typ Complex mit Lösung aus exp(<u>z</u>) */ public Complex exp() { return new Complex( Math.cos(this.getImag()) * (Math.sinh(this.getReal()) + Math.cosh(this.getReal())), Math.sin(this.getImag()) * (Math.cosh(this.getReal()) + Math.sinh(this.getReal()))); }

public RealNumber sinh() { return new RealNumber(Math.sinh(this.value)); }

/** * <u>Berechnen der e-Funktion der komplexen Zahl</u><br> * * @param comp Komplexe Zahl * @return Rückgabe eines Objektes vom Typ Complex mit Lösung aus exp(<u>z</u>) */ public static Complex exp(Complex comp) { return new Complex( Math.cos(comp.getImag()) * (Math.sinh(comp.getReal()) + Math.cosh(comp.getReal())), Math.sin(comp.getImag()) * (Math.cosh(comp.getReal()) + Math.sinh(comp.getReal()))); }

public static double besselJ(double nu, double x) { double next, sum, next1, next2, sum1, sum2, int1, int2, yp, y, yn, h; long m, N; if (x < 0) return Double.NaN; if ((nu < 0) && (Math.round(nu) == nu)) if (((int) Math.round(nu)) % 2 == 1) return -besselJ(-nu, x); else return besselJ(-nu, x); if ((nu == 0.0) && (x == 0.0)) return 1.0; if (x == 0.0) return 0.0; // power series if ((x <= 15) || (x * x < 15 * nu)) { next = Math.pow(x / 2, nu) / eulergamma(nu + 1); sum = next; // int max = (int)(200>5*nu?200*x:5*nu*x); int max = 200; for (m = 1; m < max; m++) { next *= (-1) * (x * x / 4) / (m * (m + nu)); sum += next; } return sum; } else if (8 * x > (nu * nu)) { // asymptotic expansion // if((x>30)&&(x>(3*(nu*nu-0.25)))){ next1 = 1; sum1 = next1; next2 = (4 * nu * nu - 1) / (8 * x); sum2 = next2; int max = 10 > nu ? 10 : (int) nu; for (m = 1; m <= max; m++) { next1 *= -(4 * nu * nu - (4 * m - 3) * (4 * m - 3)) * (4 * nu * nu - (4 * m - 1) * (4 * m - 1)) / ((2 * m - 1) * 2 * m * 8 * x * 8 * x); sum1 += next1; next2 *= -(4 * nu * nu - (4 * m - 1) * (4 * m - 1)) * (4 * nu * nu - (4 * m + 1) * (4 * m + 1)) / (2 * m * (2 * m + 1) * 8 * x * 8 * x); sum2 += next2; } return Math.sqrt(2 / (pi * x)) * (Math.cos(x - pi * nu / 2 - pi / 4) * sum1 - Math.sin(x - pi * nu / 2 - pi / 4) * sum2); } // integral N = (long) 40 * Math.round(x); h = pi / N; yp = 1; y = Math.cos(nu * h - x * Math.sin(h)); yn = Math.cos(nu * 2 * h - x * Math.sin(2 * h)); int1 = h / 3 * (yp + 4 * y + yn); for (m = 3; m < N; m += 2) { yp = yn; y = Math.cos(nu * m * h - x * Math.sin(m * h)); yn = Math.cos(nu * (m + 1) * h - x * Math.sin((m + 1) * h)); int1 += h / 3 * (yp + 4 * y + yn); } if (nu == Math.round(nu)) return int1 / pi; h = 0.0004; yp = 1; y = Math.exp(-x * Math.sinh(h) - nu * h); yn = Math.exp(-x * Math.sinh(2 * h) - nu * h); int2 = h / 3 * (yp + 4 * y + yn); for (m = 3; m < 5000; m += 2) { yp = yn; y = Math.exp(-x * Math.sinh(m * h) - nu * m * h); yn = Math.exp(-x * Math.sinh((m + 1) * h) - nu * (m + 1) * h); int2 += h / 3 * (yp + 4 * y + yn); } return int1 / pi - Math.sin(nu * pi) * int2 / pi; }