Erreur lors de la compilation - Page 1

1

Le 13/11/2007 à 23:01Edité par Spomky le 13/11/2007 à 23:13

J'ai une erreur lorsque je compile avec -pedantic (qui est plus rigoureux que -Wall).

CLocate.h:527: erreur: floating-point literal ne peut apparaître dans une expression de constante
CLocate.h:527: erreur: ISO C++ forbids initialization of member constant «PI" of non-integral type «const float"

La ligne incriminée est
static const float PI = 3.14159265358979323846;
J'ai mis
#define PI 3.14159265358979323846
pour l'enlever mais y a-t-il une autre solution que passer par un define?

2

Le 13/11/2007 à 23:13

Impossible de reproduire avec g++ 4.0 ou g++ 4.1
Donne plus de détails.

3

Le 13/11/2007 à 23:15

Je compile pourtant avec GCC 4.1.3
La ligne de commande que j'utilise est
g++ -Wall -pedantic -c CLocate.cpp

4

Le 13/11/2007 à 23:20

Donne l'extrait le plus grand de ton code source qui reproduit l'erreur.

5

Le 13/11/2007 à 23:26

A quoi ça sert de déclarer statique une constante ?

Un site complet sur lequel vous trouverez des programmes et des jeux pour votre calculatrice TI 89 / Titanium / 92+ / Voyage 200 : www.ti-fr.com.
Quelques idées personnelles ici.

6

Le 13/11/2007 à 23:27

Thibaut (./5) :
A quoi ça sert de déclarer statique une constante ?

A ne pas lui donner une visibilité vers l'extérieur. Mais un namespace anonyme aurait été mieux ((c) et tm jepenseenc++ ) ce qui permet au compilateur de la supprimer si elle n'est pas réellement utilisée.

7

Le 13/11/2007 à 23:30Edité par Zeph le 15/10/2014 à 23:32

eturn true; }

CLocate.cpp : //  --------------------------------------------------------------------------------------- //
//                                                                                          //
//                    Copyright (c) 2006 Spomky.Dev                                         //
//                       <http://www.spomky.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 2 of the License, or                       //
//  (at your option) any later version.                                                     //
//                                                                                          //
//  You may not change or alter any portion of this comment or credits                      //
//  of supporting developers from this source code or any supporting                        //
//  source code which is considered copyrighted (c) material of the                         //
//  original comment or credit authors.                                                     //
//                                                                                          //
//  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, write to the Free Software                             //
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA                //
// ---------------------------------------------------------------------------------------- //

// Author: Webmaster/Spomky.Dev (webmaster@spomky.com)
// URL:  http://www.spomky.com
// Project:

//C++ CODE SOURCE
#include "CLocate.h"

CLocate & CLocate::operator=( const CLocate &object )
{
     this->setDataFromObject( object );
     return *this;
}


bool CLocate::operator==( const CLocate& object ) const
{
     long double distance = this->getDistance( object );
     return (this->epsilon >= 0 && distance < this->epsilon) || (this->epsilon < 0 && distance > this->epsilon);
}


void CLocate::setDataFromValue( const long double X , const long double Y , const long double Z )
{
     this->data.Type = COORD_XYZ;
     this->data.Coord.XYZ.x = X;
     this->data.Coord.XYZ.y = Y;
     this->data.Coord.XYZ.z = Z;
}


std::string CLocate::getCoordinateName( const COORD_TYPE type )
{
     switch (type)
     {
          case COORD_unset:
               return "unset";
          case COORD_default:
               return "default";
          case COORD_XYZ:
               return "X,Y,Z";
          case COORD_Dd:
               return "degrees decimal";
          case COORD_DMd:
               return "degrees,minutes decimal";
          case COORD_DMSd:
               return "degrees,minutes,secondes decimal";
          case COORD_DMS:
               return "degrees,minutes,secondes";
          default:
               return "unknown!";
     }
}


void CLocate::setDataFromValue( const float lat_D , const float lon_D , const double alt )
{
     this->data.Type = COORD_Dd;
     this->data.Coord.Dd.latitude.d = lat_D;
     this->data.Coord.Dd.longitude.d = lon_D;
     this->data.Coord.Dd.altitude = alt;
}


void CLocate::setDataFromValue( const short lat_D , const float lat_M , const short lon_D , const float lon_M , const double alt )
{
     this->data.Type = COORD_DMd;
     this->data.Coord.DMd.latitude.d = lat_D;
     this->data.Coord.DMd.latitude.m = lat_M;
     this->data.Coord.DMd.longitude.d = lon_D;
     this->data.Coord.DMd.longitude.m = lon_M;
     this->data.Coord.DMd.altitude = alt;
}


void CLocate::setDataFromValue( const short lat_D , const short lat_M , const float lat_S , const short lon_D , const short lon_M , const float lon_S , const double alt )
{
     this->data.Type = COORD_DMSd;
     this->data.Coord.DMSd.latitude.d = lat_D;
     this->data.Coord.DMSd.latitude.m = lat_M;
     this->data.Coord.DMSd.latitude.s = lat_S;
     this->data.Coord.DMSd.longitude.d = lon_D;
     this->data.Coord.DMSd.longitude.m = lon_M;
     this->data.Coord.DMSd.longitude.s = lon_S;
     this->data.Coord.DMSd.altitude = alt;
}


void CLocate::setDataFromValue( const short lat_D , const short lat_M , const short lat_S , const short lon_D , const short lon_M , const short lon_S , const double alt )
{
     this->data.Type = COORD_DMS;
     this->data.Coord.DMS.latitude.d = lat_D;
     this->data.Coord.DMS.latitude.m = lat_M;
     this->data.Coord.DMS.latitude.s = lat_S;
     this->data.Coord.DMS.longitude.d = lon_D;
     this->data.Coord.DMS.longitude.m = lon_M;
     this->data.Coord.DMS.longitude.s = lon_S;
     this->data.Coord.DMS.altitude = alt;
}


CLocate::COORDINATES_Dd CLocate::convertCoordDd( const CLocate::COORDINATES_DMd source )
{
     COORDINATES_Dd result;
     POINT_Dd la = convertPointDd(source.latitude) , lo = convertPointDd(source.longitude);

     result.altitude = source.altitude;

     result.latitude = la;
     result.longitude = lo;
     return result;
}


CLocate::COORDINATES_Dd CLocate::convertCoordDd( const CLocate::COORDINATES_DMSd source )
{
     COORDINATES_Dd result;
     POINT_Dd la = convertPointDd(source.latitude) , lo = convertPointDd(source.longitude);

     result.altitude = source.altitude;
     result.latitude = la;
     result.longitude = lo;
     return result;
}


CLocate::COORDINATES_Dd CLocate::convertCoordDd( const CLocate::COORDINATES_DMS source )
{
     COORDINATES_Dd result;
     POINT_Dd la = convertPointDd(source.latitude) , lo = convertPointDd(source.longitude);

     result.altitude = source.altitude;
     result.latitude = la;
     result.longitude = lo;
     return result;
}


CLocate::COORDINATES_DMd CLocate::convertCoordDMd( const CLocate::COORDINATES_Dd source )
{
     COORDINATES_DMd result;
     POINT_DMd la = convertPointDMd(source.latitude) , lo = convertPointDMd(source.longitude);

     result.altitude = source.altitude;
     result.latitude = la;
     result.longitude = lo;
     return result;
}


CLocate::COORDINATES_DMd CLocate::convertCoordDMd( const CLocate::COORDINATES_DMSd source )
{
     COORDINATES_DMd result;
     POINT_DMd la = convertPointDMd(source.latitude) , lo = convertPointDMd(source.longitude);

     result.altitude = source.altitude;
     result.latitude = la;
     result.longitude = lo;
     return result;
}


