LIBRERÍA GPL C++ PARA LA MANIPULACIÓN DE EXPRESIONES SIMBÓLICAS EN LA DINÁMICA DE SISTEMAS MULTICUERPO.

LIBRERÍA GPL C++ PARA LA MANIPULACIÓN DE EXPRESIONES SIMBÓLICAS EN LA DINÁMICA DE SISTEMAS MULTICUERPO

Extracto del documento

ESCUELA TÉCNICA SUPERIOR DE INGENIEROS
INDUSTRIALES Y DE TELECOMUNICACIÓN
Titulación :
INGENIERO TÉCNICO EN INFORMÁTICA DE GESTIÓN
Título del proyecto:
LIBRERÍA GPL C++ PARA LA MANIPULACIÓN DE
EXPRESIONES SIMBÓLICAS EN LA DINÁMICA DE SISTEMAS
MULTICUERPO
Luis Miguel Arrondo Martínez
Javier Ros Ganuza
Pamplona, Noviembre de 2007
Índice
1 - INTRODUCCIÓN....................................................................................................................................................... 8
2 - ANÁLISIS.................................................................................................................................................................... 9
2.1 - NIVEL CONTEXTUAL............................................................................................................................................... 9
2.2 - NIVEL 1................................................................................................................................................................. 10
2.3 - NIVEL 2................................................................................................................................................................. 11
Nivel 2 – 1 Operaciones con Matrices..................................................................................................................................11
Nivel 2 – 2 Operaciones con Vectores 3D............................................................................................................................12
Nivel 2 – 3 Operaciones con Tensores 3D.............................................................................................................................13
Nivel 2 – 4 Operaciones con Sistemas..................................................................................................................................13
Nivel 2 – 5 Operaciones con Bases.......................................................................................................................................14
Nivel 2 – 6 Operaciones con Referencias .............................................................................................................................15
Nivel 2 – 7 Operaciones con Puntos .....................................................................................................................................15
3 - DISEÑO...................................................................................................................................................................... 16
NOMBRE_LIBRERÍA::NOMBRE_CLASE.............................................................................................................................. 17
3.1 - CONSTANTES, VARIABLES Y FUNCIONES GLOBALES.............................................................................................. 17
3.1.1 - Constantes globales ..................................................................................................................................... 17
3.1.2 - Variables globales ....................................................................................................................................... 18
extern int atomization;......................................................................................................................................................18
extern int gravity; .............................................................................................................................................................18
extern void ( * outError ) ( char * ); .................................................................................................................................18
void printError( char * args );...........................................................................................................................................18
extern vector < symbol > atoms; ......................................................................................................................................18
extern vector < ex > atom_expresions;.............................................................................................................................19
extern vector < symbol > exclude_atoms; ........................................................................................................................19
3.1.3 - Funciones globales ...................................................................................................................................... 19
template < class T > T atomize ( T m ); ...........................................................................................................................19
template < class T > T unatomize ( T m );........................................................................................................................19
template < class T > lst atom_list( T m , lst & list ) ; .......................................................................................................19
ex atomize_ex ( ex e );......................................................................................................................................................19
ex unatomize_ex ( ex e );..................................................................................................................................................21
void exclude_atom ( symbol s );.......................................................................................................................................21
void exclude_Coordinates_atoms ( System * system );....................................................................................................21
void exclude_Velocities_atoms( System * system );........................................................................................................22
void exclude_Accelerations_atoms ( System * system ); .................................................................................................22
void exclude_Unknowns_atoms ( System * system );......................................................................................................22
3.2 - CLASE MATRIX..................................................................................................................................................... 23
3.2.1 - Diagrama de clase....................................................................................................................................... 23
3.2.2 - Elementos protegidos................................................................................................................................... 24
• Atributos.............................................................................................................................................................................24
string name;......................................................................................................................................................................24
matrix mat; .......................................................................................................................................................................25
System * system;..............................................................................................................................................................25
long last_row;...................................................................................................................................................................25
long last_col; ....................................................................................................................................................................25
• Constructor protegido.........................................................................................................................................................25
Matrix ( matrix mat );.......................................................................................................................................................25
• Método protegido ...............................................................................................................................................................26
void set_matrix ( matrix mat );.........................................................................................................................................26
3.2.3 - Elementos privados...................................................................................................................................... 26
• Métodos privados ...............................................................................................................................................................26
void init ( string name , matrix mat );..............................................................................................................................26
static Matrix Operations ( const Matrix & MatrixA , const Matrix & MatrixB , const int flag );....................................26
static Matrix Operations ( const Matrix & MatrixA , const ex & expression , const int flag ); ......................................27
3.2.4 - Elementos públicos ...................................................................................................................................... 27
• Constructores......................................................................................................................................................................27
Matrix( void ); ..................................................................................................................................................................27
Matrix ( long rows , long cols ); .......................................................................................................................................27
Matrix ( string name , Matrix mat ); ................................................................................................................................28
Matrix ( string name , long rows , long cols );.................................................................................................................28
Matrix ( long rows , long cols , ex * first , ... ); ...............................................................................................................28
Matrix ( string name , long rows , long cols , ex * first , ... );.........................................................................................30
Matrix ( long rows , long cols , Matrix * first , ... ); .......................................................................................................30
Matrix ( long rows, long cols, lst expressions_list ); .......................................................................................................34
Matrix( lst expressions_list ); ...........................................................................................................................................34
Matrix( string name , lst expresión_list );........................................................................................................................35
string get_name ( void );...................................................................................................................................................36
matrix get_matrix ( void ); ...............................................................................................................................................36
System * get_System ( void );..........................................................................................................................................36
void set_name ( string name ); .........................................................................................................................................36
void set_System ( System * system ); ..............................................................................................................................37
• Métodos públicos................................................................................................................................................................37
Matrix transpose ( void ); .................................................................................................................................................37
Matrix Dt ( void ); ............................................................................................................................................................37
Matrix subs ( relational relation ); ....................................................................................................................................38
• Operadores..........................................................................................................................................................................39
friend Matrix operator + ( const Matrix & MatrixA , const Matrix & MatrixB ); ..........................................................39
friend Matrix operator - ( const Matrix & MatrixA , const Matrix & MatrixB ); ............................................................39
friend Matrix operator - ( const Matrix & MatrixA );.......................................................................................................40
friend Matrix operator * ( const Matrix & MatrixA , const Matrix & MatrixB );............................................................40
friend Matrix operator * ( const ex & expression , const Matrix & MatrixA );...............................................................41
friend Matrix operator * ( const Matrix & MatrixA , const ex & expression ); ...............................................................41
ex & operator( ) ( long row, long col ); ............................................................................................................................42
Matrix& operator = ( const ex & expression );.................................................................................................................42
Matrix& operator , ( const ex & expression );..................................................................................................................42
friend ostream & operator << ( ostream & os , const Matrix & MatrixA );.....................................................................43
• Destructor ...........................................................................................................................................................................43
~Matrix ( void );...............................................................................................................................................................43
3.3 - CLASE VECTOR3D................................................................................................................................................ 44
3.3.1 - Diagrama de clases ..................................................................................................................................... 44
3.3.2 - Elementos Privados ..................................................................................................................................... 45
• Atributos.............................................................................................................................................................................45
Base * base;......................................................................................................................................................................45
• Métodos privados ...............................................................................................................................................................45
void init ( string name , matrix mat , Base * base , System * system );............................................................................45
static Vector3D Operations ( const Vector3D & Vector3DA , const Vector3D & Vector3DB , const int flag );...........45
3.3.3 - Elementos públicos ...................................................................................................................................... 47
• Constructores......................................................................................................................................................................47
Vector3D ( void ); ............................................................................................................................................................47
Vector3D ( string name , Base * base ); ..........................................................................................................................47
Vector3D ( string name , Matrix mat , Base * base );.....................................................................................................47
Vector3D ( string name , ex expression1 , ex expression2 , ex expression3 , Base * base );........................................48
Vector3D ( string name , Matrix * mat , Base * base, System * system ); ....................................................................48
Vector3D ( string name , ex expression1 , ex expression2 , ex expression3 , Base * base , System * system ); .........49
Vector3D ( string name , Matrix mat , string base_name , System * system ); .............................................................49
Vector3D ( string name , ex expression1 , ex expression2 , ex expression3 , string base_name , System * system ); 50
Vector3D ( Base * base );.................................................................................................................................................51
Vector3D ( Matrix mat , Base * base ); ...........................................................................................................................51
Vector3D ( ex expression1 , ex expression2 , ex expression3 , Base * base ); ..............................................................51
Vector3D ( Matrix mat , Base * base , System * system );.............................................................................................52
Vector3D ( ex expression1 , ex expression2 , ex expression3 , Base * base , System * system );................................52
Vector3D ( Matrix mat , string base_name , System * system );....................................................................................53
Vector3D ( ex expression1 , ex expression2 , ex expression3 , string base_name , System * system );.......................53
• Métodos de modificación y acceso.....................................................................................................................................54
Base * get_Base ( void );..................................................................................................................................................54
void set_Base ( Base * new_base );..................................................................................................................................54
• Métodos públicos................................................................................................................................................................55
Vector3D Dt( Frame * frame); .........................................................................................................................................55
Vector3D Dt ( Base * base);.............................................................................................................................................55
Vector3D subs ( relational relation ); ...............................................................................................................................55
• Operadores..........................................................................................................................................................................55
friend Vector3D operator + ( const Vector3D & Vector3DA , const Vector3D & Vector3DA );...................................55
friend Vector3D operator - ( const Vector3D & Vector3DA , const Vector3D & Vector3DB ); ....................................56
friend Vector3D operator - ( const Vector3D & Vector3DA ); ........................................................................................57
friend ex operator * ( const Vector3D & Vector3DA , const Vector3D & Vector3DB ); ...............................................57
friend Vector3D operator * ( const Vector3D & Vector3DA , const ex & expresión ); ..................................................58
friend Vector3D operator * ( const ex & expresion , const & Vector3D Vector3DA ); ..................................................58
friend Vector3D operator ^ ( const Vector3D & Vector3DA , const Vector3D & Vector3DB );....................................59
friend ostream & operator << ( ostream & os , const Vector3D & Vector3DA ); ...........................................................59
• Destructor ...........................................................................................................................................................................60
~Vector3D ( void ); ..........................................................................................................................................................60
3.4.1 - Diagrama de clase....................................................................................................................................... 61
3.4.2 - Elementos privados...................................................................................................................................... 61
• Atributos.............................................................................................................................................................................61
Base* base;.......................................................................................................................................................................61
• Métodos privadoss..............................................................................................................................................................61
void init( string name , matrix mat , Base * base , System * system );..........................................................................61
static Vector3D Operations ( const Vector3D & Vector3DA , const Vector3D & Vector3DB , int flag ); ....................62
3.4.3 - Elementos públicos ...................................................................................................................................... 62
• Costructores........................................................................................................................................................................62
Tensor3D ( void ); ............................................................................................................................................................62
Tensor3D ( string name , Matrix mat , Base * base ); ....................................................................................................62
Tensor3D ( Matrix mat , Base * base );...........................................................................................................................62
Tensor3D ( string name , ex exp1 , ex exp2 , ex exp3 , ex exp4 , ex exp5 , ex exp6 , ex exp7 , ex exp8 , ex exp9 ,
Base * base );....................................................................................................................................................................63
Tensor3D ( string name , Matrix mat , Base * base , System * system );......................................................................63
Tensor3D ( string name , Matrix * mat , Base * base , System * system );...................................................................64
Tensor3D ( string name , ex exp1 , ex exp2 , ex exp3 , ex exp4 , ex exp5 , ex exp6 , ex exp7 , ex exp8 , ex exp9 ,
Base * base , System * system ); .....................................................................................................................................64
• Métodos de modificación y acceso.....................................................................................................................................65
void set_Base ( Base * new_base );..................................................................................................................................65
Base * get_Base ( void );..................................................................................................................................................65
• Métodos Públicos ...............................................................................................................................................................66
Tensor3D subs ( relational relation ); ...............................................................................................................................66
• Operadores..........................................................................................................................................................................66
friend Tensor3D operator + ( const Tensor3D & Tensor3DA , const Tensor3D & Tensor3DB ); ..................................66
friend Tensor3D operator - ( const Tensor3D & Tensor3DA , const Tensor3D & Tensor3DB );...................................67
friend Tensor3D operator * ( const Tensor3D & Tensor3DA , const Tensor3D & Tensor3DB ); ..................................68
friend Vector3D operator * ( const Tensor3D & Tensor3DA , const Vector3D & Vector3DA );...................................68
friend ostream & operator << ( ostream & os , const Tensor3D & Tensor3DA );...........................................................69
• Destructor ...........................................................................................................................................................................69
~Tensor3D ( void );..........................................................................................................................................................69
3.5 - CLASE BASE ......................................................................................................................................................... 70
3.5.1 - Diagrama de clase....................................................................................................................................... 70
3.5.2 - Elementos privados...................................................................................................................................... 70
• Atributos.............................................................................................................................................................................70
string name;......................................................................................................................................................................70
Matrix rotation_tupla;.......................................................................................................................................................70
ex rotation_angle;.............................................................................................................................................................70
Base * previous_base; ......................................................................................................................................................71
System * sys;....................................................................................................................................................................71
• Métodos privados ...............................................................................................................................................................71
matrix euler_parameter_to_rotation_matrix ( Matrix phi , ex expression ); ....................................................................71
Matrix euler_parameter_to_angular_velocity( Matrix phi , ex expression );...................................................................71
void init( string name , Base * previous_base , Matrix rotation_tupla , ex rotation_angle , System * system ); ..........72
3.5.3 - Elementos públicos ...................................................................................................................................... 72
• Costructores........................................................................................................................................................................72
Base ( void ); ....................................................................................................................................................................72
Base ( string name , Base * previous_base , Matrix rotation_tupla , ex totation_amgle ); ............................................72
Base ( string name , Base * previous_base , ex expression1 , ex expression2 , ex expression3 , ex rotation_angle );.73
Base ( string name , Base * previous_base , Matrix rotation_tupla , ex rotation_angle , System * system );...............73
• Métodos de modificación y acceso.....................................................................................................................................73
string get_name ( void );...................................................................................................................................................73
Matrix get_Rotation_Tupla ( void );.................................................................................................................................74
Base* get_Previous_Base ( void );...................................................................................................................................74
ex get_Rotation_Angle ( void ); .......................................................................................................................................74
void set_name ( string new_name );.................................................................................................................................74
void set_System ( System * system ); ..............................................................................................................................75
void set_Previous_Base ( Base * new_previous_base ); ..................................................................................................75
• Métodos públicos................................................................................................................................................................75
Matrix rotation_matrix ( void );........................................................................................................................................75
Vector3D angular_velocity ( void );.................................................................................................................................75
• Destructor ...........................................................................................................................................................................76
~Base ( void ); ..................................................................................................................................................................76
3.6 - CLASE POINT ........................................................................................................................................................ 77
3.6.1 - Diagrama de clase....................................................................................................................................... 77
3.6.2 - Elementos privados...................................................................................................................................... 77
• Atributos.............................................................................................................................................................................77
string name;......................................................................................................................................................................77
Point * previous_Point; ....................................................................................................................................................77
Vector3D * position_vector; ............................................................................................................................................77
3.6.3 - Elementos públicos ...................................................................................................................................... 77
• Constructores......................................................................................................................................................................77
Point ( void );....................................................................................................................................................................78
Point ( string name , Point * previous_point , Vector3D * position_vector );...............................................................78
• Métodos de modificación y acceso.....................................................................................................................................78
Point * get_Previous_Point ( void );.................................................................................................................................78
Vector3D * get_Position_Vector ( void );........................................................................................................................78
string get_name ( void );...................................................................................................................................................79
• Destructor ...........................................................................................................................................................................79
~Point ( void ); .................................................................................................................................................................79
3.7 - CLASE FRAME....................................................................................................................................................... 80
3.7.1 - Diagrama de clase....................................................................................................................................... 80
3.7.2 - Elementos privados...................................................................................................................................... 80
• Atributos.............................................................................................................................................................................80
string name;......................................................................................................................................................................80
Point * point; ....................................................................................................................................................................80
Base * base;......................................................................................................................................................................80
3.7.3 - Elementos públicos ...................................................................................................................................... 80
• Constructores......................................................................................................................................................................80
Frame ( void );..................................................................................................................................................................80
Frame ( string name , Point * point , Base * base ); .......................................................................................................81
• Métodos de modificación y acceso.....................................................................................................................................81
Point* get_Point ( void ); .................................................................................................................................................81
Base * get_Base ( void );..................................................................................................................................................81
string get_name ( void );...................................................................................................................................................82
void set_Base ( Base * new_base );..................................................................................................................................82
void set_Point ( Point * new_point ); ...............................................................................................................................82
void set_name ( string new_name );.................................................................................................................................83
• Destructor ...........................................................................................................................................................................83
~Frame ( void );................................................................................................................................................................83
3.8 - CLASE SYSTEM ..................................................................................................................................................... 84
3.8.1 - Diagrama de clase....................................................................................................................................... 84
3.8.2 - Elementos privados...................................................................................................................................... 85
• Atributos.............................................................................................................................................................................85
symbol t;...........................................................................................................................................................................85
numeric t_numeric;...........................................................................................................................................................86
vector < symbol * > coordinates; .....................................................................................................................................86
vector < symbol * > velocities;.........................................................................................................................................86
vector < symbol * > accelerations; ...................................................................................................................................86
vector < symbol * > parameters; ......................................................................................................................................86
vector < symbol * > unknowns; .......................................................................................................................................86
vector < numeric > coordinates_numeric; ........................................................................................................................86
vector < numeric > velocities_numeric; ...........................................................................................................................86
vector < numeric > accelerations_numeric;......................................................................................................................87
vector < numeric > parameters_numeric; .........................................................................................................................87
vector < numeric > unknowns_numeric; ..........................................................................................................................87
vector < Base * > Bases; ..................................................................................................................................................87
vector < Matrix * > Matrixes;...........................................................................................................................................87
vector < Vector3D * > Vectors; .......................................................................................................................................87
vector < Tensor3D * > Tensors;.......................................................................................................................................87
vector < Frame * > Frames;..............................................................................................................................................87
vector < Point * > Points; .................................................................................................................................................87
• Métodos privados ...............................................................................................................................................................88
int can_Erase_Point ( string point_name );.......................................................................................................................88
int can_Erase_Base ( string base_name ); ........................................................................................................................88
int can_Erase_Vector3D ( string Vector3D_name );........................................................................................................88
Vector3D Angular_Velocity_Aux ( Base * BaseA , Base * BaseB ); ..............................................................................88
Vector3D Position_Vector_Aux( Point * PointA , Point * PointB ); ...............................................................................88
Matrix Rotation_Matrix_Aux ( Base * BaseA , Base * BaseB ); .....................................................................................88
int Bases_Position ( Base * BaseA , Base * BaseB );.......................................................................................................89
int Points_Position ( Point * PointA , Point * PointB ); ...................................................................................................89
void init( void ( * ) ( char * ) );.........................................................................................................................................90
3.8.3 - Elementos públicos ...................................................................................................................................... 90
• Constructores......................................................................................................................................................................90
System ( void ); ................................................................................................................................................................90
System ( void ( * ) ( char * ) ); .........................................................................................................................................90
• Métodos públicos................................................................................................................................................................90
symbol * new_Coordinate ( symbol * coordinate , symbol * velocity , symbol * acceleration , numeric
coordinate_value, numeric velocity_value , numeric acceleration_value ); ...................................................................90
symbol * new_Coordinate ( symbol * coordinate , symbol* velocity , symbol * acceleration , numeric
coordinate_value , numeric velocity_value );..................................................................................................................91
symbol * new_Coordinate ( symbol * coordinate , symbol * velocity , symbol * acceleration , numeric
coordinate_value );...........................................................................................................................................................91
symbol * new_Coordinate ( symbol * coordinate , symbol * velocity , symbol * acceleration );..................................92
symbol * new_Coordinate ( string coordinate_name , string velocity_name , string acceleration_name , numeric
coordinate_value , numeric velocity_value , numeric acceleration_value ); ..................................................................92
symbol * new_Coordinate( string coordinate_name , numeric coordinate_value , numeric velocity_value , numeric
acceleration_value );.........................................................................................................................................................93
symbol * new_Coordinate ( string coordinate_name , numeric coordinate_value , numeric velocity_value );.............93
symbol * new_Coordinate ( string coordinate_name , numeric coordinate_value ); .......................................................94
symbol * new_Coordinate ( string coordinate_name ); ....................................................................................................94
Symbol * new_Parameter ( symbol * parameter , numeric parameter_value );..............................................................95
Symbol * new_Parameter ( symbol * parameter );...........................................................................................................95
Symbol * new_Parameter ( string parameter_name , numeric parameter_value );..........................................................96
symbol * new_Parameter( string parameter_name );........................................................................................................96
symbol * new_Joint_Unknown ( string unknown_parameter_name );.............................................................................97
symbol * new_Joint_Unknown ( string unknown_parameter_name , numeric unknown_parameter_value );................97
symbol * new_Joint_Unknown ( symbol * unknown_parameter );..................................................................................97
symbol * new_Joint_Unknown ( symbol * unknown_parameter , numeric unknown_parameter_value );.....................98
void new_Base( Base * BaseA );......................................................................................................................................98
void new_Matrix( Matrix * MatrixA ); ............................................................................................................................98
void new_Vector3D( Vector3D * Vector3DA );..............................................................................................................99
void set_Time_Symbol ( symbol time ); ..........................................................................................................................99
Base* new_Base ( string name , Base * previous_base , Matrix rotation_tupla , ex rotation_angle ); ...........................99
Base* new_Base ( string name , string previous_base_name , Matrix rotation_matrix , ex rotation_angle );................99
Base * new_Base ( string name , string previous_base_name , ex expression1 , ex expression2 , ex expression3 ,
ex rotation_angle );.........................................................................................................................................................100
Vector3D * new_Vector3D ( string name , matrix mat , Base * base );.......................................................................100
Vector3D * new_Vector3D ( string name , matrix mat , string base_name ); ..............................................................101
Vector3D * new_Vector3D ( string name , Matrix * mat , string base_name );...........................................................101
Vector3D* new_Vector3D ( string name , ex expression1 , ex expression2 , ex expression3 , Base * base );............102
Vector3D* new_Vector3D ( string name , ex expression1 , ex expression2 , ex expression3 , string base_name );..102
Tensor3D * new_Tensor3D ( string name , Matrix * mat , Base * base ); ...................................................................102
Tensor3D* new_Tensor3D ( string name , ex exp1 , ex exp2 , ex exp3 , ex exp4 , ex exp5 , ex exp6 , ex exp7 , ex
exp8 , ex exp9 , Base * base );.......................................................................................................................................103
Tensor3D* new_Tensor3D ( string name , ex exp1 , ex exp2 , ex exp3 , ex exp4 , ex exp5 , ex exp6 , ex exp7 , ex
exp8 , ex exp9 , string base_name);................................................................................................................................103
Point* new_Point ( string name , Point * previous_point , Vector3D * position_vector ); ...........................................104
Point* new_Point ( string name , string previous_point_name , Vector3D * position_vector ); ..................................104
Frame * new_Frame ( string name , Point * point , Base * base );...............................................................................104
Frame * new_Frame ( string name , string point_name , string base_name );..............................................................105
Matrix* new_Matrix ( string name , Matrix mat );........................................................................................................105
symbol get_Time_Symbol( void );.................................................................................................................................106
vector < symbol * > get_Coordinates ( void ); ...............................................................................................................106
vector < symbol * > get_Velocities ( void ); ..................................................................................................................106
vector < symbol * > get_Accelerations ( void );.............................................................................................................106
vector < symbol * > get_Parameters ( void );.................................................................................................................106
vector < symbol * > get_Unknowns ( void ); .................................................................................................................106
vector < Base * > get_Bases ( void );.............................................................................................................................106
vector < Matrix * > get_Matrixes ( void ); .....................................................................................................................106
vector < Vector3D * > get_Vectors ( void ); ..................................................................................................................106
vector < Tensor3D * > get_Tensors ( void );..................................................................................................................107
vector < Point * > get_Points ( void );............................................................................................................................107
vector < Frame * > get_Frames ( void ); ........................................................................................................................107
Matrix Coordinates ( void ); ...........................................................................................................................................107
Matrix Velocities ( void ); ..............................................................................................................................................107
Matrix Accelerations ( void ); ........................................................................................................................................107
Matrix Joint_Unknowns ( void ); ...................................................................................................................................107
numeric get_Time_Value ( void ); .................................................................................................................................108
void set_Time_Value ( numeric time_value ); ...............................................................................................................108
Symbol * get_Coordinate ( string coordinate_name ); ...................................................................................................108
symbol * get_Velocity ( string velocity_name );............................................................................................................108
symbol * get_Acceleration ( string acceleration_name );...............................................................................................108
symbol * get_Parameter ( string parameter_name ); ......................................................................................................109
symbol * get_Unknown ( string unknown_parameter_name ); ......................................................................................109
Base * get_Base ( string base_name ); ...........................................................................................................................109
Frame * get_Frame ( string frame_name ); ....................................................................................................................110
Matrix * get_Matrix ( string matrix_name );..................................................................................................................110
Vector3D * get_Vector3D ( string vector3D_name );....................................................................................................110
Point * get_Point ( string point_name );.........................................................................................................................111
Base * Reduced_Base ( Base * BaseA , Base * BaseB );...............................................................................................111
Base* Reduced_Base ( string BaseA_namme , string BaseB_name );..........................................................................114
Point * Reduced_Point ( Point * PointA , Point * PointB );..........................................................................................114
Point * Reduced_Point ( string PointA_name , string PointB_name ); .........................................................................114
Matrix Rotation_Matrix ( Base * BaseA , Base * BaseB );...........................................................................................115
Vector3D Position_Vector ( Point * PointA , Point * PointB ); ....................................................................................117
Vector3D Position_Vector( string PointA_name , string PointB_name );.....................................................................117
Vector3D Angular_Velocity ( Base * BaseA , Base * BaseB );.....................................................................................117
Vector3D Angular_Velocity ( string base_frame_nameA , string base_frame_nameB ); .............................................117
Tensor3D Angular_Velocity_Tensor ( Base * BaseA , Base * BaseB );.......................................................................118
Vector3D Angular_Acceleration ( string base_frame_nameA , string base_frame_nameB ); ......................................118
void remove_Matrix ( string matrix_name );..................................................................................................................118
void remove_Vector3D ( string vector3D_name ); ........................................................................................................118
void remove_Point ( string point_name ); ......................................................................................................................118
void remove_Base ( string base_name );........................................................................................................................118
bool is_dt_zero( ex expression );....................................................................................................................................118
ex dt( ex expression );.....................................................................................................................................................119
Matrix Dt ( Matrix MatrixA );........................................................................................................................................119
Vector3D Dt ( Vector3D Vector3DA , Base * base );...................................................................................................119
Vector3D Dt ( Vector3D Vector3DA , Frame * frame ); ..............................................................................................119
Vector3D Dt ( Vector3D Vector3DA , string base_frame_name );...............................................................................119
Matrix jacobina ( Matrix MatrixA , Matrix MatrixB ); ................................................................................................119
Matrix jacobian ( ex expression, Matrix MatrixA );.......................................................................................................120
Matrix jacobian ( Matrix MatrixA , symbol symbolA ); ................................................................................................120
ex jacobian ( ex expression , symbol symbolA ); ...........................................................................................................120
ex diff ( ex expression , symbol symbolA );...................................................................................................................120
Matrix diff ( Matrix MatrixA , symbol symbolA ); ........................................................................................................120
Vector3D diff ( Vector3D Vector3DA , symbol symbolA );..........................................................................................121
Tensor3D diff ( Tensor3D Tensor3DA , symbol symbolA );.........................................................................................121
ex numeric_evaluate ( ex expression );...........................................................................................................................121
Matrix evaluate_Matrix ( Matrix MatrixA );..................................................................................................................122
double ** evaluate_Array ( Matrix MatrixA );...............................................................................................................123
string print_Array ( long rows ,long cols , double ** array );........................................................................................123
• Métodos de exportación....................................................................................................................................................123
void export_var_def_C ( void ); .....................................................................................................................................124
void export_var_def_H ( void );.....................................................................................................................................124
void export_var_init_C ( void );.....................................................................................................................................124
void export_atom_def_C ( lst atom_list );......................................................................................................................124
void export_gen_coord_vect_def_H ( void );.................................................................................................................124
void export_gen_coord_vect_init_C ( void );.................................................................................................................125
void export_gen_vel_vect_init_H ( void );.....................................................................................................................125
void export_gen_vel_vect_init_C ( void );.....................................................................................................................125
void export_gen_accel_vect_init_H ( void ); .................................................................................................................125
void export_gen_accel_vect_init_C ( void );..................................................................................................................125
void export_unknowns_vect_init_H ( void );.................................................................................................................125
void export_unknowns_vect_init_C ( void ); .................................................................................................................126
void export_Column_Matrix_C ( string func_name , string vect_name , Matrix Col_matrix , lst matrix_atom_list ); 126
void export_Matrix_C ( string function_name , string marix_name , Matrix mat , lst matrix_atom_list );.................126
void export_write_state_file_header_C ( void ); ............................................................................................................126
void export_write_state_file_C ( void );.........................................................................................................................126
• Destructor .........................................................................................................................................................................127
~System ( void ); ............................................................................................................................................................127
• Funciones .........................................................................................................................................................................127
4 - EJEMPLO AMPLIO .............................................................................................................................................. 128
5 - INSTALACIÓN Y USO.......................................................................................................................................... 142
6 - BIBLIOGRAFÍA..................................................................................................................................................... 144
7- FECHA Y FIRMA....................................................................................................................................................145
(...)
1 - Introducción
El objetivo de este proyecto, es el desarrollo de una librería GPL C++ para la
manipulación de expresiones simbólicas de la dinámica de sistemas multicuerpo, que pueda
ser un sustituto del kernel de la aplicación 3D_mec.
Se trata de una librería informática escrita en el lenguaje C++, capaz de definir y
trabajar con rapidez y robustez sobre expresiones simbólicas en el campo de la mecánica
como pueden ser vectores, tensores, puntos, bases, matrices, expresiones vectoriales y
matriciales, además de poder calcular vectores de posición, matrices de cambio de base,
velocidades y aceleraciones angulares, etc.
Además la librería tiene la posibilidad de automatizar la exportación de funciones y
datos generados en la ejecución de aplicaciones que usen la librería, para así poder hacer uso
de estos datos en aplicaciones externas como puede ser, entre otros, aplicaciones de
generación de gráficas.
La decisión de escoger el lenguaje C++ para su implementación, ha sido tomada por
las siguientes razones que se van a redactar a continuación. Por la perfecta integración que
este lenguaje tiene con la librería GiNaC, la cual es base fundamental en el desarrollo de este
proyecto. La base de esta perfecta integración es debida a que GiNaC también esta
implementada en lenguaje C++. Además, las características propias de este lenguaje orientado
a objetos también lo hacen propicio, ya que adicionalmente posee algunas características de la
programación que satisfacen el paradigma iterativo, como la posibilidad de la declaración de
variables globales a toda la aplicación o posibilidad de uso de punteros para la optimización
del uso de los recursos de nuestro ordenador. También posee la posibilidad de la creación de
plantillas, lo que ha supuesto una reducción considerable en el número de líneas de código, y
alguna característica más que mas adelante podremos ver. Y finalmente la mas importante de
las razones es porque este lenguaje de programación orientado a objetos, permite la
sobrecarga de operadores, es decir, permite usar y configurar entre otros, los operadores “+”,
“-”, “*”, “^”; con lo que podremos crear instrucciones en el programa cliente de forma
natural, como si las estuviésemos creando de forma manual con un bolígrafo sobre un papel,
con la consiguiente rapidez de asimilación de la sintaxis por parte de los usuarios de la
librería.
Como se ha comentado anteriormente, la librería GiNaC, es parte fundamental del
proyecto que ahora se presenta, y se trata de una librería bajo licencia GPL de calidad
contrastada en el ámbito del algebra computacional y que haciendo uso de sus objetos y
funciones, ha hecho que la librería sea mucho mas potente y fiable además del ahorro de
esfuerzo que hubiese supuesto crear una librería de similares características.
Una vez introducidos algunos conceptos sobre la librería, vamos a describir con
detenimiento que es lo que la librería va a ser capaz haciendo una etapa de análisis detallada.
2 - Análisis
Lib3D_mec_GiNaC, que es el nombre que va a tomar la librería, debe ser capaz de
realizar múltiples operaciones entre diferentes objetos y expresiones para que podamos definir
de la forma más ágil y flexible las ecuaciones de la dinámica de sistemas multicuerpo.
A continuación, mediante una serie de diagramas de casos de uso, que son los
diagramas que se utilizan en el UML para representar en un primer momento los requisitos y
funcionalidades que debe tener la aplicación final, se va a proceder a mostrar, de una forma de
fácil comprensión las operaciones que un usuario va a ser capaz de realizar con la librería
desarrollada. Estos diagramas se van a ir desarrollando de forma descendente empezando por
el nivel cero o contextual y siguiendo por el nivel uno y sucesivos, mostrando en cada nivel
un nivel mas alto de detalle en los objetivos finales de funcionalidad de la librería.
2.1 - Nivel Contextual
En el nivel más alto de abstracción, el usuario va a encontrarse con la librería
llamada lib3d_mec_GiNaC, que es la que contiene todos los objetos y funciones que más
adelante vamos a poder utilizar. Esta es la librería que deberá ser invocada en nuestro
programa principal que contenga el método main.
(...)
Nivel 2 – 3 Operaciones con Tensores 3D
En el apartado de operaciones con objetos tensor 3D, un usuario debe poder construir
tensores 3D de diferentes formas, sumar, restar, y multiplicar tensores 3D, multiplicarlos con
vectores 3D, poder cambiar las expresiones de sus celdas por otras expresiones y finalmente
debe poder visualizar por pantalla textualmente el tensor 3D.
(...)
3 - Diseño
A continuación vamos a proceder a realizar la etapa de diseño, en esta etapa
mediante los diagramas de clase, se muestra cuales son los atributos y métodos que van a
tener finalmente en la implementación. Esta visión de la aplicación es de gran ayuda para los
desarrolladores que una vez comenzado el proyecto tengan que integrarse en el, de forma que
la comprensión del mismo sea mucho más rápida.
En este apartado también se muestran las relaciones que existen entre las clases, así
como los diferentes tipos de empaquetamiento que pueden tener sus atributos y métodos.
Además se podrán ver ejemplos de uso algunos de los constructores y métodos, así
como la explicación detallada de algunos de ellos debido a su especial complejidad o
características singulares.
Comenzaremos con un diagrama de clases que nos va a mostrar la totalidad de las
clases y las relaciones existentes entre los mismos. Para a continuación profundizar en cada
una de las clases creadas.
(...)
3.1 - Constantes, variables y funciones globales.
A diferencia de otros lenguajes orientados a objetos como puede ser Java, C++ puede
beneficiarse de algunas de las características de los lenguajes estructurados como C. En este
caso vamos a hacer uso de variables, constantes, plantillas y funciones globales, que podrán
ser usados desde cualquier clase, sin necesidad de instanciar clase alguna previamente.
3.1.1 - Constantes globales
Las constantes que se muestran a continuación nos permiten codificar un código
mucho más legible y fácil de seguir. De esta manera utilizaremos “DOWN” y “UP” para
indicar que la variable global “gravity” contiene los valores 0 o 1 respectivamente. Así
mismo las constates “YES” o “NO” las utilizaremos para indicar que la variable global
“atomization” contiene los valores 0 o 1 respectivamente. En el apartado de variables
globales, vamos a poder ver para que se utilizan las variables “gravity” y “atomization”
(...)
3.2 - Clase Matrix
Como podemos ver en el diagrama de clases general de la librería mostrado al inicio
del capitulo de diseño, la clase Matrix es una de las más importantes ya que de ella dependen
otras clases como son la clase Vector3D y la clase Tensor3D, las cuales por la herencia, que
es una de las características de los lenguajes orientados a objetos como C++, van a poder
hacer un uso directo de los métodos y atributos protegidos y públicos de esta clase.
(...)
Haciendo uso de la reutilización de código, se ha implementado el método
anteriormente escrito llamado “Operations”, que es el encargado de hacer las operaciones de
suma, resta y producto vectorial de objetos Vector3D. Para hacer estas operaciones de forma
correcta podemos observar que antes tenemos que calcular la base reducida,
“Reduced_Base”; método que se localiza en la clase System. Una vez obtenida esta base,
transformamos los dos objetos Vector3D mediante el método “Rotation_Matrix” a dos
nuevos objetos Vector3D, en la nueva base reducida. Ahora ya podemos operar entre los
objetos Vector3D y realizar la operación pertinente según hayamos indicado mediante el
parámetro “flag”
(...)
3.4.2 - Elementos privados
• Atributos
Base* base;
Atributo que almacena un puntero a un objeto de tipo Base que será su base asociada.
• Métodos privadoss
void init( string name ,
matrix mat ,
Base * base ,
System * system );

