Hallo,

Da bin ich froh, ich hätte sonst extra in die Bibliothek der TUM nach München gemusst. Ich selbst bevorzuge die Lösung von Nick Stuifbergen.

Ich habe gerade nachgesehen. Ich hatte es richtig in Erinnerung. Er verweist auf die Methode von Klotz und leitet einen in Fortran implementierten Algorithmus ab, der auch abgedruckt ist.

Sollte auch kein Benchmark-Test sein, aber wer rechnet normalerweise 100.000 Punkte um.

Oh, da kenne ich einige, die ihre alten Daten ins neue UTM-System überführen möchten und dies in einem Rutsch machen.

Doch nicht so komfortabel, aber sicher auch kein Problem.

Naja, die von mir genutzte Klasse findest Du am Ende des Postings. Sie reicht aus für die Grundrechenarten - und mehr als addieren kann der PC ja eh nicht

Für mich persönlich liegt der Mehrwert in der Theorie.

Okay, magst Du Deinen Artikel hier veröffentlichen?

Schöne Grüße
Micha

 
  /**********************************************************************
  * Copyright (C) by Michael Loesler, http//derletztekick.com            *
  *                                                                      *
  * This program is free software; you can redistribute it and/or modify *
  * it under the terms of the GNU General Public License as published by *
  * the Free Software Foundation; either version 3 of the License, or    *
  * (at your option) any later version.                                  *
  *                                                                      *
  * This program is distributed in the hope that it will be useful,      *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        *
  * GNU General Public License for more details.                         *
  *                                                                      *
  * You should have received a copy of the GNU General Public License    *
  * along with this program; if not, see <http://www.gnu.org/licenses/>  *
  * or write to the                                                      *
  * Free Software Foundation, Inc.,                                      *
  * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.            *
  *                                                                      *
   **********************************************************************/
 
package com.derletztekick.tools.geodesy;
 
public class Complex {
 public final static Complex ONE  = new Complex(1.0,0.0);
 public final static Complex ZERO = new Complex(0.0,0.0);
 
 private final double re, im;
 
 public Complex(double real) {
  this(real, 0);
 }
 
 public Complex(double real, double imag) {
  this.re = real;
  this.im = imag;
 }
 
 public double abs()   { 
  return Math.hypot(this.re, this.im); 
 }
 
 public double phase() { 
  return Math.atan2(this.im, this.re); 
 } 
 
 public Complex plus(Complex b) {
  return new Complex(this.re + b.re, this.im + b.im);
 }
 
 public Complex minus(Complex b) {
  return new Complex(this.re - b.re, this.im - b.im);
 }
 
 public Complex times(Complex b) {
  return new Complex(this.re * b.re - this.im * b.im, this.re * b.im + this.im * b.re);
 }
 
 public Complex divides(Complex b) {
  return this.times(b.reciprocal());
 }
 
 public Complex plus(double d) {
  return this.plus(new Complex(d));
 }
 
 public Complex minus(double d) {
  return this.minus(new Complex(d));
 }
 
 public Complex times(double d) {
  return this.times(new Complex(d));
 }
 
 public Complex divides(double d) {
  return this.divides(new Complex(d));
 }
 
 public Complex conjugate() {  
  return new Complex(this.re, -this.im); 
 }
 
 public Complex reciprocal() {
  double scale = this.re*this.re + this.im*this.im;
  return new Complex(re / scale, -this.im / scale);
 }
 
 public double real() {
  return re; 
 }
 
 public double image() { 
  return this.im; 
 }
 
 public Complex exp() {
  return new Complex(Math.exp(this.re) * Math.cos(this.im), Math.exp(this.re) * Math.sin(this.im));
 }
 
 public Complex sin() {
  return new Complex(Math.sin(this.re) * Math.cosh(this.im), Math.cos(this.re) * Math.sinh(this.im));
 }
 
 public Complex cos() {
  return new Complex(Math.cos(this.re) * Math.cosh(this.im), -Math.sin(this.re) * Math.sinh(this.im));
 }
 
 public Complex tan() {
  return this.sin().divides(this.cos());
 }
 
 public Complex sinh() {
  return new Complex(Math.sinh(this.re) * Math.cos(this.im), Math.cosh(this.re) * Math.sin(this.im));
 }
 
 public Complex cosh() {
  return new Complex(Math.cosh(this.re) * Math.cos(this.im), Math.sinh(this.re) * Math.sin(this.im));
 }
 
 public Complex tanh() {
  return this.sinh().divides(this.cosh());
 }
 
 public Complex coth() {
  return this.cosh().divides(this.sinh());
 }
 