CLocate::COORDINATES_DMd CLocate::convertCoordDMd( const CLocate::COORDINATES_DMS source )
{
     COORDINATES_DMd result;
     POINT_DMd la = convertPointDMd(source.latitude) , lo = convertPointDMd(source.longitude);

     result.altitude = source.altitude;
     result.latitude = la;
     result.longitude = lo;
     return result;
}


CLocate::COORDINATES_DMSd CLocate::convertCoordDMSd( const CLocate::COORDINATES_Dd source )
{
     COORDINATES_DMSd result;
     POINT_DMSd la = convertPointDMSd(source.latitude) , lo = convertPointDMSd(source.longitude);

     result.altitude = source.altitude;
     result.latitude = la;
     result.longitude = lo;
     return result;
}


CLocate::COORDINATES_DMSd CLocate::convertCoordDMSd( const CLocate::COORDINATES_DMd source )
{
     COORDINATES_DMSd result;
     POINT_DMSd la = convertPointDMSd(source.latitude) , lo = convertPointDMSd(source.longitude);

     result.altitude = source.altitude;
     result.latitude = la;
     result.longitude = lo;
     return result;
}


CLocate::COORDINATES_DMSd CLocate::convertCoordDMSd( const CLocate::COORDINATES_DMS source )
{
     COORDINATES_DMSd result;
     POINT_DMSd la = convertPointDMSd(source.latitude) , lo = convertPointDMSd(source.longitude);

     result.altitude = source.altitude;
     result.latitude = la;
     result.longitude = lo;
     return result;
}


CLocate::COORDINATES_DMS CLocate::convertCoordDMS( const CLocate::COORDINATES_Dd source )
{
     COORDINATES_DMS result;
     POINT_DMS la = convertPointDMS(source.latitude) , lo = convertPointDMS(source.longitude);

     result.altitude = source.altitude;
     result.latitude = la;
     result.longitude = lo;
     return result;
}


CLocate::COORDINATES_DMS CLocate::convertCoordDMS( const CLocate::COORDINATES_DMd source )
{
     COORDINATES_DMS result;
     POINT_DMS la = convertPointDMS(source.latitude) , lo = convertPointDMS(source.longitude);

     result.altitude = source.altitude;
     result.latitude = la;
     result.longitude = lo;
     return result;
}


CLocate::COORDINATES_DMS CLocate::convertCoordDMS( const CLocate::COORDINATES_DMSd source )
{
     COORDINATES_DMS result;
     POINT_DMS la = convertPointDMS(source.latitude) , lo = convertPointDMS(source.longitude);

     result.altitude = source.altitude;
     result.latitude = la;
     result.longitude = lo;
     return result;
}


// Vers Dd
CLocate::POINT_Dd CLocate::convertPointDd( const CLocate::POINT_DMd source )
{
     POINT_Dd result;
     result.d = std::abs(source.d);
     result.d += std::abs(source.m)/60;
     if ( source.d < 0 )
          result.d *= -1;
     return result;
}


CLocate::POINT_DMd CLocate::convertPointDMd( const CLocate::POINT_DMSd source )
{
     POINT_DMd result;
     result.d = source.d;
     result.m = std::abs(source.m);
     result.m += std::abs(source.s)/60;
     return result;
}


CLocate::POINT_DMSd CLocate::convertPointDMSd( const CLocate::POINT_DMS source )
{
     POINT_DMSd result;
     result.d = source.d;
     result.m = std::abs(source.m);
     result.s = std::abs(source.s);
     return result;
}


CLocate::POINT_Dd CLocate::convertPointDd( const CLocate::POINT_DMSd source )
{
     return convertPointDd(convertPointDMd(source));
}


CLocate::POINT_Dd CLocate::convertPointDd( const CLocate::POINT_DMS source )
{
     return convertPointDd(convertPointDMd(convertPointDMSd(source)));
}


CLocate::POINT_DMd CLocate::convertPointDMd( const CLocate::POINT_DMS source )
{
     return convertPointDMd(convertPointDMSd(source));
}


//Vers DMS
CLocate::POINT_DMd CLocate::convertPointDMd( const CLocate::POINT_Dd source )
{
     POINT_DMd result;
     result.d = (long)source.d;
     result.m = std::abs(source.d - result.d) * 60;
     return result;
}


CLocate::POINT_DMSd CLocate::convertPointDMSd( const CLocate::POINT_DMd source )
{
     POINT_DMSd result;
     result.d = source.d;
     result.m = (long)std::abs(source.m);
     result.s = std::abs(source.m - result.m) * 60;
     return result;
}


CLocate::POINT_DMS CLocate::convertPointDMS( const CLocate::POINT_DMSd source )
{
     POINT_DMS result;
     result.d = source.d;
     result.m = std::abs(source.m);
     result.s = (long)std::abs(source.s);
     return result;
}


CLocate::POINT_DMS CLocate::convertPointDMS( const CLocate::POINT_DMd source )
{
     return convertPointDMS(convertPointDMSd(source));
}


CLocate::POINT_DMS CLocate::convertPointDMS( const CLocate::POINT_Dd source )
{
     return convertPointDMS(convertPointDMSd(convertPointDMd(source)));
}


CLocate::POINT_DMSd CLocate::convertPointDMSd( const CLocate::POINT_Dd source )
{
     return convertPointDMSd(convertPointDMd(source));
}


long double CLocate::getDistance( const CLocate::COORDINATES_XYZ s , const CLocate::COORDINATES_XYZ d )
{
     return sqrt( (s.x - d.x)*(s.x - d.x) + (s.y - d.y)*(s.y - d.y) + (s.z - d.z)*(s.z - d.z) );
}


long double CLocate::getDistance( const CLocate::COORDINATES_Dd s , const CLocate::COORDINATES_Dd d )
{
     return getDistance(s.latitude,s.longitude,d.latitude,d.longitude,s.altitude,d.altitude);
}


long double CLocate::getDistance( const CLocate::COORDINATES_DMd s , const CLocate::COORDINATES_DMd d )
{
     return getDistance(s.latitude,s.longitude,d.latitude,d.longitude,s.altitude,d.altitude);
}


long double CLocate::getDistance( const CLocate::COORDINATES_DMSd s , const CLocate::COORDINATES_DMSd d )
{
     return getDistance(s.latitude,s.longitude,d.latitude,d.longitude,s.altitude,d.altitude);
}


long double CLocate::getDistance( const CLocate::COORDINATES_DMS s , const CLocate::COORDINATES_DMS d )
{
     return getDistance(s.latitude,s.longitude,d.latitude,d.longitude,s.altitude,d.altitude);
}


//Le calcul avec des altitudes différentes est une approximation.
long double CLocate::getDistance( const CLocate::POINT_Dd s_lat , const CLocate::POINT_Dd s_long , const CLocate::POINT_Dd d_lat , const CLocate::POINT_Dd d_long , const double s_alt , const double d_alt )
{
     long double distance = ((EARTH_R) * (PI/2 - asin( sin(DEGtoRAD(d_lat.d)) * sin(DEGtoRAD(s_lat.d)) + cos(DEGtoRAD(d_long.d) - DEGtoRAD(s_long.d)) * cos(DEGtoRAD(d_lat.d)) * cos(DEGtoRAD(s_lat.d)))));
     if ( s_alt != d_alt )
          distance = sqrt( distance*distance + (s_alt - d_alt)*(s_alt - d_alt) );
     
     return distance;
}


long double CLocate::getDistance( const CLocate::POINT_DMd s_lat , const CLocate::POINT_DMd s_long , const CLocate::POINT_DMd d_lat , const CLocate::POINT_DMd d_long , const double s_alt , const double d_alt )
{
     return getDistance(convertPointDd(s_lat),convertPointDd(s_long),convertPointDd(d_lat),convertPointDd(d_long),s_alt,d_alt);
}


