Clases

bicotiCoordinate
bicotiCoordinate2D
bicotiCoordinate3D
bicotiCoodinateVectorialStatic

     Templates Clases

CoordComponentType

class bicotiCoordinateVectorialStatic
                                                            < class CoordComponentType , int dim >

bicotiCoordinateVectorialStatic ( )
bicotiCoordinateVectorialStatic (  const  bicotiCoordinateVectorialStatic<CoordComponentType , dim > &  )

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

void operator = (  const bicotiCoordinateVectorialStatic<CoordComponentType , dim > &  )
bool operator == (  const bicotiCoordinateVectorialStatic<CoordComponentType , dim > &  )

bicotiCoordinateVectorialStatic<CoordComponentType , dim > operator + (  double  )
bicotiCoordinateVectorialStatic<CoordComponentType , dim > operator - (  double  )
bicotiCoordinateVectorialStatic<CoordComponentType , dim > operator * (  double  )
bicotiCoordinateVectorialStatic<CoordComponentType , dim > operator / (  double  )

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

bicotiCoordinateVectorialStatic<CoordComponentType , dim > operator +
                                                                      ( const bicotiCoordinateVectorialStatic<CoordComponentType , dim > & )
bicotiCoordinateVectorialStatic<CoordComponentType , dim > operator -
                                                                      ( const bicotiCoordinateVectorialStatic<CoordComponentType , dim > & )
bicotiCoordinateVectorialStatic<CoordComponentType , dim > operator *
                                                                      ( const bicotiCoordinateVectorialStatic<CoordComponentType , dim > & )
bicotiCoordinateVectorialStatic<CoordComponentType , dim > operator /
                                                                      ( const bicotiCoordinateVectorialStatic<CoordComponentType , dim > & )

void operator += ( const bicotiCoordinateVectorialStatic<CoordComponentType , dim > & )
void operator -= ( const bicotiCoordinateVectorialStatic<CoordComponentType , dim > & )
void operator *= ( const bicotiCoordinateVectorialStatic<CoordComponentType , dim > & )
void operator /= ( const bicotiCoordinateVectorialStatic<CoordComponentType , dim > & )

REAL ScalarProduct ( const bicotiCoordinateVectorialStatic<CoordComponentType , dim > & )
REAL Norm ( )
bicotiCoordinateVectorialStatic<CoordComponentType , dim > operator ^ (  int  )

        Es el constructor de la clase , no se le pasan parámetros.
        Es importante recordar que el tipo de las componentes y la dimensión son templates de la clase.
        Por ejemplo, la linea de código :

                bicotiCoordinateVectorialStatic < int , 3 > coord;

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

        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 del template dim.

            El operador de asignación , simplemente crea una copia, sin construir un nuevo objeto.
            Es decir que puedo hacer algo como :

                        BicotiCoordinateVectorialStatic< int , 2 > coord_a;
                        BicotiCoordinateVectorialStatic< int , 2 > coord_b;

                        coord_b = coord_a;

             La coordenada coord_b resulta una copia exacta de coord_a.

             Es importante aclarar que este operador solo funciona entre coordenadas con igual dim.
             NO PUEDO HACER :

                        BicotiCoordinateVectorialStatic< int , 3 > coord_a;
                        BicotiCoordinateVectorialStatic< int , 2 > coord_b;

                        coord_b = coord_a;

             Esto dará un error de compilación porque coord_a y coord_b tienen distintos parámetros..

            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 sobre REAL.

            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.