index

bicotiCoordinate2D

Clases

bicotiCoordinate
bicotiCoordinate2D
bicotiCoordinate3D
bicotiCoodinateVectorialStatic

Templates Clases

class bicotiCoordinate2D< class CoordComponentType >

Public Methods

bicotiCoordinate2D ( CoordComponentType = 0 , CoordComponentType = 0 )
bicotiCoordinate2D ( const bicotiCoordinate2D<CoordComponentType> & )

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

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

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

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

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

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

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

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

bicotiCoordinate2D ( CoordComponentType x_0_val , CoordComponentTypex_1_val )

        Es el constructor de la clase , se le puede pasar como parámetro los valores de las dos componentes.
        El constructor asigna :
                                          x0 = x_0_val
                                          x1 = x_1_val
        El constructor por defecto le pone ceros.

Por ejemplo :

bicotiCoordinate2D< int > coord( 1 , 2 );

Crea una coordenada 2D de enteros, coord = ( 1 , 2 ).

bicotiCoordinate2D< float > coord;

Crea una coordenada 2D de flotantes, coord = ( 0 , 0 ).

bicotiCoordinate2D ( const bicotiCoordinate2D<CoordComponentType>& coord )

Constructor de copia.

CoordComponentType & operator ( ) ( int index )

         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, que para esta clase solo puede valer 0 o 1.
         Por ejemplo si defino :

bicotiCoordinate2D< int > coord( 1 , 2 );

comp = coord( 0 )

Me devuelve la primer componente de coord. Obtengo comp = 1;

comp = coord( 1 )

Me devuelve la segunda componente de coord. Obtengo comp = 2;

coord( 0 ) = 4

Pone 4 en la primer componente de coord.

         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.

CoordComponentType & X0 ( )

Esta función permite leer o setear la primer componente de la coordenada.
Por ejemplo , si defino :

bicotiCoordinate2D< int > coord( 3 , 0 );

comp = coord.X0();

Me devuelve la primer componente de coord. Obtengo comp = 3;

coord.X0() = 5;

Pone 5 en la primer componente de coord.

CoordComponentType & X1 ( )

Esta función permite leer o setear la segunda componente de la coordenada.
Por ejemplo , si defino :

bicotiCoordinate2D< int > coord( 3 , 0 );

comp = coord.X1();

Me devuelve la segunda componente de coord. Obtengo comp = 0;

coord.X1() = 5;

Pone 5 en la segunda componente de coord.

unsignedGetDimension ( )

            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.
            Para esta clase devuelve siempre 2.

void operator = ( const bicotiCoordinate2D <CoordComponentType> & coord_src )

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

BicotiCoordinate2D<int> coord_a;
BicotiCoordinate2D<int> coord_b;

coord_b = coord_a;

La coordenada coord_b resulta una copia exacta de coord_a.

bool operator == ( const bicotiCoordinate2D <CoordComponentType> & coord_src )

Operador de comparación . Devuelve true cuando las coordenadas tienen las dos
componentes iguales.

bicotiCoordinate2D<CoordComponentType>operator + ( double scalar )

            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 )
            y hago :

coord_b = coord_a + 3;

Obtengo coord_b = ( 4 , 6 )

bicotiCoordinate2D<CoordComponentType>operator - ( double scalar )

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

bicotiCoordinate2D<CoordComponentType>operator * ( double scalar )

            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 )
            y hago :

coord_b = coord_a * 2;

Obtengo coord_b = ( 2 , 0 )

bicotiCoordinate2D<CoordComponentType>operator / ( double scalar )

            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.

void operator += ( double scalar )

            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 )

void operator -= ( double scalar )

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

void operator *= ( double scalar )

            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 )
            y hago :

coord *= -1;

Obtengo coord = ( -2 , 1 )

void operator /= ( double scalar )

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

bicotiCoordinate2D<CoordComponentType>operator +
( const bicotiCoordinate2D<CoordComponentType> & coord_src )

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

coord_c = coord_a + coord_b;

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

bicotiCoordinate2D<CoordComponentType> operator -
( const bicotiCoordinate2D<CoordComponentType> & coord_src )

            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.

bicotiCoordinate2D<CoordComponentType>operator *
( const bicotiCoordinate2D<CoordComponentType> & coord_src )

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

coord_c = coord_a * coord_b;

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

bicotiCoordinate2D<CoordComponentType>operator /
( const bicotiCoordinate2D<CoordComponentType> & coord_src )

            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

void operator += ( const bicotiCoordinate2D<CoordComponentType> & coord_src )

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

coord_a += coord_b;

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

void operator -= ( const bicotiCoordinate2D<CoordComponentType> & )

            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.

void operator *= ( const bicotiCoordinate2D<CoordComponentType> & )

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

coord_a *= coord_b;

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

void operator /= ( const bicotiCoordinate2D<CoordComponentType> & )

            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.

REAL ScalarProduct ( const bicotiCoordinate2D<CoordComponentType> & coord_src )

             Producto escalar entre dos coordenadas.
           Si coord_a = ( x1, x2 ) y coord_b = ( y1, y2 ) el resultado será :
           < coord_a , coord_b > = ( x1 * y1 + x2 * y2 )

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.

REAL Norm ( )

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

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

norm = coord.Norm( );

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

bicotiCoordinate2D<CoordComponentType>operator ^ ( int )

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

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

coord_b = coord_a ^ 2;

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

operator bicotiCoordinate2D< INTEGER > ( )

              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 :

bicotiCoordinate2D< REAL > coord_real;
bicotiCoordinate2D< INTEGER > coord_int;

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

coord_int = ( bicotiCoordinate2D< INTEGER > ) coord_real;

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

operator bicotiCoordinate2D< REAL > ( )

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

bicotiCoordinate2D< REAL > coord_real;
bicotiCoordinate2D< INTEGER > coord_int;

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

coord_real = ( bicotiCoordinate2D< REAL > ) coord_int;

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