long double CLocate::getDistance( const CLocate::POINT_DMSd s_lat , const CLocate::POINT_DMSd s_long , const CLocate::POINT_DMSd d_lat , const CLocate::POINT_DMSd d_long , const double s_alt , const double d_alt )
{
     return getDistance(convertPointDd(s_lat),convertPointDd(s_long),convertPointDd(d_lat),convertPointDd(d_long),s_alt,d_alt);
}


long double CLocate::getDistance( const CLocate::POINT_DMS s_lat , const CLocate::POINT_DMS s_long , const CLocate::POINT_DMS d_lat , const CLocate::POINT_DMS d_long , const double s_alt , const double d_alt )
{
     return getDistance(convertPointDd(s_lat),convertPointDd(s_long),convertPointDd(d_lat),convertPointDd(d_long),s_alt,d_alt);
}


long double CLocate::getDistance( const CLocate::COORDINATE s , const CLocate::COORDINATE d , const CLocate::ELLIPSOID e )
{
     COORDINATE temp;
     if ( s.Type != d.Type )
          temp = CLocate::convertCoordinate( d , s.Type );
     else
          temp = d;
     
     switch( s.Type )
     {
          case COORD_XYZ:
               return CLocate::getDistance( s.Coord.XYZ , d.Coord.XYZ );
          case COORD_Dd:
               return CLocate::getDistance( s.Coord.Dd , d.Coord.Dd );
          case COORD_DMd:
               return CLocate::getDistance( s.Coord.DMd , d.Coord.DMd );
          case COORD_DMSd:
               return CLocate::getDistance( s.Coord.DMSd , d.Coord.DMSd );
          case COORD_DMS:
               return CLocate::getDistance( s.Coord.DMS , d.Coord.DMS );
          default:
               return 0;
     }
}


CLocate::COORDINATE CLocate::convertCoordinate( const CLocate::COORDINATE coord_src , const CLocate::COORD_TYPE type_dst )
{
     if ( coord_src.Type == type_dst)
          return coord_src;
     
     COORDINATE temp;
     temp.Coord = CLocate::convertCoordinates(coord_src.Coord,coord_src.Type,type_dst,coord_src.ellipsoid );
     temp.Type = type_dst;
     return temp;
}


CLocate::COORDINATES CLocate::convertCoordinates( const CLocate::COORDINATES coord_src , const CLocate::COORD_TYPE type_src , const CLocate::COORD_TYPE type_dest , const ELLIPSOID ellipsoid_ )
{
     COORDINATES temp;
     memset( &temp,0,sizeof(COORDINATES));
     
     if ( type_src == COORD_unset || type_src == COORD_default || type_dest == COORD_unset || type_dest == COORD_default )
          return temp;
     
     if ( type_src == type_dest )
          return coord_src;
     
     if ( (type_src == COORD_XYZ || type_dest == COORD_XYZ) && ellipsoid_ == ELLIPSOID_unset )
          return temp;
     
     switch ( type_dest )
     {
          case COORD_Dd:
               if ( type_src == COORD_DMd )
                    temp.Dd = CLocate::convertCoordDd(coord_src.DMd);
               if ( type_src == COORD_DMSd )
                    temp.Dd = CLocate::convertCoordDd(coord_src.DMSd);
               if ( type_src == COORD_DMS )
                    temp.Dd = CLocate::convertCoordDd(coord_src.DMS);
               if ( type_src == COORD_XYZ )
                    temp.Dd = CLocate::convertCoordDd(coord_src.XYZ,ellipsoid_);
               break;
          case COORD_DMd:
               if ( type_src == COORD_Dd )
                    temp.DMd = CLocate::convertCoordDMd(coord_src.Dd);
               if ( type_src == COORD_DMSd )
                    temp.DMd = CLocate::convertCoordDMd(coord_src.DMSd);
               if ( type_src == COORD_DMS )
                    temp.DMd = CLocate::convertCoordDMd(coord_src.DMS);
               if ( type_src == COORD_XYZ )
                    temp.DMd = CLocate::convertCoordDMd(coord_src.XYZ,ellipsoid_);
               break;
          case COORD_DMSd:
               if ( type_src == COORD_Dd )
                    temp.DMSd = CLocate::convertCoordDMSd(coord_src.Dd);
               if ( type_src == COORD_DMd )
                    temp.DMSd = CLocate::convertCoordDMSd(coord_src.DMd);
               if ( type_src == COORD_DMS )
                    temp.DMSd = CLocate::convertCoordDMSd(coord_src.DMS);
               if ( type_src == COORD_XYZ )
                    temp.DMSd = CLocate::convertCoordDMSd(coord_src.XYZ,ellipsoid_);
               break;
          case COORD_DMS:
               if ( type_src == COORD_Dd )
                    temp.DMS = CLocate::convertCoordDMS(coord_src.Dd);
               if ( type_src == COORD_DMd )
                    temp.DMS = CLocate::convertCoordDMS(coord_src.DMd);
               if ( type_src == COORD_DMSd )
                    temp.DMS = CLocate::convertCoordDMS(coord_src.DMSd);
               if ( type_src == COORD_XYZ )
                    temp.DMS = CLocate::convertCoordDMS(coord_src.XYZ,ellipsoid_);
               break;
          case COORD_XYZ:
               if ( type_src == COORD_Dd )
                    temp.XYZ = CLocate::convertCoordXYZ(coord_src.Dd,ellipsoid_);
               if ( type_src == COORD_DMd )
                    temp.XYZ = CLocate::convertCoordXYZ(coord_src.DMd,ellipsoid_);
               if ( type_src == COORD_DMSd )
                    temp.XYZ = CLocate::convertCoordXYZ(coord_src.DMSd,ellipsoid_);
               if ( type_src == COORD_DMS )
                    temp.XYZ = CLocate::convertCoordXYZ(coord_src.DMS,ellipsoid_);
               break;
          default :
               return temp;
     }
     
     return temp;
}


