vendettaaaaa
06-01-2013, 14:05
Ciao,
ho pensato di aprire questo topic per condividere il lavoro che ho intrapreso tempo fa, sperando di avere qualche compagno di avventura e ricevere stimoli dal lavorare "in team".
Il mio obiettivo è scrivere nel tempo una libreria di classi per il calcolo numerico, nel tentativo di emulare quanto fatto da un mio professore (le BzzMath 6.0, che trovate qua (http://homes.chem.polimi.it/gbuzzi/index.htm)), cioè tutto ciò che serve ad un ingegnere (chimici noi, ma non solo) per svolgere calcoli (tipicamente integrazione di sistemi ODE, DAE, risoluzione di sistemi algebrici fortemente non lineari).
Tutto passa dall'algebra lineare, come mi ha insegnato il prof (e infatti una buona parte delle sue librerie sono classi per scrivere matrici, fattorizzate i vari modi, e vettori), quindi mi ho cominciato dallo scrivere le due classi base: una per vettori e l'altra per matrici (di double).
Un piccolo assaggio:
#ifndef GUARD_BBMATRIX_HPP
#define GUARD_BBMATRIX_HPP
#include <memory>
class BbVector;
class BbMatrix
{
public:
// Typedefs for the user
typedef double* iterator;
typedef const double* const_iterator;
typedef std::size_t size_type;
bool range_check(int i, int j) const;
private:
// Pointers to the array
double** myMatrix;
size_type nRows;
size_type nColumns;
bool hasSize;
std::allocator<double> auxAlloc;
std::allocator<double*> matrixAlloc;
void create();
void create(size_type r, size_type c, const double& val);
void create(const BbMatrix& other);
void create(const BbMatrix* other);
void uncreate();
void delete_matrix();
void delete_array(int i);
void shrink(int newRows, int newColumns);
public:
BbMatrix() { create(); }
BbMatrix(int r, int c, double val = 0.);
BbMatrix(const BbMatrix& other) { create(other); }
~BbMatrix() { uncreate(); }
double& operator()(int i, int j) { range_check(i, j); return myMatrix[i][j]; }
const double& operator()(int i, int j) const { range_check(i, j); return myMatrix[i][j]; }
double* operator[](int k) { return myMatrix[k]; }
const double* operator[](int k) const { return myMatrix[k]; }
void resize(int newRows, int newColumns);
bool size() const { return hasSize; }
size_type n_rows() const { return nRows; }
size_type n_columns() const { return nColumns; }
BbMatrix& operator=(double val);
BbMatrix& operator=(const BbMatrix& other);
BbVector get_row(int i) const;
BbVector get_column(int j) const;
void swap_rows(int swapped, int with);
void swap_columns(int swapped, int with);
void set_diagonal(double val);
void seek_pivot_and_swap_rows(int column);
void insert_row(int i, const BbVector& row);
void insert_column(int j, const BbVector& col);
void push_back_row(const BbVector& row);
void push_back_column(const BbVector& col);
void delete_row(int i);
void delete_column(int i);
void chop_row();
void chop_column();
void transpose();
};
Ora, quello che vorrei fare è: trovare qualcuno per portare avanti lo sviluppo di queste librerie in modo da avere un incentivo a lavorarci su, visto che ovviamente così come sono non ci si può fare molto.
Penso sia una buona occasione per approfondire sia la conoscenza dell'analisi numerica (inizialmente mi ero messo a scrivere queste classi per poter scrivere gli algoritmi di eliminazione e fattorizzazione di Gauss, per non stare lì a fare i conti a mano) che del linguaggio (ad esempio, per me è stato molto istruttivo imparare ad usare allocator per l'allocazione dinamica delle matrici).
Come lavorare: non ci ho pensato molto, ho avuto l'idea di aprire il topic poco fa...comunque immagino che dovremmo stabilire:
- una convenzione per la scrittura di codice (ad esempio io uso camel case per variabili, funzioni scritte con l'underscore e tutto in minuscolo, ecc);
- come condividere il codice (penso che Github o equivalenti siano inevitabili)
- un ritmo di lavoro. Dato che è un progetto amatoriale direi ritmo blando ma costante, per mantenersi sempre freschi sull'argomento.
Chi è interessato si faccia sotto :)
ho pensato di aprire questo topic per condividere il lavoro che ho intrapreso tempo fa, sperando di avere qualche compagno di avventura e ricevere stimoli dal lavorare "in team".
Il mio obiettivo è scrivere nel tempo una libreria di classi per il calcolo numerico, nel tentativo di emulare quanto fatto da un mio professore (le BzzMath 6.0, che trovate qua (http://homes.chem.polimi.it/gbuzzi/index.htm)), cioè tutto ciò che serve ad un ingegnere (chimici noi, ma non solo) per svolgere calcoli (tipicamente integrazione di sistemi ODE, DAE, risoluzione di sistemi algebrici fortemente non lineari).
Tutto passa dall'algebra lineare, come mi ha insegnato il prof (e infatti una buona parte delle sue librerie sono classi per scrivere matrici, fattorizzate i vari modi, e vettori), quindi mi ho cominciato dallo scrivere le due classi base: una per vettori e l'altra per matrici (di double).
Un piccolo assaggio:
#ifndef GUARD_BBMATRIX_HPP
#define GUARD_BBMATRIX_HPP
#include <memory>
class BbVector;
class BbMatrix
{
public:
// Typedefs for the user
typedef double* iterator;
typedef const double* const_iterator;
typedef std::size_t size_type;
bool range_check(int i, int j) const;
private:
// Pointers to the array
double** myMatrix;
size_type nRows;
size_type nColumns;
bool hasSize;
std::allocator<double> auxAlloc;
std::allocator<double*> matrixAlloc;
void create();
void create(size_type r, size_type c, const double& val);
void create(const BbMatrix& other);
void create(const BbMatrix* other);
void uncreate();
void delete_matrix();
void delete_array(int i);
void shrink(int newRows, int newColumns);
public:
BbMatrix() { create(); }
BbMatrix(int r, int c, double val = 0.);
BbMatrix(const BbMatrix& other) { create(other); }
~BbMatrix() { uncreate(); }
double& operator()(int i, int j) { range_check(i, j); return myMatrix[i][j]; }
const double& operator()(int i, int j) const { range_check(i, j); return myMatrix[i][j]; }
double* operator[](int k) { return myMatrix[k]; }
const double* operator[](int k) const { return myMatrix[k]; }
void resize(int newRows, int newColumns);
bool size() const { return hasSize; }
size_type n_rows() const { return nRows; }
size_type n_columns() const { return nColumns; }
BbMatrix& operator=(double val);
BbMatrix& operator=(const BbMatrix& other);
BbVector get_row(int i) const;
BbVector get_column(int j) const;
void swap_rows(int swapped, int with);
void swap_columns(int swapped, int with);
void set_diagonal(double val);
void seek_pivot_and_swap_rows(int column);
void insert_row(int i, const BbVector& row);
void insert_column(int j, const BbVector& col);
void push_back_row(const BbVector& row);
void push_back_column(const BbVector& col);
void delete_row(int i);
void delete_column(int i);
void chop_row();
void chop_column();
void transpose();
};
Ora, quello che vorrei fare è: trovare qualcuno per portare avanti lo sviluppo di queste librerie in modo da avere un incentivo a lavorarci su, visto che ovviamente così come sono non ci si può fare molto.
Penso sia una buona occasione per approfondire sia la conoscenza dell'analisi numerica (inizialmente mi ero messo a scrivere queste classi per poter scrivere gli algoritmi di eliminazione e fattorizzazione di Gauss, per non stare lì a fare i conti a mano) che del linguaggio (ad esempio, per me è stato molto istruttivo imparare ad usare allocator per l'allocazione dinamica delle matrici).
Come lavorare: non ci ho pensato molto, ho avuto l'idea di aprire il topic poco fa...comunque immagino che dovremmo stabilire:
- una convenzione per la scrittura di codice (ad esempio io uso camel case per variabili, funzioni scritte con l'underscore e tutto in minuscolo, ecc);
- come condividere il codice (penso che Github o equivalenti siano inevitabili)
- un ritmo di lavoro. Dato che è un progetto amatoriale direi ritmo blando ma costante, per mantenersi sempre freschi sull'argomento.
Chi è interessato si faccia sotto :)