Método que inicializa todos los atributos de un objeto de tipo Vector3D. Estos
atributos son nombre, GiNaC::matrix, puntero a objeto Base y puntero a objeto System que se
pasan como parámetros. Este método es utilizado por los constructores de la clase Tensor3D. 3 - Diseño
62
static Vector3D Operations ( const Vector3D & Vector3DA ,
const Vector3D & Vector3DB ,
int flag );

Método estático que realiza operaciones entre dos objetos de la clase Tensor3D. El
tipo de operación dependerá del valor que le indiquemos mediante el parámetro “flag”. Estos
valores pueden ser 1 para realizar sumas de objetos Tensor3D o 2 para realizar restas de
objetos Tensor3D.
3.4.3 - Elementos públicos
• Costructores
Tensor3D ( void );
Constructor que genera un objeto de tipo Tensor3D sin inicializar sus atributos.
Tensor3D ( string name ,
Matrix mat ,
Base * base );
Constructor que genera un objeto de tipo Tensor3D con un nombre dado, un objeto
de tipo Matrix y el puntero a un objeto de tipo Base al que está asociado.
(...)
4 - Ejemplo amplio
A continuación podemos ver un programa implementado con la librería lib3d_mec_GiNaC
para ver de una forma más global, el tipo de problemas que se pueden resolver con la misma. Con
este ejemplo fue presentada la librería en el congreso MULTIBODY DYNAMICS 2007, CCOMAS
Thematic Conference en Milan.
(...)
5 - Instalación y uso