std::string CLocate::getEllipsoidName( const ELLIPSOID value )
{
     switch(value)
     {
          case ELLIPSOID_unset:
               return "";
               break;
          case ELLIPSOID_airy:
               return "Airy ellipsoid 1830";
               break;
          case ELLIPSOID_airy_mod:
               return "Modified Airy";
               break;
          case ELLIPSOID_apl1965:
               return "Appl. Physics. 1965";
               break;
          case ELLIPSOID_andrae1876:
               return "Andrae 1876 (Denmark, Iceland)";
               break;
          case ELLIPSOID_australian:
               return "Australian National 1965";
               break;
          case ELLIPSOID_bessel:
               return "Bessel ellipsoid 1841";
               break;
          case ELLIPSOID_bessel_nam:
               return "Bessel 1841 (Namibia)";
               break;
          case ELLIPSOID_clarke1858a:
               return "Clarke ellipsoid 1858 1st";
               break;
          case ELLIPSOID_clarke1858b:
               return "Clarke ellipsoid 1858 2nd";
               break;
          case ELLIPSOID_clarke1866:
               return "Clarke ellipsoid 1866";
               break;
          case ELLIPSOID_clarke1880:
               return "Clarke ellipsoid 1880";
               break;
          case ELLIPSOID_clarke1880m:
               return "Clarke ellipsoid 1880 (modified)";
               break;
          case ELLIPSOID_cpm1799:
               return "Comm. des Poids et Mesures 1799";
               break;
          case ELLIPSOID_delambre:
               return "Delambre 1810 (Belgium)";
               break;
          case ELLIPSOID_engelis:
               return "Engelis 1985";
               break;
          case ELLIPSOID_everest1830:
               return "Everest 1830";
               break;
          case ELLIPSOID_everest1848:
               return "Everest 1948";
               break;
          case ELLIPSOID_everest1856:
               return "Everest 1956";
               break;
          case ELLIPSOID_everest1869:
               return "Everest 1969";
               break;
          case ELLIPSOID_everest_ss:
               return "Everest (Sabah and Sarawak)";
               break;
          case ELLIPSOID_fisher1960:
               return "Fisher 1960 (Mercury Datum)";
               break;
          case ELLIPSOID_fisher1960m:
               return "Modified Fisher 1960";
               break;
          case ELLIPSOID_fischer1968:
               return "Fischer 1968";
               break;
          case ELLIPSOID_grs67:
               return "GRS 67 (IUGG 1967)";
               break;
          case ELLIPSOID_grs80:
               return "Geodetic Reference System 1980";
               break;
          case ELLIPSOID_hayford:
               return "Hayford 1909 (International)";
               break;
          case ELLIPSOID_helmert:
               return "Helmert ellipsoid 1906";
               break;
          case ELLIPSOID_hough:
               return "Hough";
               break;
          case ELLIPSOID_iau76:
               return "IAU 1976";
               break;
          case ELLIPSOID_international:
               return "International 1924 (Hayford 1909)";
               break;
          case ELLIPSOID_kaula:
               return "Kaula 1961";
               break;
          case ELLIPSOID_krassovski:
               return "Krassovski ellipsoid 1940";
               break;
          case ELLIPSOID_lerch:
               return "Lerch 1979";
               break;
          case ELLIPSOID_mprts:
               return "Maupertius 1738";
               break;
          case ELLIPSOID_mercury:
               return "Mercury spheroid 1960";
               break;
          case ELLIPSOID_merit:
               return "MERIT 1983";
               break;
          case ELLIPSOID_new_intl:
               return "New International 1967";
               break;
          case ELLIPSOID_nwl1965:
               return "Naval Weapons Lab., 1965";
               break;
          case ELLIPSOID_plessis:
               return "Plessis 1817 (France)";
               break;
          case ELLIPSOID_se_asia:
               return "Southeast Asia";
               break;
          case ELLIPSOID_sgs85:
               return "Soviet Geodetic System 85";
               break;
          case ELLIPSOID_schott:
               return "Schott 1900 spheroid";
               break;
          case ELLIPSOID_sa1969:
               return "South American Spheroid 1969";
               break;
          case ELLIPSOID_walbeck:
               return "Walbeck";
               break;
          case ELLIPSOID_wgs60:
               return "WGS 60";
               break;
          case ELLIPSOID_wgs66:
               return "WGS 66";
               break;
          case ELLIPSOID_wgs72:
               return "WGS 72";
               break;
          case ELLIPSOID_wgs84:
               return "World Geodetic System 1984";
               break;
          default :
               return "";
               break;
     }
}


double CLocate::M( const CLocate::ELLIPSOID_CONST ellipsoid , const double b )
{
     double w = CLocate::W( ellipsoid , b );
     return ellipsoid.AIme2/(w*w*w);
}


double CLocate::N( const CLocate::ELLIPSOID_CONST ellipsoid , const double b )
{
     return ellipsoid.A/CLocate::W( ellipsoid , b );
}


double CLocate::W( const CLocate::ELLIPSOID_CONST ellipsoid , const double b )
{
     double p = sin(b);
     return sqrt(1 - ellipsoid.e2*p*p);
}


double CLocate::V( const CLocate::ELLIPSOID_CONST ellipsoid , const double b )
{
     double p = cos(b);
     return sqrt(1 + ellipsoid.e22*p*p);
}


double CLocate::F( const CLocate::ELLIPSOID_CONST ellipsoid , const double b )
{
     return sqrt(1 + ellipsoid.n*cos(b+b) + ellipsoid.n*ellipsoid.n);
}