 public Complex asin() {
  double re2 = this.re * this.re;
  double im2 = this.im * this.im;
  double t1 = re2 + im2;
  //double t2 = Math.sqrt( (t1-1.0) * (t1-1.0) + 4.0 * im2 );
  double t2 = Math.hypot( (t1-1.0), 2.0 * Math.abs(this.im) );
  return new Complex(
    0.5*Math.signum(this.re) * Math.acos(t2 - t1),
    //0.5*Math.signum(this.im) * MathExtension.acosh(t2 + t1),
    0.5*Math.signum(this.im) * Math.log((t2 + t1)+Math.sqrt((t2 + t1)*(t2 + t1) - 1.0))
  );
 }
 
 public Complex acos(){
  return (new Complex(0.5*Math.PI)).minus(this.asin());
 }
 
 public Complex log() {
  return new Complex(Math.log(this.abs()), this.phase());
 }
 
 public Complex pow(Complex z){
  return (z.times(this.log())).exp();
 }
 
 public Complex pow(double d){
  return this.pow(new Complex(d));
 }
 
 
 @Override
 public String toString() {
  return this.re + " " + (this.im < 0.0 ? "-" : "+") + " " + Math.abs(this.im) + "i";
 }
 
 public static void main(String args[]) {
  Complex a = new Complex(3.14, 5.78);
 
  System.out.println(a.pow(a));
 }
}
 

--
applied-geodesy.org - OpenSource Least-Squares Adjustment Software for Geodetic Sciences

Hallo,

Seb verstehe ich das richtig, das Du die Taylor-Reihen für Gauß-Krüger selbst entwickelst, das würde mich interessieren. Es gibt schon einige Programmiersprachen bei denen komplexe Funktionen implementiert sind z.B.: Fortran oder Delphi oder die meisten Computeralgebrasysteme. Wie Michael gezeigt hat, ist es aber auch möglich diese Funktionen selbst zu definieren.

Mir ist bekannt, dass man Taylor-Reihen numerisch lösen kann. Ich habe z.B. eine Lösung in Matlab vorliegend, die ich von dieser Quelle habe:

Numerical Methods in MATLAB (Matthews)

Diese müssen dann nur in Java oder C umgeschrieben werden, wobei ich glaube, dass es dort schon fertige Lösungen gibt. Die GK Lösung für die Taylorreihe habe ich grade nicht zur Hand.

Sonst kann ich mich der Meinung von Michael nur anschleißen innerhalb der Meridianstreifen hat die komplexe Lösung keinen Mehrwert.

Aber es gibt Länder z.B. Polen, hier wurde über die Einführung eines 10° breiten Meridianstreifens nachgedacht, Kanada oder die Skandinavischen Länder die größere Steifenbreiten verwenden möchten. Letztere weil bei Ihnen die ellipsoidischen Zweiecke schon sehr schmal sind. Wenn man die Isolinien des Maßstabsfaktors betrachtet, kommt man ohnehin zu der Überlegung statt des Zweieckes lieber ein Band konstanter Breite zu verwenden. In Nordrichtung wird der Maßstabsfaktor sogar kleiner.

Die Sache wird wirklich interessant, wenn die Streifen breiter werden wie z.B. in Ländern höherer Breiten. Du scheinst da schon einiges Hintergrundwissen zu haben.

Ich bin da auch nicht mehr so fit drin in den geodätischen Projektionen.
Ich habe nur noch das im Ohr:

Die Streckenkorrektion wächst mit dem Quadrat des Abstandes vom Mittelmeridian

Da habe ich nochmal in meinem schlaues Skript geguckt und tatsächlich:

Aber das gilt offenbar nur für die konventionelle Entwicklung. Vielleicht müssen dann die Formeln überdacht werden.

Die Hauptgleichung der konformen Gauß’schen Abbildung lautet:
(x + y * i) = f(q + L * i).
Dieser einfachen Gleichung kann man im Komplexen direkt folgen. Von der komplexen Mercator-Ebene geht es über die Ebene der komplexen Breite zur komplexen Gauß-Ebene. Die Funktion-f ist dabei die inverse Mercatorfunktion und die Funktion der Meridianbogenlänge.

Dann ist die Sache ja nicht schwierig. Komplexe Zahlen ja sich seit jeher gut für Projektionen gemacht. Der komplexe Zahlenraum ist ja per se schon ein zweidimensionaler Raum, wo man alles unterbringen und überführen kann.
Mittlerweile komme ich auch ins Grübeln, vielleicht ist die komplexe Variante sogar die mathematisch Intuitivere, aber war in Vergangenheit schwierig numerisch zu machen. Heute sollte es kein Problem mehr sein!

Naja, die von mir genutzte Klasse findest Du am Ende des Postings. Sie reicht aus für die Grundrechenarten - und mehr als addieren kann der PC ja eh nicht

Da ist aber der Michael nett, dass er dich gleich die Klasse für komplexe Zahlen schenkt... dann ist ja die Umsetzung ein kinderleichtes Unterfangen.

Viel Erfolg!
LG Sebastian