Para que podamos instalar la librería lib3d_mec_GiNaC correctamente y poder
ejecutar programas que hagan uso de la misma, debemos seguir los siguientes pasos:
Tener instaladas las librerías GiNaC, GLS y CLN para poder compilar la librería y el
programa GNUPLOT para poder visualizar resultados mediante gráficas. Para ello podemos
descargarnos los paquetes binarios de dichas librerías mediante los siguientes scripts.
$ apt-get install libginac1.3c2a libginac-dev libcln4 libcln-dev
gnuplot libgsl0 libgsl0-dev
Una vez hemos instalado correctamente las librerías en nuestro ordenador, ahora
podemos proceder a instalar la librería lib3d_mec_GiNaC, para ello, donde se encuentre la
librería, ejecutamos las siguientes instrucciones
(...)
6 - Bibliografía
• “Desarrollo de software con C++”, Russel Winder I.S.B.N. 84-7978-21-8-8
• “Thinking in C++, Volume 1: Introduction to Standard C++”, Bruce Eckel I.S.B.N. 0-
13-979809-9
• “Thinking in C++, Vol. 2: Practical Programming”, Bruce Eckel, Chuck Allison I.S.B.N.:
0-13-122552-9
• “GiNaC tutorial” http://www.ginac.de/tutorial.pdf
• “GiNaC Reference Manual 1.4.0” http://www.ginac.de/reference.pdf
• "Kinematic and Dynamic Simulation of Multibody Systems. The Real-Time Challenge",
ISBN 0-387-94096-0, 440 pp., Springer-Verlag, New-York, 1994
• “Mecánica de La Partícula y del Sólido Rígido, J. Agulló”, Publicaciones OK Punt,
I.S.B.N.: 84-920850-5-3, 2000
• Apuntes propios asignatura Mecánica de 2º II
• “Numerical Recipes in C, The Art of Scientific Computing”. William H. Press, “et al.”.
CAMBRIDGE UNIVERSITY PRESS. 6 - Bibliografía
145
7 – Fecha y firma
Este proyecto ha sido realizado por LUIS MIGUEL ARRONDO MARTÍNEZ ,
estudiante de INGENIERÍA TÉCNICA EN INFORMÁTICA DE GESTIÓN
Fdo: Luis Miguel Arrondo Martínez
Pamplona, Noviembre de 2007