CLocate::ELLIPSOID_CONST CLocate::getEllipsoidConst( CLocate::ELLIPSOID value )
{
     ELLIPSOID_CONST temp;
     temp.A = 0;
     temp.B = 0;
     temp.ff = 0;
     temp.n = 0;
     temp.e2 = 0;
     temp.e22 = 0;
     temp.Ime2 = 0;
     temp.Ipe22 = 0;
     temp.AIme2 = 0;
     temp.AB = 0;

     switch( value )
     {
          case CLocate::ELLIPSOID_airy :
               CLocate::updateEllipsoidConst( &temp , 6377563.396, 6356256.910 ,  0 ,  0 );
               break;
          case CLocate::ELLIPSOID_airy_mod :
               CLocate::updateEllipsoidConst( &temp , 6377340.189, 6356034.446 ,  0 ,  0 );
               break;
          case CLocate::ELLIPSOID_apl1965 :
               CLocate::updateEllipsoidConst( &temp , 6378137 ,  0 ,  0 , 298.25 );
               break;
          case CLocate::ELLIPSOID_andrae1876 :
               CLocate::updateEllipsoidConst( &temp , 6377104.43 ,  0 ,  0 , 300.0 );
               break;
          case CLocate::ELLIPSOID_australian :
               CLocate::updateEllipsoidConst( &temp , 6378160 ,  0 ,  0 , 298.25 );
               break;
          case CLocate::ELLIPSOID_bessel :
               CLocate::updateEllipsoidConst( &temp , 6377397.15508, 6356078.96290 ,  0 ,  0 );
               break;
          case CLocate::ELLIPSOID_bessel_nam :
               CLocate::updateEllipsoidConst( &temp , 6377483.865 ,  0 ,  0 , 299.1528128 );
               break;
          case CLocate::ELLIPSOID_clarke1858a :
               CLocate::updateEllipsoidConst( &temp , 6378361, 6356685 ,  0 ,  0 );
               break;
          case CLocate::ELLIPSOID_clarke1858b :
               CLocate::updateEllipsoidConst( &temp , 6378558, 6355810 ,  0 ,  0 );
               break;
          case CLocate::ELLIPSOID_clarke1866 :
               CLocate::updateEllipsoidConst( &temp , 6378206.4, 6356583.8 ,  0 ,  0 );
               break;
          case CLocate::ELLIPSOID_clarke1880 :
               CLocate::updateEllipsoidConst( &temp , 6378316, 6356582 ,  0 ,  0 );
               break;
          case CLocate::ELLIPSOID_clarke1880m :
               CLocate::updateEllipsoidConst( &temp , 6378249.145 ,  0 ,  0 , 293.4663 );
               break;
          case CLocate::ELLIPSOID_cpm1799 :
               CLocate::updateEllipsoidConst( &temp , 6375738.7 ,  0 ,  0 , 334.29 );
               break;
          case CLocate::ELLIPSOID_delambre :
               CLocate::updateEllipsoidConst( &temp , 6376428 ,  0 ,  0 , 311.5 );
               break;
          case CLocate::ELLIPSOID_engelis :
               CLocate::updateEllipsoidConst( &temp , 6378136.05 ,  0 ,  0 , 298.2566 );
               break;
          case CLocate::ELLIPSOID_everest1830 :
               CLocate::updateEllipsoidConst( &temp , 6377276.345 ,  0 ,  0 , 300.8017 );
               break;
          case CLocate::ELLIPSOID_everest1848 :
               CLocate::updateEllipsoidConst( &temp , 6377304.063 ,  0 ,  0 , 300.8017 );
               break;
          case CLocate::ELLIPSOID_everest1856 :
               CLocate::updateEllipsoidConst( &temp , 6377301.243 ,  0 ,  0 , 300.8017 );
               break;
          case CLocate::ELLIPSOID_everest1869 :
               CLocate::updateEllipsoidConst( &temp , 6377295.664 ,  0 ,  0 , 300.8017 );
               break;
          case CLocate::ELLIPSOID_everest_ss :
               CLocate::updateEllipsoidConst( &temp , 6377298.556 ,  0 ,  0 , 300.8017 );
               break;
          case CLocate::ELLIPSOID_fisher1960 :
               CLocate::updateEllipsoidConst( &temp , 6378166 ,  0 ,  0 , 298.3 );
               break;
          case CLocate::ELLIPSOID_fisher1960m :
               CLocate::updateEllipsoidConst( &temp , 6378155 ,  0 ,  0 , 298.3 );
               break;
          case CLocate::ELLIPSOID_fischer1968 :
               CLocate::updateEllipsoidConst( &temp , 6378150 ,  0 ,  0 , 298.3 );
               break;
          case CLocate::ELLIPSOID_grs67 :
               CLocate::updateEllipsoidConst( &temp , 6378160 ,  0 ,  0 , 298.2471674270 );
               break;
          case CLocate::ELLIPSOID_grs80 :
               CLocate::updateEllipsoidConst( &temp , 6378137 ,  0 ,  0 , 298.257222101 );
               break;
          case CLocate::ELLIPSOID_hayford :
               CLocate::updateEllipsoidConst( &temp , 6378388 ,  0 ,  0 , 297 );
               break;
          case CLocate::ELLIPSOID_helmert :
               CLocate::updateEllipsoidConst( &temp , 6378200 ,  0 ,  0 , 298.3 );
               break;
          case CLocate::ELLIPSOID_hough :
               CLocate::updateEllipsoidConst( &temp , 6378270 ,  0 ,  0 , 297 );
               break;
          case CLocate::ELLIPSOID_iau76 :
               CLocate::updateEllipsoidConst( &temp , 6378140 ,  0 ,  0 , 298.257 );
               break;
          case CLocate::ELLIPSOID_international :
               CLocate::updateEllipsoidConst( &temp , 6378388 ,  0 ,  0 , 297 );
               break;
          case CLocate::ELLIPSOID_kaula :
               CLocate::updateEllipsoidConst( &temp , 6378163 ,  0 ,  0 , 298.24 );
               break;
          case CLocate::ELLIPSOID_krassovski :
               CLocate::updateEllipsoidConst( &temp , 6378245 ,  0 ,  0 , 298.3 );
               break;
          case CLocate::ELLIPSOID_lerch :
               CLocate::updateEllipsoidConst( &temp , 6378139 ,  0 ,  0 , 298.257 );
               break;
          case CLocate::ELLIPSOID_mprts :
               CLocate::updateEllipsoidConst( &temp , 6397300 ,  0 ,  0 , 191.0 );
               break;
          case CLocate::ELLIPSOID_mercury :
               CLocate::updateEllipsoidConst( &temp , 6378166 ,  0 ,  0 , 298.3 );
               break;
          case CLocate::ELLIPSOID_merit :
               CLocate::updateEllipsoidConst( &temp , 6378137 ,  0 ,  0 , 298.257 );
               break;
          case CLocate::ELLIPSOID_new_intl :
               CLocate::updateEllipsoidConst( &temp , 6378157.5, 6356772.2 ,  0 ,  0 );
               break;
          case CLocate::ELLIPSOID_nwl1965 :
               CLocate::updateEllipsoidConst( &temp , 6378145 ,  0 ,  0 , 298.25 );
               break;
          case CLocate::ELLIPSOID_plessis :
               CLocate::updateEllipsoidConst( &temp , 6376523, 6355863 ,  0 ,  0 );
               break;
          case CLocate::ELLIPSOID_se_asia :
               CLocate::updateEllipsoidConst( &temp , 6378155, 6356773.3205 ,  0 ,  0 );
               break;
          case CLocate::ELLIPSOID_sgs85 :
               CLocate::updateEllipsoidConst( &temp , 6378136 ,  0 ,  0 , 298.257 );
               break;
          case CLocate::ELLIPSOID_schott :
               CLocate::updateEllipsoidConst( &temp , 6378157 ,  0 ,  0 , 304.5 );
               break;
          case CLocate::ELLIPSOID_sa1969 :
               CLocate::updateEllipsoidConst( &temp , 6378160 ,  0 ,  0 , 298.25 );
               break;
          case CLocate::ELLIPSOID_walbeck :
               CLocate::updateEllipsoidConst( &temp , 6376896, 6355834.8467 ,  0 ,  0 );
               break;
          case CLocate::ELLIPSOID_wgs60 :
               CLocate::updateEllipsoidConst( &temp , 6378165 ,  0 ,  0 , 298.3 );
               break;
          case CLocate::ELLIPSOID_wgs66 :
               CLocate::updateEllipsoidConst( &temp , 6378145 ,  0 ,  0 , 298.25 );
               break;
          case CLocate::ELLIPSOID_wgs72 :
               CLocate::updateEllipsoidConst( &temp , 6378135 ,  0 ,  0 , 298.26 );
               break;
          case CLocate::ELLIPSOID_wgs84 :
               CLocate::updateEllipsoidConst( &temp , 6378137 ,  0 ,  0 , 298.257223563 );
               break;
          default :
               break;
     }

     return temp;
}


void CLocate::updateEllipsoidConst( CLocate::ELLIPSOID_CONST* ellipsoid , const double pa , const double pb , const double pf , const double pf1 )
{
     if ( ellipsoid == NULL )
          return;

     ellipsoid->A = pa;
     if (pb)
     {
          ellipsoid->B  = pb;
          ellipsoid->ff = (ellipsoid->A - ellipsoid->B)/ellipsoid->A;
     }
     else if (pf)
     {
          ellipsoid->ff = pf;
          ellipsoid->B  = ellipsoid->A*(1 - ellipsoid->ff);
     }
     else
     {
          ellipsoid->ff = 1/pf1;
          ellipsoid->B  = ellipsoid->A*(1 - ellipsoid->ff);
     }

     double a2=ellipsoid->A*ellipsoid->A, b2=ellipsoid->B*ellipsoid->B;

     ellipsoid->n   = (ellipsoid->A - ellipsoid->B)/(ellipsoid->A + ellipsoid->B);
     ellipsoid->e2  = (a2 - b2)/a2;
     ellipsoid->e22 = (a2 - b2)/b2;

     ellipsoid->Ime2  = 1 - ellipsoid->e2;
     ellipsoid->Ipe22 = 1 + ellipsoid->e22;
     ellipsoid->AIme2 = ellipsoid->A*ellipsoid->Ime2;
     ellipsoid->AB    = ellipsoid->A/ellipsoid->B;
}


CLocate::COORDINATES_XYZ CLocate::convertCoordXYZ( const CLocate::COORDINATES_Dd coord , const CLocate::ELLIPSOID ellipsoid )
{
     COORDINATES_XYZ temp;
     temp.x = 0;
     temp.y = 0;
     temp.z = 0;


     if ( ellipsoid == ELLIPSOID_unset )
          return temp;

     ELLIPSOID_CONST ELLIPSOID_const = CLocate::getEllipsoidConst(ellipsoid);


     const double sb = sin( DEGtoRAD(coord.latitude.d) );
     const double cb = cos( DEGtoRAD(coord.latitude.d) );
     const double sl = sin( DEGtoRAD(coord.longitude.d) );
     const double cl = cos( DEGtoRAD(coord.longitude.d) );
     const double nn = CLocate::N( ELLIPSOID_const , DEGtoRAD(coord.latitude.d) );
     const double n1 = nn*ELLIPSOID_const.Ime2 + coord.altitude;
     const double nh = nn + coord.altitude;

     temp.x = nh*cb*cl;
     temp.y = nh*cb*sl;
     temp.z = n1*sb;
     return temp;
}


CLocate::COORDINATES_XYZ CLocate::convertCoordXYZ( const CLocate::COORDINATES_DMd coord , const CLocate::ELLIPSOID ellipsoid )
{
     return CLocate::convertCoordXYZ( CLocate::convertCoordDd( coord ) , ellipsoid );
}


CLocate::COORDINATES_XYZ CLocate::convertCoordXYZ( const CLocate::COORDINATES_DMSd coord , const CLocate::ELLIPSOID ellipsoid )
{
     return CLocate::convertCoordXYZ( CLocate::convertCoordDd( coord ) , ellipsoid );
}


