Newsgroup: it.comp.lang.c++
Titolo: Richiesta di "suggerimento" urgente

Devo scrivere un compilatore che sia in grado di riconoscere e trattare
espressioni nella forma:
(i,2:12:2)(j,1:10:3)...(k,2:13:5)((i+12)*j)/k
dove (i,2:12:2) e' un for i cui elementi sono rispettivamente: la
variabile,
il valore "basso", il valore "alto" e il passo. I for sono al massimo
13.
Ho gia' risolto (o almeno spero) il problema delle espressioni mediante
l'implementazione di un DAG senza sottoespressioni comuni e che si
occupa della semplificazione delle costanti, della semplificazione delle
espressioni contenenti elementi neuti etc.
Ho definito le classi relative al singolo nodo del dag, alle
costanti,agli operatori,ai for (contenuti in una tabella gestita con la
tecnica dell'hashing),alla memoria,alle liste e alle variabili che sono
conservate in una tabella sempre gestita con una tecnica di hashing
(ogni variabile
deve interfacciarsi -mediante puntatori- sia all'albero delle
espressioni,al quale da il valore, sia alla tabella for corretta, dalla
quale riceve il valore).
Mi resta da risolvere ancora un problema notevole. Non so come gestire e
soprattutto come implementare l'enorme tabella contenente tutti i
possibili valori dell'espressione,determinati secondo lo schema:
i=2 j=1 ... k=2 Computa(exp)
i=2 j=1 ... k=7 Computa(exp)
...
i=2 j=4 ... k=2 Computa(exp)
i=2 j=4 ... k=7 Computa(exp)
....
....
i=4 j=2 ... k=2 Computa(exp)
i=4 j=2 ... k=7 Computa()
...
...
Grazie in anticipo per l'aiuto...
Gesmina
--
Posted from 
ten.dimi.uniud.it
 [158.110.144.132]
via Mailgate.ORG Server - 
http://www.mailgate.org


Potresti usare una matrice multidimensionale, dove le dimensioni
rapresentano i parametri dell'espressione.
A causa dei passi, avresti pero' celle inutilizzate.
Per risparmiare spazio potresti implemetare una matrice "bucata"
che si occuperebbe di ottimizzare la memoria allocata.
Potresti partire definendo un vettore a dimensione fissa
con spazi vuoti:
#include <vector>
template < class Element, int Start, int End, int Step >
// sarebbe meglio se il tuo compilatore te lo permette:
//typedef std::vector<Element>::size_type _size_type;
//template <class Element, _size_type, _size_type End, _size_type Step >
class hatchvector
{
public:
 typedef std::vector<Element> vector;
 typedef vector::value_type value_type;
 typedef vector::reference reference;
 typedef vector::size_type size_type;
private:
 std::vector<Element> vec;
 static size_type convert_position(size_type pos)
  {return (pos - Start) / Step;}
public:
 static int start_value() {return Start;}
 static int end_value() {return End;}
 static int step_value() {return Step;}
 static int size() {return convert_position(end_value()) + 1;}
 hatchvector() : vec(size()){}
 reference operator[](size_type pos)
 {
  size_type vector_pos = convert_position(pos);
  return vec[vector_pos];
 }
};
quindi un vettore di interi che parte dall'elemento 4, termina con l'elemento  10
ed ha un passo 2 lo istanzi nel seguente modo
hatchvector<int, 4, 10, 2> vec;
una mtrice "bucata" bidimensionale dovra' essere definito come
un vettore che ha come elementi il vettore definito prima e che parte
dalla posizione 3, termina con la posizione 6 ed ha passo 3:
typedef hatchvector<int, 4, 10, 2> first_vector;
hatchvector<first_vector, 3, 6, 3> matrix;
...quindi
matrix[3][4] = 6;
ecc.
Oreste Notelli.