Clases

bicotiCoordinate
bicotiCoordinate2D
bicotiCoordinate3D
bicotiCoodinateVectorialStatic

     Templates Clases

CoordComponentType

class bicotiCoordinate < class CoordComponentType >

bicotiCoordinate ( int = 0 )
~bicotiCoordinate (  )
bicotiCoordinate (  const  bicotiCoordinate<CoordComponentType > &  )

CoordComponentType& operator ( ) ( int  )
unsigned GetDimension ( )

void operator = (  const bicotiCoordinate<CoordComponentType > &  )
bool operator == (  const bicotiCoordinate<CoordComponentType > &  )

bicotiCoordinate<CoordComponentType > operator + (  double  )
bicotiCoordinate<CoordComponentType > operator - (  double  )
bicotiCoordinate<CoordComponentType > operator * (  double  )
bicotiCoordinate<CoordComponentType > operator / (  double  )

void operator += (  double  )
void operator -= (  double  )
void operator *= (  double  )
void operator /= (  double  )

bicotiCoordinate<CoordComponentType > operator +  ( constbicotiCoordinate<CoordComponentType >& )
bicotiCoordinate<CoordComponentType > operator - ( constbicotiCoordinate<CoordComponentType >& )
bicotiCoordinate<CoordComponentType > operator * ( const bicotiCoordinate<CoordComponentType >& )
bicotiCoordinate<CoordComponentType > operator / ( constbicotiCoordinate<CoordComponentType >& )

void operator += ( const bicotiCoordinate<CoordComponentType >& )
void operator -= ( const bicotiCoordinate<CoordComponentType >& )
void operator *= ( const bicotiCoordinate<CoordComponentType >& )
void operator /= ( const bicotiCoordinate<CoordComponentType >& )

REAL ScalarProduct( const bicotiCoordinate<CoordComponentType >& )
REAL Norm ( )
bicotiCoordinate<CoordComponentType > operator ^ (  int  )