CLocate::COORDINATES_XYZ CLocate::convertCoordXYZ( const CLocate::COORDINATES_DMS coord , const CLocate::ELLIPSOID ellipsoid )
{
     return CLocate::convertCoordXYZ( CLocate::convertCoordDd( coord ) , ellipsoid );
}


CLocate::COORDINATES_Dd CLocate::convertCoordDd( const CLocate::COORDINATES_XYZ coord , const CLocate::ELLIPSOID ellipsoid )
{
     COORDINATES_Dd temp;
     temp.latitude.d = 0;
     temp.longitude.d = 0;
     temp.altitude = 0;

     CLocate::COORDINATES_XYZ coord2 = coord;

     if ( ellipsoid == ELLIPSOID_unset )
          return temp;

     ELLIPSOID_CONST ELLIPSOID_const = CLocate::getEllipsoidConst(ellipsoid);
     double t, tan_u, cos2_u, cos_u, sin2_u, sin_u;

     temp.longitude.d = atan2( coord2.y , coord2.x );

     coord2.x = fabs(coord2.x);
     coord2.y = fabs(coord2.y);
     if ( coord2.x > coord2.y )
     {
          t = coord2.y/coord2.x;
          coord2.x = coord2.x * sqrt(1 + t*t);
     }
     else if (coord2.y)
     {
          t = coord2.x/coord2.y;
          coord2.x = coord2.y * sqrt(1 + t*t);
     }
     else
     {
          temp.longitude.d = 0;
          if (coord2.z > 0)
          {
               temp.latitude.d = M_PI/2;
               temp.altitude = coord2.z - ELLIPSOID_const.Ime2*CLocate::N(ELLIPSOID_const,temp.latitude.d);
          }
          else
          {
               temp.latitude.d = -M_PI/2;
               temp.altitude = -coord2.z - ELLIPSOID_const.Ime2*CLocate::N(ELLIPSOID_const,temp.latitude.d);
          }
          return temp;
     }

     tan_u  = ELLIPSOID_const.AB*coord2.z/coord2.x;
     cos2_u = 1/(1 + tan_u*tan_u);
     cos_u  = sqrt(cos2_u);
     sin2_u = 1 - cos2_u;
     sin_u  = sqrt(sin2_u);
     if (coord2.z < 0) sin_u = -sin_u;

     temp.latitude.d = atan2(coord2.z + ELLIPSOID_const.e22*ELLIPSOID_const.B*sin2_u*sin_u, coord2.x - ELLIPSOID_const.e2*ELLIPSOID_const.A*cos2_u*cos_u);

     if (coord2.x > fabs(coord2.z))
          temp.altitude = coord2.x/cos(temp.latitude.d) - CLocate::N(ELLIPSOID_const,temp.latitude.d);
     else
          temp.altitude = coord2.z/sin(temp.latitude.d) - ELLIPSOID_const.Ime2*CLocate::N(ELLIPSOID_const,temp.latitude.d);

     temp.latitude.d = RADtoDEG( temp.latitude.d );
     temp.longitude.d = RADtoDEG( temp.longitude.d );

     return temp;
}


CLocate::COORDINATES_DMd CLocate::convertCoordDMd( const CLocate::COORDINATES_XYZ coord , const CLocate::ELLIPSOID ellipsoid )
{
     return CLocate::convertCoordDMd(CLocate::convertCoordDd( coord , ellipsoid ));
}


CLocate::COORDINATES_DMSd CLocate::convertCoordDMSd( const CLocate::COORDINATES_XYZ coord , const CLocate::ELLIPSOID ellipsoid )
{
     return CLocate::convertCoordDMSd(CLocate::convertCoordDd( coord , ellipsoid ));
}


CLocate::COORDINATES_DMS CLocate::convertCoordDMS( const CLocate::COORDINATES_XYZ coord , const CLocate::ELLIPSOID ellipsoid )
{
     return CLocate::convertCoordDMS(CLocate::convertCoordDd( coord , ellipsoid ));
}


std::string CLocate::getCoordinatesAsString( const CLocate::COORDINATES coord , const CLocate::COORD_TYPE type , const int i )
{
     std::ostringstream result;

     if ( type == CLocate::COORD_unset )
          return "";

     switch ( type )
     {
          case COORD_XYZ :
               result << CLocate::addTab(i) << coord.XYZ.x << ";" << coord.XYZ.y << ";" << coord.XYZ.z;
               break;
          case COORD_Dd :
               result << CLocate::addTab(i) << coord.Dd.latitude.d << ";" << coord.Dd.longitude.d << ";" << coord.Dd.altitude;
               break;
          case COORD_DMd :
               result << CLocate::addTab(i) << coord.DMd.latitude.d << "," << coord.DMd.latitude.m << ";" << coord.DMd.longitude.d << "," << coord.DMd.longitude.m << ";" << coord.DMd.altitude;
               break;
          case COORD_DMSd :
               result << CLocate::addTab(i) << coord.DMSd.latitude.d << "," << coord.DMSd.latitude.m << "," << coord.DMSd.latitude.s << ";" << coord.DMSd.longitude.d << "," << coord.DMSd.longitude.m << "," << coord.DMSd.longitude.s << ";" << coord.DMSd.altitude;
               break;
          case COORD_DMS :
               result << CLocate::addTab(i) << coord.DMS.latitude.d << ","<< coord.DMS.latitude.m << "," << coord.DMS.latitude.s << ";"  << coord.DMS.longitude.d << "," << coord.DMS.longitude.m << "," << coord.DMS.longitude.s << ";" << coord.DMS.altitude;
               break;
          default :
               return CLocate::addTab(i);
     }

     return result.str();
}


