[C++] Librerie per algebra lineare e metodi numerici

[vendettaaaaa]

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), 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

[[Kendall]]

Ho avuto modo per la mia tesi di laurea di lavorare sulla realizzazione di una app per windows store (windows 8) che espletasse diverse funzionalità di algebra lineare (dalle basilari operazioni su matrice fino a decomposizioni, risoluzione di sistemi lineari, autovalori/autovettori e quant'altro.
Per quanto concerne questo ho lavorato in C# (quindi niente C++) però ho avuto modo di effettuare diverse ricerche sull'argomento "algebra lineare e programmazione".

Io ti consiglio di affidarti a librerie già realizzate ed ottimizzate con i migliori algoritmi di calcolo, e di realizzare da te tutto quello che concerne l'impiego di tale librerie per il tuo scopo preciso.

In ambiente scientifico è molto utilizzato (per lo meno da quanto mi diceva la docente di calcolo numerico) la libreria LAPACK.

[vendettaaaaa]

Originariamente inviato da [Kendall]

Ho avuto modo per la mia tesi di laurea di lavorare sulla realizzazione di una app per windows store (windows 8) che espletasse diverse funzionalità di algebra lineare (dalle basilari operazioni su matrice fino a decomposizioni, risoluzione di sistemi lineari, autovalori/autovettori e quant'altro.
Per quanto concerne questo ho lavorato in C# (quindi niente C++) però ho avuto modo di effettuare diverse ricerche sull'argomento "algebra lineare e programmazione".

Io ti consiglio di affidarti a librerie già realizzate ed ottimizzate con i migliori algoritmi di calcolo, e di realizzare da te tutto quello che concerne l'impiego di tale librerie per il tuo scopo preciso.

In ambiente scientifico è molto utilizzato (per lo meno da quanto mi diceva la docente di calcolo numerico) la libreria LAPACK.

Grazie, la conosco e l'ho utilizzata in passato insieme ad altre cariatidi dell'analisi numerica (DASPK ad esempio), ma voglio proprio fare io una libreria, e per scopo didattico e per utilizzare la OOP

[[Kendall]]

Originariamente inviato da vendettaaaaa

Grazie, la conosco e l'ho utilizzata in passato insieme ad altre cariatidi dell'analisi numerica (DASPK ad esempio), ma voglio proprio fare io una libreria, e per scopo didattico e per utilizzare la OOP

Capito. Guarda, ora come ora se fosse stato il portare avanti un progetto amatoriale in C# ti avrei dato una mano anche volentieri, ma il C++ è un linguaggio che apprezzo usare molto meno di quanto io lo conosca.

[vendettaaaaa]

Qualche settimana fa avevi scritto in qualche thread che l'allocazione dinamica in C# avviene più rapidamente che in C++ (in un thread riguardo alle matrici...non ricordo bene), e da quella volta m'è rimasta la pulce nell'orecchio di provare, quindi potrei convertire la classe Vector in C# giusto per fare un test (non so di che tipo, magari allocazione di un Vector di 100 elementi per N milioni di volte...) e potremmo lavorarci un pochino.
Oppure, meglio, se vuoi ti do il sorgente della classe e ci pensi tu, non sono molte righe di codice, penso sui 400 max. Giusto per far qualcosa "in team con qualcun altro", senza contare che sto imparando il C# da un mesetto e mi tornerebbe utile! Che ne dici?

[[Kendall]]

Originariamente inviato da vendettaaaaa

Qualche settimana fa avevi scritto in qualche thread che l'allocazione dinamica in C# avviene più rapidamente che in C++ (in un thread riguardo alle matrici...non ricordo bene), e da quella volta m'è rimasta la pulce nell'orecchio di provare, quindi potrei convertire la classe Vector in C# giusto per fare un test (non so di che tipo, magari allocazione di un Vector di 100 elementi per N milioni di volte...) e potremmo lavorarci un pochino.
Oppure, meglio, se vuoi ti do il sorgente della classe e ci pensi tu, non sono molte righe di codice, penso sui 400 max. Giusto per far qualcosa "in team con qualcun altro", senza contare che sto imparando il C# da un mesetto e mi tornerebbe utile! Che ne dici?

Prova a girarmelo (ti mando la mia mail tramite pm) che ci do un'occhiata nel weekend (prima faccio fatica perchè di giorno lavoro). Magari in certi punti particolarmente contorti (se ce ne sono) inseriscimi anche qualche commentino che non fa mai male.

P.S: riguardo all'allocazione dinamica, questo è dovuto per forza di cose al meccanismo di allocazione e deallocazione propri dei linguaggi non gestiti (come il C++) e di quelli gestiti (come il C#), che non significa che a livello generale il C# sia più perfomante.

[Vincenzo1968]

Iscritto. Argomento interessante. Mi dispiace solo di non poter contribuire direttamente a causa delle mie scarse conoscenze nell'ambito del calcolo numerico e dell'algebra lineare. Ma iscritto.