operator bicotiCoordinate< INTEGER > ( )
operator bicotiCoordinate< REAL > ( )
operator bicotiCoordinate2D< INTEGER > ( )
operator bicotiCoordinate3D< INTEGER > ( )
operator bicotiCoordinate2D< REAL > ( )
operator bicotiCoordinate3D< REAL > ( )

        Es el constructor de la clase , al que se le puede pasar como parámetro, el número de componentes.
        Es importante recordar que el tipo de las componentes es un template de la clase.
        Por ejemplo, la linea de código :

                bicotiCoordinate < int > coord(3);

        Crea una coordenada de enteros de 3 dimensiones.

        Si no le pasamos la dimensión, por defecto se toma cero.

                bicotiCoordinate < float > coord;

        Crea una coordenada de floatantes de 0 dimensiones, es decir que en realidad no reserva memoria,
          pero si se asigna el tipo de las componetes, luego se puede cambiar dinámicamente la dimesión.

        El constructor no asigna valores por defecto a las componentes, por lo tanto, luego de creada, la
        coordenada tendrá "basura".

          Si la dimensión que se le pasa al constructor es negativa, este tirará una exepción.
        Ver Exepciones para más detalles.

         Destructor. Libera la memoria reservada en el array dinámico.

        Constructor de copia.

         Este operador es la intefaz standard para acceder a las componentes de las coordenadas.
         Todas las coordenadas deben tener este operador definido.
         Es bidireccional, por lo que podemos a través de el , leer o setear la componente de índice
         indicado por la variable index.
         Por ejemplo :

                    componete = coordinate ( 2 )

         Me devuelve la tercer componente de coordinate.

                    coordinate ( 0 ) = 4

         Pone 4 en la primer componente de coordinate.

         Es importante destacar que los índices van de 0 a dimensión - 1.
         La operación controla que el índice este dentro de rango si se han habilitado los chequeos, ver
         "Macros" para más información.  Si el índice está fuera de rango y se han habilitado
          los chequeos, el operador tira una exepción.
         Ver "Exepciones" para más detalle.

            Esta función devuelve la dimensión de la coordenada ( número de componentes ). También
            es parte de la interfáz standard por lo tanto todas las coordenadas deben definirla.
              En el caso de esta clase, la función devuelve el valor de una variable privada que indica la
            dimensión.

            El operador de asignación , simplemente crea una copia, sin construir un nuevo objeto.
            Si las dimensiones de la coordenada no coinciden con las de coord_src, estas se modifican
            para que coincidan con la fuente.
            Es decir que puedo hacer algo como :

                        BicotiCoordinate< int > coord_a(3);
                        BicotiCoordinate< int > coord_b(2);

                        coord_b = coord_a;

             La coordenada coord_b resulta una copia exacta de coord_a, con tres componentes.

            Operador de comparación . Devuelve true cuando todas las componentes son iguales.

            Este operador le suma un doble a cada una de las componentes y devuelve una nueva
            coordenada.
            Por ejemplo si fuera  coord_a = ( 1,  3 , -2 )
            y hago :

                        coord_b = coord_a + 3;

            Obtengo  coord_b = ( 4 , 6 , 1 )

            Este operador le resta un doble a cada una de las componentes y devuelve una nueva
            coordenada. Similar al operator +.

            Este operador multiplica por un doble a cada una de las componentes y devuelve una nueva
            coordenada..
            Por ejemplo si fuera  coord_a = ( 1,  0 , -1 , 2 )
            y hago :

                        coord_b = coord_a * 2;

            Obtengo  coord_b = ( 2 , 0 , -2 , 4 )

            Este operador divide por un doble a cada una de las componentes y devuelve una nueva
            coordenada. Similar al operator *.
            NO se controla de división por 0 ( cero ). Las consecuencias de hacerlo dependerán de lo que
            haga el sistema operativos para los tipos básicos. Es aconsejable que el usuario contemple
            externamente esta posibilidad.

            Este operador le suma un doble a cada una de las componentes y devuelve los resultados
            en la misma coordenada.
            Por ejemplo si fuera  coord = ( 1,  -1 )
            y hago :

                        coord += 2;

            Obtengo  coord = ( 3 , 1 )

            Este operador le resta un doble a cada una de las componentes y devuelve los resultados
            en la misma coordenada. Similar al operator +=.

            Este operador multiplica por un doble a cada una de las componentes y devuelve los resultados
            en la misma coordenada.
            Por ejemplo si fuera  coord = ( 2,  -1,  0 )
            y hago :

                        coord *= -1;

            Obtengo  coord = ( -2 , 1 , 0 )

            Este tipo de operadores tiene una utilidad interesante para setearle facilmente valores a todas
            las componentes.
            Por ejemplo si quiero obtener la coordenada "0" ( ceros en todas las componentes )
            Puedo hacer:

                       coord *= 0;

            Independientemente de la dimension y del contenido previo de coord.
            Si quiero poner unos en todas las componentes puedo hacer:

                       coord *= 0;
                       coord += 1;

            Este operador divide por un doble a cada una de las componentes y devuelve los resultados
            en la misma coordenada. Similar al operator /=.

            Suma componenete a componente y devuelve el resultado en otra coordenada.
            Por ejemplo si tengo , coord_a  = ( 1 , -1 , 2 )  y coord_b = ( 0, 3 , -2 )
            y hago :

                        coord_c = coord_a + coord_b;

           obtengo coord_c = ( 1, 2, 0 ), sin cambiar coord_a y coord_b.

            Resta componenete a componente de y devuelve el resultado en otra coordenada.
            Por ejemplo si tengo , coord_a  = ( 0 , -1 )  y coord_b = ( -3, 3 )
            y hago :

                        coord_c = coord_a - coord_b;

           obtengo coord_c = ( 3, -4 ), sin cambiar coord_a y coord_b.

            Producto componenete a componente y devuelve el resultado en otra coordenada.
            Por ejemplo si tengo , coord_a  = ( 1 , -1 , 0 )  y coord_b = ( 0, 3 , -2 )
            y hago :

                        coord_c = coord_a * coord_b;

           obtengo coord_c = ( 0, -3, 0 ), sin cambiar coord_a y coord_b.

            División componenete a componente y devuelve el resultado en otra coordenada.
            Por ejemplo si tengo , coord_a  = ( 1 , 4 )  y coord_b = ( 4, 2 )
            y hago :

                        coord_c = coord_a  /  coord_b;

           obtengo coord_c = ( 0.25 , 2 ), sin cambiar coord_a y coord_b.
           Es importante destacar que se usa la división del tipo de las componentes. En este ejemplo se
           supone que las componentes son reales ( float o double ). Si fueran enteros el resultado sería
           coord_c = ( 0, 2 ) ya que se usaría la división de enteros.
           NO se controla de división por 0 ( cero ). Las consecuencias de hacerlo dependerán de lo que
           haga el sistema operativos para los tipos básicos. Es aconsejable que el usuario contemple
           externamente esta posibilidad.

             En todos estos operadores, si se usan componentes de tipos definidos por el usuario, deberán
           definirse para estos tipos, los operadores +, - , * , / ,etc.
           Ver CoordComponentType

              Suma componenete a componente y devuelve el resultado en la misma coordenada.
            Por ejemplo si tengo , coord_a  = ( 1 , -1 , 2 )  y coord_b = ( 0, 3 , -2 )
            y hago :

                        coord_a += coord_b;

           obtengo coord_a = ( 1, 2, 0 ), sin cambiar coord_b.

            Resta componenete a componente de y devuelve el resultado en la misma coordenada.
            Por ejemplo si tengo , coord_a  = ( 0 , -1 )  y coord_b = ( -3, 3 )
            y hago :

                        coord_a -= coord_b;

           obtengo coord_a = ( 3, -4 ), sin cambiar coord_b.

            Producto componenete a componente y devuelve el resultado en la misma coordenada.
            Por ejemplo si tengo , coord_a  = ( 1 , -1 , 0 )  y coord_b = ( 0, 3 , -2 )
            y hago :

                        coord_a *= coord_b;

           obtengo coord_a = ( 0, -3, 0 ), sin cambiar coord_b.

            División componenete a componente y devuelve el resultado en la misma coordenada.
            Por ejemplo si tengo , coord_a  = ( 1 , 4 )  y coord_b = ( 4, 2 )
            y hago :

                        coord_a /= coord_b;

           obtengo coord_a = ( 0.25 , 2 ), sin cambiar coord_b.

             Producto escalar entre dos coordenadas. Aquí se usa el producto usual , es decir
           si coord_a = ( x1, x2 , .... , xn ) y coord_b = ( y1, y2 , ... yn ) el resultado será :
           < coord_a , coord_b > = ( x1 * y1  +  x2 * y2  +  ...  +  xn * yn  )

           Por lo tanto si fueran, por ejemplo  coord_a = ( 2 , -1 )  y coord_b = ( -3 , -2 )
           y hago :

                          prod = coord_a.ScalarProduct( coord_b );

           Obengo prod = - 4 . El tipo de retorno de esta función es REAL, un macro que se define en
           el archivo "bicoti_basic.hpp". La idea es definirlo como float o double, dependiendo
           de la precisión que se necesite.
           Ver "Macros" para más información.

            Norma de la coordenada. Esta definición deriva de la de producto escalar.
            Si coord = ( x1, x2 , .... , xn ) su norma será :
            || coord || = ( x1 * x1  +  x2 * x2  +  ...  +  xn * xn  ) ^ ( 1 / 2 )

           Por lo tanto si fueran, por ejemplo  coord = ( 1 , 2 , 2 )
           y hago :

                          norm = coord.Norm( );

           Obtengo norm = 3 .
           Ver "Macros" para más información sobre REAL.

            Calcula la potencia de cada componente y devuelve el resultado en otra coordenada.
            Si coord  = ( x1, x2 , .... , xn ).
            coord ^ 3 = ( x1^3 , x2^3 , .... , xn^3 ).

            Por ejemplo si coord_a = ( 2 , 3 ).
            y hago :

                            coord_b = coord_a ^ 2;

            Obtengo coord_b = ( 4 , 9 ) , sin cambiar coord_a.

              En muchos casos tenemos coordenadas cuyas componentes son REAL ( float o double ) y
            queremos convertirals a INTEGER ( char o integer ). Para ello hay que hacer el casting de
            cada una de las componentes. Esto es lo que hace este operador de casting.
            Por ejemplo si se define una coordenada de reales y una de enteros :

                              bicotiCoordinate< REAL >  coord_real( 3 );
                              bicotiCoordinate< INTEGER >  coord_int( 3 );

            Se hacen algunas cuentas con coord_real y luego se la quiere pasar a enteros, puedo hacer:

                              coord_int = ( bicotiCoordinate< INTEGER > ) coord_real;

            Obs :  Para que el casting funcione, las coordenadas deben tener el mismo número de
                      componentes

           Ver "Macros" para más información sobre REAL e INTEGER.

              Este operador de casting convierte coordenadas de INTEGER a coordenadas de REAL.
            Por ejemplo si defino :

                              bicotiCoordinate< REAL >  coord_real( 2 );
                              bicotiCoordinate< INTEGER >  coord_int( 2 );

            Se hacen algunas cuentas con coord_int y luego se la quiere pasar a reales, puedo hacer:

                              coord_real = ( bicotiCoordinate< REAL > ) coord_int;

            Obs :  Para que el casting funcione, las coordenadas deben tener el mismo número de
                      componentes

           Ver "Macros" para más información sobre REAL e INTEGER.

            Este operador permite convertir una coordenada de tipo bicotiCoordinate a una de sus
            especializaciones , bicotiCoordinate2D< INTEGER > , la que tiene dos componentes
            enteras. Obviamente este solo tiene sentido si la coordenada tiene dos componentes.
            Por ejemplo si defino :

                             bicotiCoordinate< REAL > coord ( 2 );
                             bicotiCoordinate2D< INTEGER > coord_2D;

            Luego podría hacer una conversión de la forma :

                             coord_2D = ( bicotiCoordinate2D< INTEGER > ) coord;

            Si la dimensión de la coordenada a convertir fuera distinta de 2 , el operador tira una exepción.
            Ver "Exepciones" para más detalle.

            Este operador permite convertir una coordenada de tipo bicotiCoordinate a una de sus
            especializaciones , bicotiCoordinate3D< INTEGER > , la que tiene tres componentes
            enteras. Obviamente este solo tiene sentido si la coordenada tiene tres componentes.
            Por ejemplo si defino :

                             bicotiCoordinate< REAL > coord ( 3 );
                             bicotiCoordinate3D< INTEGER > coord_3D;

            Luego podría hacer una conversión de la forma :

                             coord_3D = ( bicotiCoordinate3D< INTEGER > ) coord;

            Si la dimensión de la coordenada a convertir fuera distinta de 3 , el operador tira una exepción.
            Ver "Exepciones" para más detalle.

            Este operador permite convertir una coordenada de tipo bicotiCoordinate a una de sus
            especializaciones , bicotiCoordinate2D< REAL > , la que tiene dos componentes
            enteras. Obviamente este solo tiene sentido si la coordenada tiene dos componentes.
            Por ejemplo si defino :

                             bicotiCoordinate< INTEGER > coord ( 2 );
                             bicotiCoordinate2D< REAL > coord_2D;

            Luego podría hacer una conversión de la forma :

                             coord_2D = ( bicotiCoordinate2D< REAL > ) coord;

            Si la dimensión de la coordenada a convertir fuera distinta de 2 , el operador tira una exepción.
            Ver "Exepciones" para más detalle.

            Este operador permite convertir una coordenada de tipo bicotiCoordinate a una de sus
            especializaciones , bicotiCoordinate3D< REAL > , la que tiene tres componentes
            reales. Obviamente este solo tiene sentido si la coordenada tiene tres componentes.
            Por ejemplo si defino :

                             bicotiCoordinate< INTEGER > coord ( 3 );
                             bicotiCoordinate3D< REAL > coord_3D;

            Luego podría hacer una conversión de la forma :

                             coord_3D = ( bicotiCoordinate3D< REAL > ) coord;

            Si la dimensión de la coordenada a convertir fuera distinta de 3 , el operador tira una exepción.
            Ver "Exepciones" para más detalle.