std::string CLocate::getCoordinatesAsXML( const CLocate::COORDINATES coord , const CLocate::COORD_TYPE type , const int i )
{
     std::ostringstream result;
     
     if ( type == CLocate::COORD_unset )
          return "";

     switch ( type )
     {
          case COORD_XYZ :
               result << CLocate::addTab(i) << "<xyz>\n";
               result << CLocate::addTab(i) << "\t<x>" << coord.XYZ.x << "</x>\n";
               result << CLocate::addTab(i) << "\t<y>" << coord.XYZ.y << "</y>\n";
               result << CLocate::addTab(i) << "\t<z>" << coord.XYZ.z << "</z>\n";
               result << CLocate::addTab(i) << "</xyz>";
               break;
          case COORD_Dd :
               result << CLocate::addTab(i) << "<dd>\n";
               result << CLocate::addTab(i) << "\t<lat>\n";
               result << CLocate::addTab(i) << "\t\t<d>" << coord.Dd.latitude.d << "</d>\n";
               result << CLocate::addTab(i) << "\t</lat>\n";
               result << CLocate::addTab(i) << "\t<long>\n";
               result << CLocate::addTab(i) << "\t\t<d>" << coord.Dd.longitude.d << "</d>\n";
               result << CLocate::addTab(i) << "\t</long>\n";
               result << CLocate::addTab(i) << "\t<alt>" << coord.Dd.altitude << "</alt>\n";
               result << CLocate::addTab(i) << "</dd>";
               break;
          case COORD_DMd :
               result << CLocate::addTab(i) << "<dmd>\n";
               result << CLocate::addTab(i) << "\t<lat>\n";
               result << CLocate::addTab(i) << "\t\t<d>" << coord.DMd.latitude.d << "</d>\n";
               result << CLocate::addTab(i) << "\t\t<m>" << coord.DMd.latitude.m << "</m>\n";
               result << CLocate::addTab(i) << "\t</lat>\n";
               result << CLocate::addTab(i) << "\t<long>\n";
               result << CLocate::addTab(i) << "\t\t<d>" << coord.DMd.longitude.d << "</d>\n";
               result << CLocate::addTab(i) << "\t\t<m>" << coord.DMd.longitude.m << "</m>\n";
               result << CLocate::addTab(i) << "\t</long>\n";
               result << CLocate::addTab(i) << "\t<alt>" << coord.DMd.altitude << "</alt>\n";
               result << CLocate::addTab(i) << "</dmd>";
               break;
          case COORD_DMSd :
               result << CLocate::addTab(i) << "<dmsd>\n";
               result << CLocate::addTab(i) << "\t<lat>\n";
               result << CLocate::addTab(i) << "\t\t<d>" << coord.DMSd.latitude.d << "</d>\n";
               result << CLocate::addTab(i) << "\t\t<m>" << coord.DMSd.latitude.m << "</m>\n";
               result << CLocate::addTab(i) << "\t\t<s>" << coord.DMSd.latitude.s << "</s>\n";
               result << CLocate::addTab(i) << "\t</lat>\n";
               result << CLocate::addTab(i) << "\t<long>\n";
               result << CLocate::addTab(i) << "\t\t<d>" << coord.DMSd.longitude.d << "</d>\n";
               result << CLocate::addTab(i) << "\t\t<m>" << coord.DMSd.longitude.m << "</m>\n";
               result << CLocate::addTab(i) << "\t\t<s>" << coord.DMSd.longitude.s << "</s>\n";
               result << CLocate::addTab(i) << "\t</long>\n";
               result << CLocate::addTab(i) << "\t<alt>" << coord.DMSd.altitude << "</alt>\n";
               result << CLocate::addTab(i) << "</dmsd>";
               break;
          case COORD_DMS :
               result << CLocate::addTab(i) << "<dms>\n";
               result << CLocate::addTab(i) << "\t<lat>\n";
               result << CLocate::addTab(i) << "\t\t<d>" << coord.DMS.latitude.d << "</d>\n";
               result << CLocate::addTab(i) << "\t\t<m>" << coord.DMS.latitude.m << "</m>\n";
               result << CLocate::addTab(i) << "\t\t<s>" << coord.DMS.latitude.s << "</s>\n";
               result << CLocate::addTab(i) << "\t</lat>\n";
               result << CLocate::addTab(i) << "\t<long>\n";
               result << CLocate::addTab(i) << "\t\t<d>" << coord.DMS.longitude.d << "</d>\n";
               result << CLocate::addTab(i) << "\t\t<m>" << coord.DMS.longitude.m << "</m>\n";
               result << CLocate::addTab(i) << "\t\t<s>" << coord.DMS.longitude.s << "</s>\n";
               result << CLocate::addTab(i) << "\t</long>\n";
               result << CLocate::addTab(i) << "\t<alt>" << coord.DMS.altitude << "</alt>\n";
               result << CLocate::addTab(i) << "</dms>";
               break;
          default :
               return CLocate::addTab(i);
     }

     return result.str();
}



void CLocate::setCoordinateType( const CLocate::COORD_TYPE coord )
{
     if ( coord == COORD_unset || coord == COORD_default || this->data.Type == coord )
          return;
     
     if ( this->data.Type == COORD_unset )
     {
          this->data.Type = coord;
          return;
     }
     
     if ( this->data.Type == COORD_XYZ && this->data.ellipsoid == ELLIPSOID_unset )
          return;
     
     this->data = convertCoordinate( this->data , coord );
}


CLocate::COORD_TYPE CLocate::getCoordinateType( void ) const
{
     return this->data.Type;
}


std::string CLocate::getDataAsString( const CLocate::COORD_TYPE coord, const int i ) const
{
     if ( coord == COORD_unset )
          return "";
     
     if ( coord == this->data.Type || coord == COORD_default )
          return this->getCoordinatesAsString( this->data.Coord , this->data.Type , i );
     
     COORDINATE temp = this->convertCoordinate( this->data , coord );
     return this->getCoordinatesAsString( temp.Coord , coord , i );
}


std::string CLocate::getDataAsXML( const CLocate::COORD_TYPE coord, const int i ) const
{
     if ( coord == COORD_unset )
          return "";
     
     if ( coord == this->data.Type || coord == COORD_default )
          return this->getCoordinatesAsXML( this->data.Coord , this->data.Type , i );
     
     COORDINATE temp = this->convertCoordinate( this->data , coord );
     return this->getCoordinatesAsXML( temp.Coord , coord , i );
}


bool CLocate::getDataAsBin( void* buffer , const CLocate::COORD_TYPE coord ) const
{
     if ( coord == COORD_unset || buffer == NULL )
          return false;
     
     if ( coord == this->data.Type || coord == COORD_default )
     {
          memcpy( buffer , &this->data , this->getDataSizeForBin() );
          return true;
     }
     
     COORDINATE temp = this->convertCoordinate( this->data , coord );
     memcpy( buffer , &temp , this->getDataSizeForBin() );
     
     return true;
}


std::string CLocate::addTab( const int i )
{
     if ( i == 0 )
          return "";
     std::ostringstream result;
     
     for ( int cptr = 0 ; cptr < i ; cptr++ )
          result << "\t";
     
     return result.str();
}


void CLocate::setEllipsoid( const CLocate::ELLIPSOID ellipsoid_ )
{
     this->data.ellipsoid = ellipsoid_;
}


CLocate::ELLIPSOID CLocate::getEllipsoid( void ) const
{
     return this->data.ellipsoid;
}


bool CLocate::setDataFromBin( const void* buffer )
{
     if ( buffer == NULL )
          return false;
     
     memcpy( &this->data , buffer , sizeof(COORDINATE) );
     return true;
}


bool CLocate::setDataFromObject( const CLocate &object )
{
     if( object.getDataAsBin( &this->data ) == true )
     {
          this->setEllipsoid( object.getEllipsoid() );
          this->epsilon = object.epsilon;
          return true;
     }
     return false;
}


long double CLocate::getDistance( const CLocate &object ) const
{
     COORDINATE temp;
     object.getDataAsBin( &temp , this->data.Type );
     return CLocate::getDistance( this->data , temp );
}


bool CLocate::getDataFromValue( long double* X , long double* Y , long double* Z ) const
{
     if ( X == NULL || Y == NULL || Z == NULL )
          return false;
     
     if ( this->data.Type == COORD_XYZ )
     {
          *X = this->data.Coord.XYZ.x;
          *Y = this->data.Coord.XYZ.y;
          *Z = this->data.Coord.XYZ.z;
          return true;
     }
     
     COORDINATE temp = this->convertCoordinate( this->data , COORD_XYZ );
     
     *X = temp.Coord.XYZ.x;
     *Y = temp.Coord.XYZ.y;
     *Z = temp.Coord.XYZ.z;
     return true;
}


bool CLocate::getDataFromValue( float* lat_d , float* lon_d , double* alt ) const
{
     if ( lat_d == NULL || lon_d == NULL || alt == NULL )
          return false;
     
     if ( this->data.Type == COORD_Dd )
     {
          *lat_d = this->data.Coord.Dd.latitude.d;
          *lon_d = this->data.Coord.Dd.longitude.d;
          *alt = this->data.Coord.Dd.altitude;
          return true;
     }
     
     COORDINATE temp = this->convertCoordinate( this->data , COORD_Dd );
     
     *lat_d = temp.Coord.Dd.latitude.d;
     *lon_d = temp.Coord.Dd.longitude.d;
     *alt = temp.Coord.Dd.altitude;
     return true;
}


