Nous mettons en œuvre une bibliothèque de compression matricielle basée sur une syntaxe de grammaire bidimensionnelle modifiée. Nous avons maintenant deux approches pour nos types de données - laquelle sera la meilleure en cas d'utilisation de la mémoire? (nous voulons compresser quelque chose;)).
Les grammaires contiennent des non terminaux avec exactement 4 productions ou un terminal sur le côté droit. Nous aurons besoin des noms de Productions pour les contrôles d'égalité et la minimisation de la grammaire.
La première:
-- | Type synonym for non-terminal symbols
type NonTerminal = String
-- | Data type for the right hand side of a production
data RightHandSide = DownStep NonTerminal NonTerminal NonTerminal NonTerminal | Terminal Int
-- | Data type for a set of productions
type ProductionMap = Map NonTerminal RightHandSide
data MatrixGrammar = MatrixGrammar {
-- the start symbol
startSymbol :: NonTerminal,
-- productions
productions :: ProductionMap
}
Ici, nos données RightHandSide enregistrent uniquement les noms de chaîne pour déterminer les prochaines productions, et ce que nous ne savons pas ici, c'est comment Haskell enregistre ces chaînes. Par exemple, la matrice [[0, 0], [0, 0]] a 2 productions:
a = Terminal 0
aString = "A"
b = DownStep aString aString aString aString
bString = "B"
productions = Map.FromList [(aString, a), (bString, b)]
La question ici est donc de savoir à quelle fréquence la chaîne "A" est-elle vraiment enregistrée? Une fois dans aString, 4 fois en b et une fois dans les productions ou juste une fois dans aString et les autres détiennent simplement des références "moins chères"?
La deuxième:
data Production = NonTerminal String Production Production Production Production
| Terminal String Int
type ProductionMap = Map String Production
ici le terme "Terminal" est un peu trompeur car c'est en fait la production qui a un terminal comme côté droit. La même matrice:
a = Terminal "A" 0
b = NonTerminal "B" a a a a
productions = Map.fromList [("A", a), ("B", b)]
et la question similaire: à quelle fréquence la production est-elle sauvegardée en interne par Haskell? Peut-être que nous supprimerons les noms dans les productions si nous n'en avons pas besoin, mais nous ne sommes pas sûrs pour le moment.
Disons donc que nous avons une grammaire avec environ 1000 productions. Quelle approche consommera moins de mémoire?
Enfin une question sur les entiers dans Haskell: Actuellement, nous prévoyons d'avoir un nom en tant que chaînes. Mais nous pourrions facilement passer aux noms entiers, car avec 1000 productions, nous aurons des noms avec plus de 4 caractères (ce qui, je suppose, est de 32 bits?). Comment Haskell gère-t-il cela. Un Int est-il toujours 32 bits et Integer alloue la mémoire dont il a vraiment besoin?
J'ai également lu ceci: Conception d'un test de la sémantique de valeur / référence de Haskell - mais je ne peux pas comprendre ce que cela signifie exactement pour nous - Je suis plus un enfant java impératif qu'un bon programmeur fonctionnel: P