bool CLocate::getDataFromValue( short* lat_d , float* lat_m , short* lon_d , float* lon_m , double* alt ) const
{
     if ( lat_d == NULL || lat_m == NULL || lat_d == NULL || lat_m == NULL || alt == NULL )
          return false;
     
     if ( this->data.Type == COORD_DMd )
     {
          *lat_d = this->data.Coord.DMd.latitude.d;
          *lat_m = this->data.Coord.DMd.latitude.m;
          *lon_d = this->data.Coord.DMd.longitude.d;
          *lon_m = this->data.Coord.DMd.longitude.m;
          *alt = this->data.Coord.DMd.altitude;
          return true;
     }
     
     COORDINATE temp = this->convertCoordinate( this->data , COORD_DMd );
     
     *lat_d = temp.Coord.DMd.latitude.d;
     *lat_m = temp.Coord.DMd.latitude.m;
     *lon_d = temp.Coord.DMd.longitude.d;
     *lon_m = temp.Coord.DMd.longitude.m;
     *alt = temp.Coord.DMd.altitude;
     return true;
}


bool CLocate::getDataFromValue( short* lat_d , short* lat_m , float* lat_s , short* lon_d , short* lon_m , float* lon_s , double* alt ) const
{
     if ( lat_d == NULL || lat_m == NULL || lat_s == NULL || lat_d == NULL || lat_m == NULL || lat_s == NULL || alt == NULL )
          return false;
     
     if ( this->data.Type == COORD_DMSd )
     {
          *lat_d = this->data.Coord.DMSd.latitude.d;
          *lat_m = this->data.Coord.DMSd.latitude.m;
          *lat_s = this->data.Coord.DMSd.latitude.s;
          *lon_d = this->data.Coord.DMSd.longitude.d;
          *lon_m = this->data.Coord.DMSd.longitude.m;
          *lon_s = this->data.Coord.DMSd.longitude.s;
          *alt = this->data.Coord.DMSd.altitude;
          return true;
     }
     
     COORDINATE temp = this->convertCoordinate( this->data , COORD_DMSd );
     
     *lat_d = temp.Coord.DMSd.latitude.d;
     *lat_m = temp.Coord.DMSd.latitude.m;
     *lat_s = temp.Coord.DMSd.latitude.s;
     *lon_d = temp.Coord.DMSd.longitude.d;
     *lon_m = temp.Coord.DMSd.longitude.m;
     *lon_s = temp.Coord.DMSd.longitude.s;
     *alt = temp.Coord.DMSd.altitude;
     return true;
}


bool CLocate::getDataFromValue( short* lat_d , short* lat_m , short* lat_s , short* lon_d , short* lon_m , short* lon_s , double* alt ) const
{
     if ( lat_d == NULL || lat_m == NULL || lat_s == NULL || lat_d == NULL || lat_m == NULL || lat_s == NULL || alt == NULL )
          return false;
     
     if ( this->data.Type == COORD_DMS )
     {
          *lat_d = this->data.Coord.DMS.latitude.d;
          *lat_m = this->data.Coord.DMS.latitude.m;
          *lat_s = this->data.Coord.DMS.latitude.s;
          *lon_d = this->data.Coord.DMS.longitude.d;
          *lon_m = this->data.Coord.DMS.longitude.m;
          *lon_s = this->data.Coord.DMS.longitude.s;
          *alt = this->data.Coord.DMS.altitude;
          return true;
     }
     
     COORDINATE temp = this->convertCoordinate( this->data , COORD_DMS );
     
     *lat_d = temp.Coord.DMS.latitude.d;
     *lat_m = temp.Coord.DMS.latitude.m;
     *lat_s = temp.Coord.DMS.latitude.s;
     *lon_d = temp.Coord.DMS.longitude.d;
     *lon_m = temp.Coord.DMS.longitude.m;
     *lon_s = temp.Coord.DMS.longitude.s;
     *alt = temp.Coord.DMS.altitude;
     r

8

Le 13/11/2007 à 23:41

Le testcase réduit est :

class toto {
  static const float PI = 3.14;
};

9

10

Le 14/11/2007 à 03:58

Pas le droit d'initialiser un static float à l'intérieur d'une classe. Initialiser une variable statique de classe n'est permis que pour un entier. Pour le reste, l'initialisateur doit être écrit dans un fichier .cpp.

Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

11

Le 14/11/2007 à 08:27

Thibaut (./5) :
A quoi ça sert de déclarer statique une constante ?

En C++ visibilité de classe, en C visibilité dans .c uniquement.

Sinon: http://cpp.developpez.com/faq/cpp/?page=static#CLASS_init_static

12

Le 14/11/2007 à 13:05

Mais une constante n'est pas sensée être exportable ! C'est ça que je comprends pas.
Le but des constantes c'est d'avoir des valeurs connues à la compilation. Si une constante est visible par une autre unité, ce n'est plus une constante. C'est une variable classique, qui prend quelques octets de mémoire et qui nécessite un accès relogé, etc.

Un site complet sur lequel vous trouverez des programmes et des jeux pour votre calculatrice TI 89 / Titanium / 92+ / Voyage 200 : www.ti-fr.com.
Quelques idées personnelles ici.

13

Le 14/11/2007 à 18:30

Kevin Kofler (./10) :
Pas le droit d'initialiser un static float à l'intérieur d'une classe. Initialiser une variable statique de classe n'est permis que pour un entier. Pour le reste, l'initialisateur doit être écrit dans un fichier .cpp.

Oui j'ai bien compris le sens du message d'erreur.

Je la déclare en static parce qu'elle utilisée dans des membres static de la classe comme la fonction de conversion d'angle (de ° vers rad par exemple), le calcul de distance ou la conversion des coordonnées.
Si je ne la déclare pas en tant que static j'ai forcément l'erreur
invalid use of member «CLocate::PI" in static member function

14

15

Le 14/11/2007 à 20:45

Bon j'ai viré toutes les fonctions static. plus de problème maintenant.

16

Le 14/11/2007 à 21:36

Matrial : En fait je pense comprendre.
const ça veut dire qu'on n'a pas le droit de modifier la variable. Ce sont des variables comme les autres, mais le compilateur interdit leur accès en écriture.

Donc y'a pas d'autre chose que #define pour faire des vraies constantes en C++ ?

Un site complet sur lequel vous trouverez des programmes et des jeux pour votre calculatrice TI 89 / Titanium / 92+ / Voyage 200 : www.ti-fr.com.
Quelques idées personnelles ici.

17

18

Le 14/11/2007 à 21:46

Si tu mets une instruction C++ à la place de ta ligne de 68k, tu auras une erreur, tu n'as pas le droit d'écrire dans un pointeur const. Ni de passer un pointeur const à une fonction qui prend un pointeur non-const d'ailleurs (warning minimum pour ça).

Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

19

Le 14/11/2007 à 21:50

si tu peux avec mutable.
thibaut: l'interet c'est le debugage.

20

21

Le 14/11/2007 à 23:51

Là je pense que le compilo ne dira rien

Mais pour l'exemple que tu as donné, certains compilos comprendront que l'écriture se fait sur une zone appartenant à une variable constante.

Un site complet sur lequel vous trouverez des programmes et des jeux pour votre calculatrice TI 89 / Titanium / 92+ / Voyage 200 : www.ti-fr.com.
Quelques idées personnelles ici.

22

Le 15/11/2007 à 11:10

Le compilateur ne sait pas où pointe le pointeur, mais il sait que tu n'as pas le droit d'assigner l'adresse d'une variable const à un pointeur non-const, ni d'assigner un pointeur const à un pointeur non-const, donc seul un pointeur const peut pointer sur ta variable const. Du coup, il suffit d'interdire d'écrire dans un pointeur const.

(Oui, il y a des hacks comme const_cast, mais à ce moment-là, tu fais exprès de contourner cette vérification et tu assumes tous les problèmes qu'une écriture dans une variable const peut induire, par exemple une erreur de segmentation en temps d'exécution.)

Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

23

24

Le 25/11/2007 à 15:28

L'avantage suprème du const_cast sur un hack en ASM, c'est qu'au moins le const_cast est explicite, et recherchable.

Maintenant j'ai la flemme de garder une signature à jour sur ce site. Je n'ai même plus ma chaîne Exec sous la main.