FoodCalc v. 1.3 <small><small><small><small>19981218</small></small></small></small>

FoodCalc est un programme simple pour le calcul de la consommation de nutriments à partir d’une liste de quantités de divers aliments ingérés et d’une liste indiquant la teneur en nutriments des divers aliments (table de composition).
Les programmes présentant des variantes de tels calculs abondent, mais la plupart d’entre eux ont une envergure limitée: certains sont liés à une table de composition spécifique, d’autres supposent une nouvelle saisie de toutes les données mêmes si ces données figurent déjà dans un fichier de l’ordinateur, d’autres encore sont incapables de traiter les réductions de nutriments dues à la cuisson ou ne les traite que de manière idiosyncrasique.
FoodCalc présente aussi un propos limité, mais dans les limites de ses possibilités, il est aussi bien flexible qu’efficace. Les nouveaux utilisateurs de FoodCalc doivent être ou bien programmeurs ou bien être au moins capables de préparer des fichiers "texte" et de saisir des commandes sur une ligne de commandes. Si ce n’est pas le cas, il faut s’adresser à un programmeur qui initie l’utilisateur au maniement du programme FoodCalc.
FoodCalc suppose qu’on dispose d’une liste de quantités ingérées et d’une table de composition sous forme de fichier "texte". Si ce n’est pas le cas, il faut d’abord saisir les données sur un éditeur ou tout autre système, par exemple une base de données ou un système de support d’interview. La plupart de ces systèmes sont capables d’exporter les données sous une forme compréhensible pour FoodCalc. Il faut également saisir sous forme de fichier "texte" les commandes qui instruisent FoodCalc de la manière dont les calculs doivent être effectués avant d’exécuter le programme FoodCalc, ce qui peut ne pas sembler très maniable au premier abord, mais ce qui permet de facilement effectuer les mêmes calculs sur des données différentes ou des calculs différents sur les mêmes données, de manière répétée, systématique et bien documentée. Ceci permet également à l’utilisateur d’intégrer FoodCalc à un programme plus vaste.
Les calculs effectués par FoodCalc sont relativement simples. Le programme présente cependant une certaine flexibilité, surtout en matière de traitement des réductions de teneur en nutriments dues à la cuisson des aliments.
FoodCalc est très efficace, ce qui rend possible de traiter assez rapidement la consommation de dizaines voire de centaines de milliers de personnes ayant chacune consommé des centaines ou des milliers d’aliments. Le temps nécessaire aux calculs pour FoodCalc dépend cependant largement de l’ordinateur mis à contribution. Actuellement FoodCalc est disponible pour Windows 95, Windows NT et HP-UX. Le code source est également disponible, et peut être facilement compilé sur la plupart des systèmes qui ont un compilateur ANSI C.

Le programme FoodCalc a été élaboré par Jesper Lauritsen. La rédaction de la version initiale et de certaines modifications ultérieures ont largement été soutenues par Diet, Cancer and Health project (projet régime alimentaire, cancer et santé) de la Danish Cancer Society (société danoise contre le cancer). Il est possible de se renseigner sur la nouvelle version du programme FoodCalc sur http://www.ibt.ku.dk/jesper/FoodCalc. En cas de questions, de commentaires ou pour signaler des bogues et des remèdes éventuels à ces bogues, contacter l’auteur par courrier électronique à Jesper.Lauritsen@acm.org.
Ce programme est du domaine public<small>. Il est donc libre à tous de l’utiliser et de le modifier à souhait. Cependant il faut toujours, en ce cas, citer l’auteur, Jesper Lauritsen. D’autre part, ni Jesper Lauritsen ni la Danish Cancer Society ne peuvent être tenus responsables des dommages éventuels occasionnés par ce programme. De plus, Jesper Lauritsen et la Danish Cancer Society ne donnent aucune garantie de quel type qu’elle soit en ce qui concerne la fonctionnalité ou la correction du programme que tout un chacun est libre d’utiliser, mais dont seuls les utilisateurs peuvent être tenus responsables en cas de non fonctionnement ou de non pertinence. </small>

La présente documentation est en deux parties. La première est un guide de l’usager, avec les sections suivantes:

Food table (foods file) [table de composition des aliments, fichier "aliment"]
Consumed amount (input file) [quantité consommée, fichier "entrée"]
Food calculations (commands file) [calculs sur les aliments, fichier "commande"]
Group by [catégorisation]
Transposing [transposition]
Cooking [cuisson]
Calculating new fields [calcul des nouvelles rubriques]
Groups file and more than one foods file [fichier "catégorie", fichier "plus-d’un-aliment"]
Recipes files [fichier "recette"]
Reducing from input and recipes [réduction des entrées et des recettes]
Weight reductions [réductions de poids]
Recipe reductions [réductions de recette]
Calculating recipe set fields [calcul des rubriques "insérer recette"]
Non-edible part [partie non-comestible]

Selecting foods [sélection des aliments]

La seconde partie est un guide de référence (référence guide) avec les sections suivantes:

Data files [fichiers de données]
Commands files [fichiers "commande"]
Commands [commandes]
Calling FoodCalc [activer FoodCalc]
Version history [historique des diverses versions]

Le guide de référence présente aussi des informations détaillées sur les diverses commandes: Log:, Verbosity:, Commands:, Save:, Decimal point:, Separator:, Comment:, Blip:, Foods:, Groups:, Recipes:, Food weight:, Ingredients:, Cook:, Weight cook:, Set:, Group set:, Recipe set:, No-calc fields:, Text fields:, Input:, Input format:, Input fields:, Input *fields:, Input scale:, Cook field:, Reduce field:, Weight reduce field:, Recipe reduce field:, Recipe weight reduce field:, Non-edible field:, Output:, Output format:, Output fields:, Transpose:, Group by:, Where:.

Table de composition des aliments, fichier "aliment" (food table, foods file)

La base des calculs est une base de données comprenant la teneur des divers aliments en nutriments – ce qu’on nomme une table de composition des aliments. Par nutriments FoodCalc entend aussi bien les macro-nutriments (énergie totale, teneur totale en matières grasses, teneur totale en protéines, etc.) que les micro-nutriments (vitamines, sels minéraux, etc.) (il serait peut-être plus correct de parler de composants des aliments plutôt que de nutriments). En vérité FoodCalc ne distingue pas entre les différents types de nutriments (sauf peut-être en spécifiant certaines règles de réductions après cuisson). FoodCalc traite donc tous les aliments de la table de composition sur pied d’égalité, et les aliments peuvent donc être des aliments de base, des aliments composés, voire des repas complets.
Chaque aliment doit être identifié par un nombre que nous nommons numéro d’identité de l’aliment (food id). Ces nombres doivent être des nombres positifs entiers, mais ne doivent pas forcément être consécutifs, ce qui permet un système de numération au choix de l’utilisateur.
Pour chaque aliment il faut répertorier les valeurs spécifiant sa teneur pour chaque nutriment. Toutes ces valeurs doivent être données pour une même quantité de l’aliment, en général pour 100 g d’aliment (ce que nous appelons la quantité de la table de composition - food table amount), mais il est possible de choisir n’importe quelle quantité unitaire, tant que cette même quantité unitaire est employée pour tous les nutriments et tous les aliments. Il n’est d’ordinaire pas nécessaire de spécifier explicitement cette quantité unitaire, mais ce peut être tout de même une bonne idée de le faire. Retournons maintenant à comment faire quoi ( how to do that).
L’unité de mesure de chaque nutriment peut être différente (mais le même nutriment doit évidemment être spécifiée par la même unité de mesure pour tous les aliments).
La table de composition doit avoir la forme d’un fichier "texte" (text file) ce qui signifie qu’il faut la préparer avec un éditeur, un système de traitement de texte (pour exporter le texte) ou, peut-être, l’exporter par le biais d’un système de base de données. L’exemple qui suit est un fichier "aliment" (food file) très limité:

food#,energy,fat,water,vit_d,calcium [aliment… matières grasses…eau]
381,766,12.1,68.9,0.60,7.0
1146,949,0.2,44,0,0

La première ligne (line) répertorie les noms des colonnes figurant dans la table. Nous appelons chacune de ces colonnes une rubrique (field), et disons donc que la première ligne est une liste de noms de rubriques. Chaque rubrique (field) est ou bien un numéro d’identité de l’aliment (food#) ou bien un nutriment (énergie, matières grasses, etc.). (Nous introduirons plus loin d’autres types de rubriques). Bien que cela ne soit pas explicitement indiqué, cet exemple spécifie toutes les valeurs par 100 g d’aliment (ici du collet de porc dégraissé et de la confiture d’abricot, tirés de la table de composition danoise, Danish national food table). Les nutriments ont une énergie totale en kJ, les matières grasses totales en g, le total de l’eau en g, la vitamine D en µg, et le calcium en mg. Mais il est à noter que tout ce que nous spécifions ici est le nom des rubriques concernées.
Il est très important de noter que FoodCalc ne traite pas les valeurs manquantes. Si vous omettez une des valeurs de la table, FoodCalc emploiera simplement la valeur 0 pour le nutriment concerné.

Quantité consommée, fichier "entrée" (consumed amount, input file)

La manière d’exprimer la quantité (amount) consommée des divers aliments dépend plus ou moins de la manière dont les informations ont été collectées. Il faut au minimum spécifier une liste de numéros d’identité de l’aliment (food id) et la quantité consommée de ces derniers. Ce numéro d’identité (food id) doit évidemment être défini à partir de la table de composition. La quantité peut être exprimée en grammes, en livres, ou toute autre unité de mesure, mais il faut bien sûr s’en tenir à une seule unité de mesure de manière consistante. Il n’est pas nécessaire d’utiliser la même unité de mesure que celle figurant dans la table de composition. Il est possible d’ajouter autant de valeurs supplémentaires qu’on le désire, comme l’identité des personnes, l’identification de l’occasion de prise des aliments, etc.
Répétons-le, les informations doivent figurer dans un texte (text file) et nous appelons un tel fichier un fichier "entrée" (input file). L’exemple suivant est à nouveau limité:

Person_id,food,amount [...aliment, quantité]
101,381,9
101,1146,20
102,381,11.5

Répétons que la première ligne (line) dénomme les rubriques (fields) (ici nous avons trois rubriques). Dans cet exemple, le fichier (file) contient des informations sur le nombre de personnes, dont chacune a consommé un certain nombre d’aliments (ce pourrait être les données d’un questionnaire de fréquence ou, peut-être, des données tirées d’un relevé). La première rubrique (field), "person_id", identifie la personne. La seconde rubrique, "food", identifie l’aliment consommé. La troisième rubrique, "amount", est la quantité (amount) consommée en grammes.

Calculs sur les aliments, fichier "commande" (food calculations - commands file)

Quand on veut effectuer des calculs sur les aliments, trois fichiers "texte" (text files) au moins sont toujours nécessaires : le fichier "aliment" (foods file), le fichier "entrée" (input file) et un fichier "commande" (commands file) qui spécifie le mode de calcul.
Suppposons que nous avons le fichier "aliment" (foods file) dans l’exemple ci-dessus dans le fichier "foods.txt" et le fichier "entrée" dans l’autre exemple ci-dessus dans le fichier "input.txt". Si nous voulons connaître les nutriments consommés pour chaque aliment ingéré nous avons besoin du simple fichier "commande" suivant :

; this is an example (ceci est un exemple)
Foods: "foods.txt" food#
Input: "input.txt" food amount
Input scale: 0.01 ; = 1/100
Output: "output.txt"

Le fichier "commande" peut contenir certains commentaires dans des lignes commençant par un point-virgule. Il est également possible d’inscrire des commentaires sur la même ligne qu’une commande, mais suivi d’un point-virgule (comme après la commande "échelle d’entrée:" -"input scale:" dans l’exemple ci-dessus). Les commandes du fichier sont chacune sur une ligne, et de telles lignes de commande commencent toujours avec le nom de la commande suivi de deux points, puis du contenu de la commande. La plupart des commandes peuvent être entrées dans n’importe quel ordre, FoodCalc ne différenciant pas entre les lettres de haut ou de bas de casse.
La commande "foods:" spécifie le nom du fichier contenant la table de composition (food table) et la rubrique "identité de l’aliment" (food id field). La commande "input:" spécifie le nom du fichier contenant les quantités consommées et le nom de la rubrique "identité de l’aliment" (food id field) ainsi que la rubrique "quantité" (amount field) dans ce fichier. La commande "échelle d’entrée:" (input scale:) spécifie le rapport entre l’unité de mesure de quantité figurant dans le fichier "entrée" (input file) et celle de la table de composition (food table). Dans le présent exemple l’unité de quantité du fichier "entrée" (input file) est le gramme et celle de la table de composition (food table) est 100 grammes, ce qui nous donne une valeur d’échelle d’entrées (input scale value) de 0.01 (= 1/100). Enfin la commande "output:" spécifie le nom du fichier où sont inscrits les résultats des calculs.

Si les commandes sont dans le fichier "example.fc", nous pouvons effectuer le calcul en entrant ce qui suit comme message de guidage (un message DOS ou un message UNIX shell, selon votre système d’exploitation):

foodcalc example.fc

Ceci donne un fichier "connection" nommé "example.log", et indiquant quelque peu ce qui a été fait et si des erreurs ont été commises. Après avoir exécuté FoodCalc il faut toujours contrôler s’il y a eu des erreurs dans un fichier "connection" (log file) qui a la forme suivante:

FoodCalc v. 1.2
Tue Jun 09 16:25:24 1998 (date)

Read 4 commands from file example.fc. (lu 4 commandes dans le fichier)

Read foods file foods.txt. Foods: 2. Fields:
food# energy fat water vit_d calcium

The food table contains 2 foods and the fields:(La table a 2 aliments et les rubriques:)
food# energy fat water vit_d calcium

Read input file input.txt. Lines: 3. Fields: 3 (lu le fichier "entrée")
person_id food amount

Wrote output file output.txt. Lines: 3. Fields: 9 (écrit le fichier "sortie")
person_id food amount food# energy fat water vit_d calcium

Le fichier "sortie" (output file) en résultant sera comme suit:

person_id,food,amount,food#,energy,fat,water,vit_d,calcium
101,381,9,381,68.94,1.089,6.201,0.054,0.63
101,1146,20,1146,189.8,0.04,8.8,0,0
102,381,11.5,381,88.09,1.3915,7.9235,0.069,0.805

Comme on peut le voir, il y a une ligne dans le fichier "sortie" (output file) pour chaque ligne du fichier "entrée" (input file). On peut également voir qu’il contient toutes les rubriques figurant dans le fichier "entrée" ainsi que toutes les rubriques du fichier "aliment" (foods file).
Les calculs effectués ici sont d’une extrême simplicité. Les grammes consommés du fichier "entrée" sont simplement multipliés par le facteur de l’échelle d’entrée (input scale factor) et par les valeurs pour chaque aliment du fichier "aliment" (foods file) (Par exemple on obtient, pour l’énergie dans la première ligne, une valeur énergétique de 9*0.01*766 = 68.94).

Catégorisation (Group by)

Dans l’exemple ci-dessus on a une ligne dans le fichier "sortie" pour chaque ligne du fichier "entrée". Il est cependant fréquent de souhaiter avoir les résultats synthétisés à un certain niveau. Si, par exemple, on souhaite la consommation totale de chaque individu, on peut ajouter les commandes suivantes au fichier "commande":

Group by: person_id

Ce qui donne dans le fichier "sortie":

person_id,energy,fat,water,vit_d,calcium
101,258.74,1.129,15.001,0.054,0.63
102,88.09,1.3915,7.9235,0.069,0.805

(energy=énergie; fat=matières grasses; water=eau)

FoodCalc a ainsi additionné les valeurs pour les nutriments de l’ensemble des aliments consommés par chaque personne, ce qui donne une ligne pour chaque personne dans le fichier "entrée". Il est à noter que le fichier "sortie" contient maintenant seulement une catégorie par rubrique et les rubriques "nutriment" tirées du fichier "aliment", ceci en raison du fait qu’il serait absurde d’y ajouter toute autre rubrique.

Prenons un exemple plus élaboré. Disons que nous avons des informations sur les aliments consommés par un certain nombre de personnes en un certain nombre d’occasions (par exemple les repas d’un seul jour). L’occasion de prise d’aliments est codée dans une rubrique supplémentaire comme "fco" dans le fichier "entrée". Nous avons également regroupé tous les aliments dans un certain nombre de catégories (légumes, fruits, viande, etc.). Chaque catégorie d’aliment est codée dans une rubrique supplémentaire comme "food_group" dans le fichier "aliment".
Si nous souhaitons la consommation totale de nutriments pour chaque individu à chaque occasion de prise d’aliments pour chaque catégorie d’aliment, nous pouvons le faire avec:

Group by: person_id,fco,food_group

Si la première rubrique ou celles qui suivent sont des rubriques "entrée", le fichier "entrée" doit être classé dans ces rubriques "entrée" (la version précédente de FoodCalc présentait davantage de limitations dans l’usage de la commande "group by:", mais toutes ces limitations ont désormais été levées).

Transposition (transposing)

Suposons qu’on utilise les commandes suivantes:

Group by: person_id, food_group
Output fields: person_id, food_group, energy

et que le résultat en soit le fichier "sortie" suivant:

person_id,food_group,energy
101,1,68.94
101,3,189.8
102,1,88.09

Pour chaque personne on a un certain nombre de lignes, et chaque ligne indique la contribution énergétique de chaque catégorie d’aliment. Cependant, si on souhaite importer ces données dans un système statistique ou graphique pour analyse, cette présentation n’est pas des meilleures. Supposons que tous les aliments de la table de composition ont des valeurs pour la catégorie d’aliment (food_group values) coimprise entre 1 et 4. Nous pouvons alors utiliser les commandes:

Group by: person_id
Output fields: person_id
transpose: food_group 4 energy

et le résultat sera alors le fichier "sortie" suivant:

person_id,energy1,energy2,energy3,energy4
101,68.94,0,189.8,0
102,88.09,0,0,0

Nous n’avons plus qu’une seule ligne pour chaque personne, mais une rubrique "énergie" pour chaque catégorie d’aliment (food_group). On dit alors qu’on a transposé l’énergie dans la catégorie "aliment" (food_group). On peut avoir autant de commandes "transpose:" qu’on le souhaite.

Cuisson (cooking)

De nombreuses tables de composition contiennent seulement ou presque des aliments crus. La plupart des gens préfèrent cependant les aliments cuits, et la cuisson peut modifier de manière substantielle la quantité de nutriments contenus dans les aliments. L’interprétation de la cuisson par FoodCalc est très simple mais également relativement flexible.

FoodCalc interprète la cuisson en utilisant ce qu’on appelle des rubriques "réduction" (reduce fields). Si on a un fichier "aliment" avec les rubriques suivantes:

Food_id,vit_a,sodium,calcium,vit_a_boil,vit_a_fry,min_boil,min_fry

(boil=bouillir; fry=frire)

on peut alors utiliser les commandes suivantes:

Cook: boil vit_a_boil vit_a
Cook: boil min_boil sodium,calcium
Cook: fry vit_a_fry vit_a
Cook: fry min_fry sodium,calcium

(cook=cuisson)

Les rubriques "vit_a", "sodium" et "calcium" sont des rubriques "nutriment" et les rubriques "vit_a_boil", "min_boil", "vit_a_fry" et "min_fry" sont des rubriques "réduction" (reduce fields). Les commandes spécifient que si on fait bouillir un aliment, il faut réduire la teneur en vitamine A par le facteur de la rubrique "vit_a_boil", et la teneur en sodium et calcium par le facteur de la rubrique "min_boil". Si on fait frire l’aliment, il faut réduire la teneur en vitamine A par le facteur de la rubrique "vit_a_fry", et réduire la teneur en sodium et calcium par le facteur de la rubrique "min_fry".

De cette manière, on peut parfaitement contrôler de combien de nutriments il faut réduire la teneur de chaque aliment pour chaque mode de cuisson. On peut spécifier autant de modes de cuisson qu’on le souhaite, les dénommer comme on veut, et utiliser autant de rubriques "réduction" qu’il est nécessaire.
Cette méthode permet de mettre en œuvre des facteurs de réduction différents pour chaque aliment et chaque mode de cuisson (on peut utiliser des fichiers "catégorie" - groups files, comme il sera expliqué plus loin, pour utiliser les mêmes facteurs de réduction pour les catégories d’aliment).

Ces rubriques "réduction" doivent avoir des valeurs qui sont le facteur de réduction de chaque nutriment. Supposons que pour un aliment donné la teneur en vitamine A doivent être réduite de 10% à la cuisson, la rubrique "vit_a_boil" devra alors avoir une valeur de 0,1. On peut également spécifier des valeurs négatives, c’est-à-dire que la teneur en certains nutriments augmente à la cuisson, ce qui peut être utile pour l’eau dans certains aliments à l’ébullition et pour les matières grasses en cas de friture.

On utilise une rubrique supplémentaire dans le fichier "entrée" pour spécifier si et comment l’aliment consommé est cuit. Cette rubrique doit être spécifiée avec une commande rubrique "cuisson" (cook field:), comme le montre la ligne ci-dessous:

Cook field: cook boil,fry

Le premier argument de la commande "cook field:" est le nom de la rubrique dans le fichier "entrée", qui spécifie le mode de cuisson. Dans l’exemple, la rubrique "cuisson" (cook) a été utilisée. Le second argument doit être une liste des noms des divers modes de cuisson employés. La rubrique "cuisson" (cook) doit avoir la valeur 0 si l’aliment n’est pas cuit et la valeur 1 s’il est cuit par le premier mode de cuisson répertorié dans la commande (dans notre cas bouilli - boil), et la valeur 2 s’il est cuit selon le second mode de cuisson répertorié et ainsi de suite.

Nous verrons plus loin comment réaliser cuisson et autres réductions d’autres manières.

Il est à noter que lorsqu’une ligne du fichier "entrée" spécifie que l’aliment est cuit, la rubrique "quantité" du fichier "entrée" doit alors spécifier le poids cru de l’aliment consommé. Si on n’apprécie pas cette manière de faire, on peut, à la place, utiliser les recettes, ce qui sera expliqué plus loin.

Calcul des nouvelles rubriques (calculating new fields)

Dans notre tout premier exemple nous avions une rubrique "énergie" (energy) dans le fichier "aliment". Cependant ce n’est pas un fichier qu’il faut avoir dans une table de composition, la teneur énergétique totale étant en général à partir d’autres rubriques de la table de composition. Or si la cuisson réduit les valeurs de ces autres rubriques, il faudra aussi réduire l’énergie de manière peu évidente.
Une méthode commune de calcul de la teneur énergétique totale est d’effectuer l’opération suivante: 17*protein_total + 38*fat_total + 17*carbohyd_total + 30*alcohol (fat=matières grasses). Si le fichier "aliment" contient les rubriques "protein_tot", "fat_tot", "carb_total" et "alcohol" avec des valeurs en grammes, on peut créer une nouvelle rubrique qui contienne l’énergie totale en kJ avec la commande suivante:

Set: energy = 7*protein_total + 38*fat_total + 17*carbohyd_total + 30*alcohol

On peut créer autant de nouvelles rubriques qu’on le souhaite avec la commande "insérer:" (set:) Ces rubriques "insérer" peuvent être utilisées à peu près partout où une rubrique "table de composition en nutriments" (food table nutrient field) est disponible.

Ces rubriques "insérer" (set fields) sont calculées pour chaque aliment qui est calculé, et si la commande "group by:" est utilisée les valeurs des rubriques "insérer" seront additionnées comme dans n’importe quelle rubrique "table de composition en nutriments" (food table nutrient field). Cependant cela signifie qu’on ne peut pas utiliser la commande "set:" pour, par exemple, calculer le taux énergétique des matières grasses (pensez-y et vous comprendrez pourquoi!). D’où la variante suivante (pour "insérer catégorie"):

Group set: fat_energy_pct = 38*fat_total / energy * 100

Les rubriques "insérer catégorie" (group set fields) sont calculées après aggrégation en catégories et pourront donc calculer le taux énergétique des matières grasses de manière correcte. Si on se pose la question de savoir s’il est possible de n’utiliser que la commande "insérer catégorie:" (group set:) au lieu de la commande "set:", la réponse est que c’est très souvent possible (par exemple c’est probablement une bonne idée de faire de l’énergie un group set field plutôt qu’un group field). Mais pour des raisons techniques, il n’est possible d’utiliser que les group set fields dans les "output fields:", tandis que les rubriques "insérer" (set fields) peuvent l’être dans beaucoup d’autres commandes.

Une autre rubrique qu’il peut être utile de calculer est le poids des aliments consommés (qui sera identique à la rubrique "quantité" – amount, dans le fichier "entrée" si les aliments sont crus, mais qui pourra être différent si les aliments sont cuits). Cette rubrique sera plus tard utilisée dans la commande "food weight:" ("poids des aliments:"), c’est pourquoi nous en faisons ici une rubrique "insérer" (set field) et non une rubrique "insérer catégorie" (group set field). Si vous avez les rubriques ci-dessous ainsi que les rubriques ash (cendres) et water (eau) dans le fichier "aliment", vous pouvez effectuer le calcul comme suit:

Set: weight = protein_tot + fat_tot + carb_tot + alcohol + ash + water

Fichiers "catégorie", fichier "plus-d’un-aliment" (groups files, more than one foods file)

Si on a diverses catégories d’aliment qui présentent les mêmes valeurs pour une ou plusieurs rubriques, on peut utiliser les fichiers "catégorie" (groups files), ce qui est souvent nécessaire pour les rubriques "réduction" (reduce fields) où souvent on n‘a que des valeurs génériques pour les catégories d’aliment.
Pour utiliser un fichier "catégorie" (groups file) il faut avoir au moins une rubrique "catégorie de référence " (group reference field) dans le fichier "aliment". Ces rubriques "référence" spécifient à quelle catégorie un aliment déterminé appartient. De telles identités de catégorie (group id) doivent être des nombres entiers positifs. Si toute la rubrique "catégorie de référence " (group reference field) a la valeur 0 pour un aliment, c’est que le-dit aliment ne fait partie d’aucune des catégories définies.
Le fichier "catégorie" est un fichier "texte" (text file) très semblable à un fichier "aliment". Il doit contenir la rubrique "identité de catégorie" (group id field) et chaque catégorie doit avoir sa propre ligne. Le fichier "catégorie" peut contenir un nombre indéfini de rubriques supplémentaires.

Si notre fichier "aliment" (foods file) est comme suit :

Food_id,vit_a,group_id
400,3,1
401,2,3
402,2,1
403,3,0

et notre fichier "catégorie" (groups file) porte le nom de groups.txt comme:

Group_id,vit_a_boil,vit_a_fry
1,0.1,0.2
2,0.2,0.1
3,0.4,0.4

nous aurons alors la ligne de commandes suivante:

Groups: "groups.txt" group_id

Exactement comme si nous avions un fichier "aliment" (foods file) comme:

Food_id,vit_a,group_id,vit_a_boil,vit_a_fry
400,3,1,0.1,0.2
401,2,3,0.4,0.4
402,2,1,0.1,0.2
403,3,0,0,0

On peut avoir un nombre indéfini de fichiers "catégorie", et on peut aussi avoir un fichier "plus-d’un-aliment" (more than one foods file) si on le souhaite. Deux raisons commandent en général l’utilisation d’un tel fichier. En premier lieu on peut souhaiter avoir certains aliments dans un fichier et d’autres dans un autre fichier (par exemple si les données ont des sources différentes). Dans ce cas il est préférable d’utiliser les différentes valeurs d’identité de l’aliment (food id values) dans des fichiers différents. En second lieu il se peut qu’on souhaite disposer de certaines rubriques dans un fichier et de certaines autres dans un autre fichier (par exemple on peut souhaiter avoir les rubriques "nutriment" - nutrient fields, dans un fichier et les rubriques "réduction" - reduce fields, dans un autre). Dans ce cas il faut s’assurer que tous les aliments figurent bien dans les deux fichiers avec les mêmes valeurs d’identité de l’aliment (food id values). Si un aliment ne figure pas dans un des fichiers "aliment", toutes les rubriques définies dans ce fichier afficheront la valeur 0.
On spécifie les fichiers "aliment" simplement en utilisant plusieurs commandes "foods:".

On appelle table de composition des aliments (food table) la combinaison de tous les fichiers "catégorie" et "aliment" (cependant, nous verrons que les fichiers "recette" ajoutent des aliments à la table de composition et que la commande "insérer recette:" recipe set: peut ajouter des rubriques à cette même table).

Fichiers "recette" (recipes files)

On peut obtenir de nouveaux aliments en combinant divers aliments de la table de composition selon certaines recettes qui spécifient la quantité de chaque ingrédient intervenant dans la recette (aliment existant) et si ces ingrédient doivent être cuits et, si oui, leur mode de cuisson.

Il faut spécifier les recettes dans des fichiers "recette" (recipes files) qui ressemblent beaucoup à des fichiers "entrée" (input files) comme dans l’exemple ci-dessous:

Recipe_id,food,amount,cook
3001,400,30,1
3001,401,110,1
3001,403,5,0
3002,400,50,1

Le fichier contient quatre rubriques. La première est le numéro d’identité de la recette (recipe id), qui doit être un nombre entier positif. Ce numéro d’identité doit être unique et différent de tout autre numéro d’identité d’aliment (food id) (en fait, après que la recette est saisie, il y aura un aliment de la table de composition avec un numéro d’identité d’aliment - food id, identique à celui de la recette -recipe id). La seconde rubrique est le numéro d’identité d’aliment (food id) de l’ingrédient, qui doit présenter des valeurs pouvant être retrouvées dans un fichier "aliment" (foods file). La troisième rubrique est la quantité, qui peut être donnée en grammes ou toute autre unité, exactement comme dans les fichiers "entrée". Enfin on peut avoir une rubrique "cuisson" (cook field) exactement comme dans les fichiers "entrée". Le fichier doit présenter une ligne pour chaque ingrédient de chaque recette.
On peut aussi utiliser un autre format pour le fichier "recette", appelé star format (format "avec astérisque"). Avec ce format, l’exemple ci-dessus prendra la forme suivante:

*Recipe_id
food,amount,cook
*3001
400,30,1
401,110,1
403,5,0
*3002
400,50,1

Les deux exemples définissent exactement la même recette. Ils définissent deux nouveaux aliments (/recettes): l’aliment(/recette) 3001 qui se compose de 30 grammes de l’aliment 400, bouilli, 110 grammes de l’aliment 401, également bouilli, et 5 grammes de l’aliment 403, cru, ainsi que l’aliment 3002 qui se compose de 50 grammes de l’aliment 400, bouilli.

On utilise les fichiers "recette" (recipes file) avec la commande "recipes:", comme dans l’exemple ci-dessous:

Recipes: "recipes.txt" recipe_id food amount

La commande "recipes:" présente comme argument le nom du fichier "recette", le nom de la rubrique contenant le numéro d’identité de la recette (recipes id), le nom de la rubrique contenant le numéro d’identité d’aliment (food id) pour les ingrédients, et le nom de la rubrique "quantité d’ingrédient".

On se souvient que les valeurs des nutriments dans le fichier "aliment" et le fichier "catégorie" représentent implicitement une certaine quantité de l’aliment (par exemple par 100 grammes), et nous avons appelé cette quantité la quantité de table de composition, food table amount. Les quantités d’ingrédient peuvent atteindre n’importe quelle valeur pour une recette, mais pour pouvoir utiliser cette recette en tant que nouvel aliment dans la table de composition il faut normaliser la quantité totale obtenue en fonction de la quantité figurant dans la table de composition. De plus, la cuisson peut modifier certaines quantités pour certains ingrédients. FoodCalc effectue cette normalisation automatiquement, mais il faut lui indiquer la manière d’obtenir le poids de l’aliment cuit et la valeur de la quantité dans la table de composition.
Le poids des aliments cuits a été vu au chapitre Calcul des nouvelles rubriques (Calculating new fields), et on peut utiliser les recettes si on dispose de nouvelles rubriques qui calculent le poids d’un aliment après cuisson (cependant, si on ne cuit pas l’aliment, on peut simplement avoir une rubrique "poids", weight, dans le fichier "aliment" qui a une valeur 100 pour tous les aliments).
Il faut alors le spécifier avec la commande "food weight:" , comme ci-dessous:

Food weight: 100 protein_tot,fat_tot,carb_tot,alcohol,ash,water

Le premier chiffre est la valeur de la quantité figurant dans la table de composition (food table amount) et la somme des rubriques répertoriées devrait être le poids de l’aliment. Si on a défini une nouvelle rubrique "poids" (weight field) comme dans l’exemple calculé plus haut, on peu simplement utiliser:

Food weight: 100 weight

Dans l’exemple ci-dessus la recette 3002 contient seulement l’aliment 400, bouilli. Pourquoi alors élaborer une telle recette quand on peut se contenter de spécifier l’aliment 400, bouilli, directement dans le fichier "entrée"? La différence réside dans le fait que si on utilise l’aliment 400, bouilli, dans le fichier "entrée", il faut également spécifier le poids consommé cru, tandis qu’en utilisant la recette 3002 dans le fichier "entrée" il faut spécifier le poids consommé cuit.

FoodCalc permet de spécifier la quantité négative d’un ingrédient, ce qui est probablement intéressant si l’ingrédient est l’eau (avec des teneurs nulles pour tous les nutriments sauf l’eau elle-même). Dans ce cas, l’interprétation peut être que l’eau est éliminée de la recette par le fait qu’elle s’évapore en cours de cuisson. La teneur en eau des recettes est très importante en raison du fait que la proportion d’eau influence le niveau de tous les nutriments quand on prélève une quantité déterminée de la recette totale.

Une fois définies, les recettes se comportent exactement comme des aliments simples définis dans un fichier "aliment", et on s’y réfère comme à de simples aliments dans le fichier "entrée". Cependant, lorsqu’on répertorie suivant les rubriques de la table de composition (par exemple par numéros d’identité d’aliment - food id ou par catégorie d’aliment), on peut souhaiter obtenir des catégories d’ingrédients plutôt que des catégories de recettes. Par exemple, si on souhaite obtenir la quantité de vitamine A fournie par les légumes, on voudra grouper en catégories qui distinguent les légumes des autres types d’aliment. Mais si les recettes sont comme des aliments, on n’obtiendra pas la contribution des carottes utilisées dans les recettes. Pour regrouper par ingrédients plutôt que par recettes, il faut utiliser la commande suivante:

Ingredients: keep

(keep= conserver)

On utilisera la commande ingredients: keep que lorsque cela est nécessaire, car cela rend FoodCalc relativement plus lent.

On aura souvent une catégorisation des aliments dans le fichier "aliment", exprimée par une ou plusieurs catégories. Si on ajoute des recettes à la table de composition, ces recettes/aliments auront la valeur 0 pour toutes les rubriques qui ne sont pas des rubriques "nutriment", ce qui signifie que les recettes auront toujours la valeur 0 pour de telles rubriques. On peut modifier ce fait en disposant de rubriques dans le fichier "recette" portant le même nom que les rubriques "catégorie". Les valeurs du fichier "recette" seront alors utilisées dans la table de composition si on utilise la commande "ingredients:" ou bien avec l’argument final ou bien avec l’argument "keepx" ("keepx" est exactement comme "keep", excepté le fait que "keep" ne copie pas les valeurs des recettes dans la table de composition).

Réduction des entrées et des recettes (reducing from input and recipes)

Nous avons déjà évoqué la manière d’utiliser les rubriques "réduction" en cas de cuisson. Un type spécifique de cuisson suppose l’utilisation de rubriques "réduction" spécifiques de la table de composition.
On peut aussi utiliser les rubriques "réduction" du fichier "entrée" (input file) ou des fichiers "recette" (recipes files). De telles rubriques "réduction" ne sont pas liées à la rubrique "cuisson" (cook field) – une rubrique "entrée" ou "recette" peut être utilisée, que le mode de cuisson soit spécifié ou non. Ces rubriques "réduction" présentent probablement plus d’intérêt dans le cas des recettes.

Supposons qu’on ait une rubrique supplémentaire dans le fichier "recette" portant le nom de water_loss (perte d’eau) ainsi qu’une rubrique dans la table de composition avec le nom water (eau). La rubrique "water_loss" contient la proportion d’eau perdue pour un ingrédient donné lors de la cuisson. On entre alors la commande suivante dans FoodCalc:

Reduce field: water_loss water

Comme on le voit, la commande "rubrique réduction:" (reduce field) est exactement identique à la commande "cook:" ("cuisson:") excepté le fait qu’il n’est pas nécessaire de spécifier un mode de cuisson et que les rubriques "réduction" se trouvent dans le fichier "entrée" et/ou le fichier "recette" au lieu de se trouver dans la table de composition.
On peut combiner l’utilisation de rubriques "réduction" à partir de la table de composition ou du fichier "recette". Par exemple on peut utiliser une rubrique "réduction" à partir d’un fichier "catégorie" (groups file) pour spécifier la perte de micro-nutriments due au mode de cuisson, en combinaison avec une rubrique "réduction" à partir d’un fichier "recette" afin de spécifier la perte d’eau pour des ingrédients spécifiques de recettes spécifiques. On doit bien sûr être très prudent dans la réduction d’une rubrique "nutriment" par le biais d’une rubrique "réduction" de recette combinée à une "réduction" de la table de composition!

Réductions de poids (weight reductions)

La commande "rubrique réduction:" (reduce field:) utilise des rubriques "réduction" qui spécifient la réduction en termes de fractions de la valeur du nutriment. On peut aussi utiliser ce qu’on nomme des rubriques "réduction de poids" (weight reduce field) qui spécifient la réduction à effectuer en tant que fraction du poids de l’aliment.
Pour utilier une telle rubrique, FoodCalc doit connaître la quantité de la table de composition (food table amount) et le mode de calcul du poids de l’aliment en question, ce qu’il faut spécifier avec "food weight:", comme lors de l’utilisation des recettes (voir plus haut).
Certains pays ont pour habitude de spécifier les réductions d’eau et de matières grasses de cette façon. Sil faut signaler à FoodCalc qu’il faut utiliser des rubriques "réduction" par la commande "weight reduce field:" (rubrique "réduction du poids") comme dans l’exemple ci-dessous:

Food weight: 100 protein_tot,fat_tot,carb_tot,alcohol,ash,water
Weight reduce field: water_reduc water

Supposons qu’une recette contient 20 grammes d’un ingrédient qui présente une valeur de réduction d’eau (water_reduc) de 0.2. La rubrique "eau" de l’exemple ci-dessus sera donc réduite de 20*0.2 = 4.

Lorsqu’on réduit la teneur en matières grasses on peut souhaiter la spécifier sous forme de perte de poids. On compte d’ordinaire les matières grasses parmi les macro-nutriments, mais on peut être en présence de plusieurs micro-nutriments constituant plusieurs composantes des matières grasses, et on peut alors choisir de les réduire avec le même facteur que les matières grasses en tant que macro-nutriment, comme dans l’exemple suivant:

Weight reduce field: fat_reduc fat,fat_mono,fat_poly,fat_other

(other= autres)

Supposons qu’une recette contient 20 grammes d’un ingrédient qui présente une valeur de réduction des matières grasses (fat_reduc) de 0.1. La rubrique "matières grasses" de l’exemple ci-dessus sera alors réduite de 20*0.05 = 2, comme dans l’exemple ci-dessus avec l’eau. Si l’ingrédient a une teneur en matières grasses de 30 grammes par 100 grammes d’aliment, la teneur restante de l’ingrédient en matières grasses sera donc 30/100*20 - 2 = 4, ce qui signifie que la teneur en matières grasses a été réduite d’une fraction 2/(30/100*20) = 0.333. Dans l’exemple ci-dessus les rubriques fat_mono, fat_poly et fat_other seront donc réduites de la même fraction 0.333.
Si on a une liste de rubriques au sein de la commande "rubrique réduction du poids:" (weight reduce field:), la première rubrique pourra être une rubrique de calcul. Par exemple, si la somme des rubriques fat_mono, fat_poly et fat_other égale la teneur totale de l’aliment en matières grasses, on a alors besoin de la rubrique "matières grasses" de la table de composition, mais on peut, à la place, effectuer le calcul à l’aide de la commande "calcul:" (calculate).

On peut aussi utiliser les rubriques "réduction du poids" lors de la cuisson en utilisant simplement la commande "poids après cuisson:" (weight cook:) au lieu de la commande "cuisson:" (cook:), comme dans l’exemple ci-dessous:

Weight cook: boil water_boil water
Weight cook: fry water_fry water
Weight cook: boil fat_boil fat,fat_mono,fat_poly,fat_other
Weight cook: fry fat_fry fat,fat_mono,fat_poly,fat_other

Réductions de recette (recipe reductions)

Comme mentionné plus haut il est en général plus utile d’effectuer les réductions dans les fichiers "recette" que dans les fichiers "entrée". Mais il est à noter que les commandes "cook:", "weight cook:", "reduce field:" et "weight reduce field:" spécifient toutes des réductions au niveau de l’ingrédient. Parfois on ne souhaite pas être spécifique à ce point, mais seulement utiliser les mêmes réductions pour tous les ingrédients d’une même recette. On peut le faire à l’aide des commandes "recipe reduce field:" et "recipe weight reduce field:", comme dans l’exemple suivant:

Recipe reduce field: water_reduc water
Recipe weight reduce field: fat_reduc fat,fat_mono,fat_poly,fat_other

Les rubriques "réduction" de recette" doivent être des rubriques “avec astérisque” si on utilise un format avec astérisque (star format) sinon la valeur de la rubrique "réduction de recette" sera la même pour tous les ingrédients.
La commande "recipe reduce field:" est en fait un pseudonyme de la commande "reduce field:" (en y réfléchissant on se rend compte que c’est la même commande) mais on peut utiliser la commande "recipe reduce field:" au lieu de la commande "reduce field:" afin de légitimer la réduction par une même fraction de tous les ingrédients.
La rubrique "réduction du poids de la recette" (recipe weight reduce field:) fonctionne comme suit: la première rubrique de la liste des rubriques "nutriment" de la commande est récapitulée pour tous les ingrédients (appelons-la n_sum), le poids de tous les ingrédients étant lui aussi récapitulé (appelons-le w_sum). Si nous appelons r la valeur de la rubrique "réduction", FoodCalc calculera alors une fraction avec laquelle effectuer la réduction: (r * w_sum) / n_sum. Toutes les rubriques "nutriment" de la commande sont alors réduites par cette fraction pour tous les ingrédients de la recette.

Calcul des rubriques "insérer recette" (calculating recipe set fields)

La commande "insérer recette:" (recipe set:) est plus ou moins identique à la commande "insérer:" (set:) par le fait qu’elle calcule une expression et en introduit le résultat dans une rubrique. Cependant les commandes "insérer:" (recipe set:) sont uniquement calculées une fois que les fichiers "recette" sont lus, et non quand le fichier "entrée" l’est. L’expression donnée peut contenir des rubriques tirées des fichiers "recette" et la rubrique résultante sera introduite dans la table de composition, ce qui signifie que la rubrique résultante peut alors être utilisée comme n’importe quelle autre rubrique de la table de composition. Il en existe plusieurs usages très spécialisés.

Si un fichier "recette" contient la rubrique "catégorie de recette" (recipe_group) la commande:

Recipe set: recipgrp = recipe_group

déplacera alors la valeur de la catégorie de recette (recipe_group) vers la nouvelle valeur de la table de composition recipgrp pour toutes les recettes.

L’exemple précédent de rubrique "réduction de recette" (recipe reduce field:) pourrait avoir été écrit comme suit:

Recipe set: water = water * (1 - water_reduc)

Ceci n’est évidemment pas très intéressant, mas on voit l’usage qu’on peut faire de cette commande "insérer recette:" (recipe set:) pour d’autres réductions très spécialisées, etc...

Enfin, si, par exemple, on a une rubrique glycemic_index (index=indice) dans les fichiers "recette", on peut utiliser:

Recipe set: glycemic_load = carbonhydrate * glycemic_index

(load = charge)

Pour calculer une nouvelle rubrique glycemic_load dans la table de composition contenant la charge glycémique pour toutes les recettes.

Partie non-comestible (non-edible part)

De nombreux aliments présentent naturellement une partie non-comestible (les os, par exemple, dans une côte d’agneau) et une partie comestible (tout ce qui n’est pas les os dans la même côte d’agneau). La table de composition (fichiers "aliment" et "catégorie") ne doit comporter les teneurs en nutriments que pour la partie comestible des aliments, et la rubrique "entrée" et la rubrique "recette" devraient normalement présenter des rubriques "quantité" (amount fields) spécifiant les quantités ingérées.

Cependant, si on a une rubrique de la table de composition qui indique la valeur de la fraction non-comestible des aliments tels qu’ils sont usuellement achetés, on peut choisir de spécifier le poids total des aliments (partie comestible comme non-comestible) dans des rubriques "quantité" de la rubrique "entrée" et de la rubrique "recette", comme dans l’exemple ci-dessous:

non-edible field: non_edible

Dans cet exemple, la rubrique "non-comestible" (non_edible) de la table de composition doit contenir la fraction non-comestible (non_edible fraction) et toutes les rubriques "quantité" du fichier "entrée" et du fichier "recette" doivent contenir les poids totaux.
Plus intéressant est le fait qu’on peut spécifier que seules certaines quantités constituent des poids totaux et certaines autres le poids de la seule partie comestible, comme dans l’exemple ci-dessous:

non-edible field: non_edible non_ed_flag

(flag = indicateur)

Le second argument de la commande "rubrique non-comestible:" (non-edible field:) est le nom de la rubrique. Si cette rubrique ne se trouve pas dans un fichier "entrée" ou un fichier "recette", toutes les quantités du fichier doivent constituer le poids de la partie comestible. Si la rubrique est dans un fichier, alors elle doit avoir la valeur 0 ou 1. Si elle est 0, la quantité doit être le poids de la partie comestible, si elle est 1, la quantité est le poids total de l’aliment considéré.

Sélection des aliments (selecting foods)

Il est possible de commander à FoodCalc d’ignorer certains aliments ou d’ignorer tout sauf certains aliments, ce qui est particulièrement intéressant pour l’usage des commandes "fichiers recette:" (recipes files) et "ingrédients: garder" (ingredients: keep).
Il faut utiliser la commande "où:" (where:) pour sélectionner les aliments. La commande prise comme exemple ci-dessous sélectionne les aliments là où la rubrique "identité de l’aliment" (food_id) a la valeur 236 ou la rubrique "catégorie d’aliment" (food_group) a la valeur 4 ou 7:

where: food_id = 236 or group_id in (4,7)

Autre exemple, la commande suivante, qui sélectionne tous les aliments dont la catégorie principale (main_group) est supérieure à 7 ou les aliments dont la catégorie principale (main_group) est égale à 2 et les sous-catégories (sub_groups) 3, 4 ou 7:

where: main_group > 6 or (main_group = 2 and sub_group in (3,4,7))

Informations de référence (reference section)

Le reste du présent document est un ensemble d’informations de référence qui sont probablement surtout intéressantes pour les programmeurs qui souhaitent utiliser FoodCalc parallèlement à d’autres systèmes.

Fichiers de données (data files)

FoodCalc utilise un certain nombre de fichiers de données: foods files, input files, output files, groups files et recipes files. Tous ces fichiers sont normalement des fichiers "texte" (text files), et ils ont un format commun (seuls les fichiers "entrée" et "sortie" peuvent avoir un format différent comme il a été expliqué au chapitre des commandes "input format:", "input fields:" et "output format:").

Toute ligne des fichier de données qui est vide (qui ne contient que des blancs) ou dans lesquelles le premier caractère n’étant pas un blanc est un point-virgule (;) constitue une ligne de commentaire que FoodCalc ignore. Par blancs on entend espaces et tabulations. D’autres lignes peuvent comporter un point-virgule. En ce cas, la portion de la ligne partant du point-virgule et jusqu’à la fin est alors ignorée.
On peut donner à FoodCalc l’ordre d’utiliser n’importe quel autre caractère que le point-virgule en tant que caractère indiquant un commentaire pour tout fichier de données ou pour un seul (voir la commande "commentaire:" - comment:), ce qui peut se révéler utile si on souhaite utiliser le point-virgule comme séparateur.

Une ligne logique peut être poursuivie sur la ligne suivante en inscrivant un signe d’égalité (=) en tête de cette ligne.

Format normal (normal format)

La première ligne de non-commentaire d’un fichier de données doit être une liste de noms des rubriques du fichier. Ces noms doivent être séparés par un séparateur qui est d’ordinaire la virgule (,) et peut-être avec un blanc avant et/ou après ce caractère de séparation. Les noms des rubriques peuvent avoir n’importe quelle longueur et contenir n’importe quel caractère. Cependant si un nom contient des blancs, le séparateur ou le caractère de commentaire, il devra se présenter entre guillemets ("). Pour les lettres a à z, la casse de la lettre est sans signification. Ci-dessous on trouvera trois exemples de lignes autorisées pour les noms de rubriques:

Food_id,vit_a,vit_b ; this is a comment (=ceci est un commentaire)
; this is a comment line (=ceci est une ligne de commentaire)
Food#, vitaminA, vitaminB
# , "Vitamin A" , "Vitamin B" , ; this line continues below (=cette ligne continue)
= "A long and very stränge field name" (=un nom de rubrique bien long et étrange)

On peu donner à FoodCalc l’ordre d’utiliser n’importe quel autre caractère que la virgule comme séparateur pour tous les fichiers de données ou un seul (voir la commande "séparateur:" - separator:), ce qui est souvent en usage dans les pays où on emploie la virgule avant les décimales d’un nombre. Si on utilise un espace comme séparateur, les noms des rubriques peuvent n’être séparées que par un blanc (espace ou tabulation).

Toute ligne de non-commentaire après la liste des noms de rubriques doit être une liste de valeurs. Sur une telle ligne on doit trouver autant de valeurs qu’il y a de noms de rubriques. Les valeurs doivent être séparées par le séparateur et les blancs utilisés pour les noms de rubriques. Ces valeurs doivent normalement être numériques, mais on peut également utiliser la commande "rubrique texte:" (text fields:) pour spécifier que certaines rubriques peuvent contenir d’autre types de valeurs. De telles rubriques "texte" seront toujours ignorées lors de la lecture du fichier de données. Si une rubrique "texte" contient des caractères de séparation, de poursuite à la ligne ou de commentaire, elle doit se présenter entre guillemets (").
Il est possible d’ignorer une valeur (mais aucun séparateur), mais elle sera alors interprétée exactement comme le chiffre 0 (FoodCalc ne traitant pas les valeurs manquantes). Les valeurs numériques peuvent en général être des nombres entiers ou contenir des fractions (elles peuvent aussi être des nombres à virgule flottante), et elles peuvent être positives ou négatives (certains types de rubriques n’utilisent cependant que la partie entière des nombres et certains autres exigent l’utilisation de nombres positifs). Il ne doit jamais y avoir d’espaces au sein des nombres et on ne peut pas utiliser de séparateur pour les milliers. Ci-dessous on trouvera trois exemples de lignes comportant les valeurs de quatre rubriques, la dernière de ces rubriques étant une rubrique "texte":

1001,23,4.5,xx ; this is a comment (=ceci est un commentaire)
; this is a comment line (=ceci est une ligne de commentaire)
0203, 0023, -4.0, "x,;"
23 , , ; this line continues below (=cette ligne se poursuit sur la ligne suivante)
= -0.000004, xx yy

On peut modifier le caractère utilisé pour les décimales pour tous les fichiers de données ou pour un seul (voir la commande "point avant décimale:" - decimal point:) ce qui est souvent en usage dans les pays où on utilise la virgule avant les décimales (à noter que si on transforme le point décimal en virgule décimale, il faut aussi changer de séparateur).

Format avec astérisque (star format)

Nous avons plus haut décrit ce que nous appelons le format normal (normal format) des fichiers de données. On peut également utiliser un format "avec astérisque" (star format) dans les fichiers de données. Ce Star format est surtout utile pour les fichiers "recette" (recipes files) mais il peut aussi être utilisé pour tout type de fichier de données.
La première ligne de non-commentaire d’un fichier en format "avec astérisque" doit débuter par une astérisque (*) qui doit être suivie d’une liste de noms de rubrique. Ces rubriques seront appelées des rubriques "avec astérisque". La seconde ligne de non-commentaire doit également être une liste de noms de rubriques. Le fichier contiendra donc des rubriques de ces deux lignes.
Toute ligne suivant les deux lignes de noms de rubriques doit commencer par une astérisque, qui doit être suivie par autant de valeurs qu’il y a de rubriques "avec astérisque". Pour toute ligne suivante ne commençant pas par une astérisque, les rubriques "avec astérisque" y figurant prendront les valeurs de la ligne avec astérisque précédente.
Toute ligne suivant les deux lignes avec astérisque de noms de rubriques et ne commençant pas par une astérisque devra contenir autant de valeurs qu’il y a de rubriques "sans astérisque".

Le fichier de format normal ci-dessous:

field1, field2, field3
1, 2, 3
1, 4, 5
2, 6, 7
2, 8, 9

sera interprété par FoodCalc exactement comme le fichier de format avec astérisque suivant:

*field1
field2, field3
*1
2, 3
4, 5
*2
6, 7
8, 9

Fichiers standards (standard files)

Quand on spécifie le nom d’un fichier, on peut utiliser le nom de fichier spécial (special file name) "-". Sa signification dépend du type de fichier:

Log file: standard error (=fichier "connection": erreur standard)
Output file: standard output (= fichier "sortie": sortie standard)
All other types of files: standard input (=tout autre type de fichier: entrée standard)

La signification d’une erreur standard comme d’une entrée ou d’une sortie standard dépend du système d’exploitation mis à contribution.

Fichiers "commande" (commands files)

Lors de l’exécution de FoodCalc on peut spécifier un ou plusieurs fichiers "commande" sous forme d‘arguments afin que FoodCalc lise tous les fichiers. Au sein d’un fichier "commande" on peut également lire d’autres fichiers "commande" avec la commande "commands:". Si on ne donne aucun argument à FoodCalc, il lira les commandes à partir de l’entrée standard.
Dans les fichiers "commande" on peut utiliser des lignes de commentaires et de passage à la ligne comme dans les fichiers de données. L’ordre des commandes dans un fichier "commande" est sans importance et l’ordre des fichiers "commande" est aussi sans importance (cependant, pour certaines commande l’ordre des divers usages de la commande a son importance).

Commandes (commands)

Toutes les commandes commencent par un mot-clé suivi de deux points (:). La casse des lettes est sans importance dans un mot-clé, et on peut y utiliser des blancs supplémentaires. La liste suivante est une liste de toutes les commandes que FoodCalc comprend. Les commandes marquées d’un signe + peuvent être utilisées plus d’une fois, les autres ne pouvant l’être qu’au maximum une fois. Les commandes marquées d’un point d’exclamation (!) doivent être utilisées au moins une fois, les autres commandes étant facultatives.

	log: file-name connection: nom du fichier
	verbosity: number prolixité: nombre
+	commands: file-name commande: nom du fichier
	save: file-name sauvegarder: nom du fichier
	decimal point: character point décimal: caractère
	separator: character séparateur: caractère
	comment: character commentaire: caractère
	blip: number anomalie: nombre
!+	foods: file-name [id-field sep-char dec-point-char com-char] aliment: nom du fichier [identité de la rubrique, séparateur, point avant décimale, caractère de commentaire]
+	Groups: file-name [id-field-list sep-char dec-point-char com-char] Catégories: nom du fichier [liste d’identité de rubriques, séparateur, point avant décimale, caractère de commentaire]
+	Recipes: file-name [recipe-field food-field amount-field sep-char dec-point-char com-char] recette: nom du fichier [rubrique "recette", rubrique "aliment", rubrique "quantité", séparateur, point avant décimale, caractère de commentaire]
	food weight: weight field-list poids de l’aliment: liste des rubriques "poids"
	Ingredients: keep|keepx|sum ingrédients: (=garder…somme)
+	cook: type-name reduce-field field-list cuisson: nom du type, rubrique "réduction", liste de rubriques
+	Weight cook: type-name weight-reduce-field field-list poids après cuisson: nom du type, rubrique "réduction du poids", liste de rubriques
+	set: field = expression insérer: rubrique = expression
+	Group set: field = expression Insérer catégorie: rubrique = expression
+	recipe set: field = expression insérer recette: rubrique = expression
+	no-calc fields: field-list rubriques non calculées: liste de rubriques
+	text fields: field-list rubriques "texte": liste de rubriques
!	input: file-name [id-field amount-field sep-char dec-point-char com-char] entrée: nom du fichier [rubrique "identité", rubrique "quantité", séparateur, point avant décimale, caractère de commentaire
	input format: text|bin-native format d’entrée: binaire, autochtone
	input fields: field-list rubrique "entrée": liste de rubriques
	input *fields: field-list rubrique *"entrée": liste de rubriques
	input scale: scale échelle d’entrée: échelle
	cook field: cook-field type-list rubrique "cuisson": rubrique "cuisson", liste de modes de cuisson
+	reduce field: reduce-field field-list rubrique "réduction": rubrique "réduction", liste de rubriques
+	weight reduce field: weight-reduce-field field-list rubrique "réduction du poids": rubrique "réduction du poids", liste de rubriques
+	recipe reduce field: reduce-field field-list rubrique "réduction de recette": rubrique "réduction", liste de rubriques
+	recipe weight reduce field: weight-reduce-field field-list rubrique "réduction du poids de la recette": rubrique "réduction du poids", liste de rubriques
	non-edible field: non-edible-field [flag-field] rubrique "non-comestible": rubrique "non-comestible" [rubrique "indicateur"]
!	output: file-name [sep-char dec-point-char] sortie: nom du fichier [séparateur, point avant décimale]
	output format: text|text-no-head|bin-native format de sortie: texte, texte sans en-tête, binaire-autochtone
	output fields: field-list rubriques "sortie": liste de rubriques
	group by: field-list catégorisation: liste de rubriques
+	Transpose: field number field-list transposer: numéro de rubrique, liste de rubriques
	where: logical-expr où: expression logique

Les arguments des commandes doivent être séparés par un blanc ou plus. Si un argument contient des blancs, des virgules ou des points-virgules, il doit se présenter entre guillemets ("). Si un nombre est utilisé comme argument, il faut utiliser un point (.) avant les décimales. Si un argument est une liste de valeurs ou de noms, les éléments de la liste doivent être séparés par des virgules. Si certains arguments dans la liste ci-dessus sont entre crochets ([ ]) ils sont facultatifs. On peut laisser de côté tous les arguments facultatifs ou seulement quelques-uns ou uniquement le dernier.
Si un argument est une liste de rubriques (field-list) on peut répertorier les noms des rubriques en les séparant par une virgule. On peut également spécifier un certain ordre des rubriques en inscrivant le nom de la première rubrique, ensuite deux traits d’union (--), puis le nom de la dernière. Les rubriques et séries de rubriques peuvent, dans la même liste de rubriques (field-list), être séparées par des virgules. L’ordre des rubriques de la table de composition sera l’ordre dans lequel elles sont ajoutées à la table par les commandes "aliment:" (foods:) et "catégorie:" (groups:).

Activer (calling) FoodCalc

On exécute FoodCalc en entrant ce qui suit en message de guidage ou dans un fichier écrit:

foodcalc [options] [file-names]

Les noms de fichier doivent être les noms des fichiers "commande". Si plus d’un fichier est spécifié, ceux qui suivent le premier seront lus comme si les commandes étaient entrées à la fin du premier fichier. Si aucun nom de fichier n’est fourni comme argument, FoodCalc lira les commandes en entrée standard.

On peut, facultativement, donner une ou plus des options suivantes comme arguments avant tout argument de nom de fichier:

-v number -v nombre	The same as using the "verbosity:" command. This will also override any "verbosity:" commands in the commands files. Même chose qu’à l’usage de la commande “verbosity:” (prolixité). Toute autre commande “verbosity:” du fichier "commande" ne sera pas prise en compte.
-l file-name -l nom du fichier	The same as using the "log:" command. This will also override any "log:" commands in the commands files. Même chose qu’à l’usage de la commande “log:” (connection). Toute autre commande “log:” dans le fichier "commande" ne sera pas prise en compte.
-i file-name -i nom du fichier	This file will be used instead of the file name given as argument to the "input:" command. This is most useful when also using the -s command. Ce fichier sera utilisé aulieu du fichier dont le nom a été donné comme argument à la commande “input:” (entrée). Des plus utile quand on utilise la commande –s
-o file-name -o nom du fichier	This file will be used instead of the file name given as argument to the "output:" command. This is most useful when also using the -s command. Ce fichier sera utilisé au lieu du fichier dont le nom a été donné comme argument à la commande “output:” (sortie). Des plus utile quand on utilise la commande –s
-s file-name -s nom du fichier	See the description of the "save:" command for information about the -s option. Voir la description de la commande “save:” (sauvegarde) pour obtenir des informations quant à l’option –s.

Commande "connection:" (log: command)

log: file-name

(connection: nom du fichier)

La commande "log:" spécifie le nom du fichier où la connection à FoodCalc (FoodCalc log) sera inscrite. Si on n’utilise pas la commande "log:", FoodCalc prendra le nom de commandes donné comme argument à FoodCalc, enlèvera la terminaison ".fc" ou ".txt" et ajoutera la terminaison ".log". Le nom de fichier résultant sera utilisé pour le fichier "connection" (log file). Si on utilise la commande "log:", elle devra être la première commande du fichier "commande".

Commande "prolixité:" (verbosity: command)

Verbosity: number

(prolixité: nombre)

La commande "prolixité:" (verbosity: command) spécifie le degré de prolixité de FoodCalc lors de la rédaction du fichier "connection" (log file). Plus le nombre est élevé, plus FoodCalc sera prolixe. Par défaut le nombre 50 sera utilisé, ce qui est relativement prolixe. Actuellement, les niveaux de prolixité suivants ont été définis:

50	Default. (par défaut)
40	Do not print warning messages. (ne pas imprimer de message d’alerte)
30	Do not print the name of the log file to standard error. (ne pas imprimer le nom du fichier "connection" en tant qu’erreur standard)
20	Do not print any informational messages about files read and written. (n’imprimer aucun message d’information au sujet des fichiers lus ou écrits)
10	Do not print any error messages. (n’imprimer aucun message d’erreur)
1	Do not make a log file. (ne pas élaborer de fichier "connection")

Commande "commandes:" (commands: command)

+	Commands: file-name (commandes: nom du fichier)

La commande "commandes:" (commands:) est facultative et peut être utilisée plus d’une fois. Elle spécifie un fichier "commande" supplémentaire, et les commandes de ce fichier seront traitées comme elles avaient été entrées à la fin du fichier "commande" concerné.

Commande "sauvegarde:" (save: command)

save: file-name

(sauvegarde: nom du fichier)

La commande "sauvegarde:" est très spéciale. Quand on l’utilise, FoodCalc lira tous les fichiers "commande", "aliment", "catégorie" et "recette", mais ne lira pas le fichier "entrée" ni n’écrira le fichier "sortie". A la place, il sauvegardera toute information des fichiers "commande", "aliment", "catégorie" et "recette" en tant qu’argument de la commande "sauvegarde:" (save:) en utilisant un format binaire efficace. Plus tard on pourra exécuter la commande FoodCalc avec:

foodcalc –s save-file

Exécuté de cette manière, FoodCalc lira l’information dans le fichier binaire "sauvegarde" (binary save-file) et fonctionner comme si les fichiers "commande", "aliment", "catégorie" et "recette" originaux étaient donnés. Cependant on peut laisser de côté le nom des fichiers "connection", "entrée" et "sortie" (log file, input file et output file) figurant dans le fichier "commande" original en utilisant les options -l, -i et -o.

Ceci est surtout utile si on exécute FoodCalc de façon répétée avec différents (petits) fichiers d’entrée mais avec les mêmes fichiers "aliment", "catégorie" et "recette". FoodCalc peut également lire le fichier binaire "sauvegarde" beaucoup rapidement que les fichiers "aliment", "catégorie" et "recette" originaux.

Commande "point avant décimale:" (decimal point: command)

Decimal point: character

(point avant décimale, caractère)

Cette commande spécifie le caractère utilisé par défaut avant les décimales pour tous les fichiers de données (on peut ne pas en tenir compte pour des fichiers de données spécifiques). Si on utilise pas la commande "decimal point:", FoodCalc utilisera un point (.) par défaut avant les décimales.

Commande "séparateur:" (separator: command)

Separator: character

(séparateur: caractère)

Cette commande spécifie le caractère utilisé par défaut pour tous les fichiers de données (peut être ignoré pour des fichiers de données spécifiques). Si on n’utilise pas la commande "separator:", FoodCalc utilisera la virgule comme séparateur par défaut.

Commande "commentaire:" (comment: command)

Comment: character

(commentaire: caractère)

Cette commande spécifie le caractère à utiliser par défaut comme caractère de commentaire pour tous les fichiers de données (peut être ignoré pour des fichiers de données spécifiques). Si on n’utilise pas cette commande, FoodCalc utilisera le point-virgule (;) par défaut comme caractère de commentaire.

Commande "anomalie:" (blip: command)

blip: number

(anomalie: nombre)

Si on utilise la commande "blip:", FoodCalc écrira le nombre de lignes lues dans le fichier "entrée" comme erreur standard (normalement sur le terminal/l’écran), chaque fois qu’il aura lu autant de lignes qu’il en est spécifié comme argument pour la commande "blip:".

Commande "aliment:" (foods: command)

!+	foods: file-name [id-field sep-char dec-point-char com-char] (aliment: nom du fichier [rubrique "identité", séparateur, caractère avant décimale, caractère de commentaire])

Cette commande ordonne à FoodCalc de lire le fichier "aliment" avec le nom donné comme premier argument. Un fichier "aliment" est un fichier de données (data file) où chaque ligne définit un aliment. Une des rubriques du fichier doit être la rubrique "identité de l’aliment" (food id field) qui identifie les aliments. Cette rubrique sera une rubrique "ne-pas-calculer" (no-calc field). Les valeurs d’identité de l’aliment (food id values) doivent être des nombres entiers positifs uniques. Si le second argument de la commande "aliment:" (foods:) est utilisé ce doit être le nom de la rubrique "identité de l’aliment". Sinon, la première rubrique du fichier est utilisé comme rubrique "identité de l’aliment" (food id field). Le troisième, le quatrième et le cinquième argument peuvent être utilisés pour spécifier le séparateur, le caractère avant décimale et le caractère de commentaire pour le fichier "aliment".
On doit toujours avoir au moins une commande "aliment:" (foods:) et on peut en avoir autant qu’on le souhaite. Si on utilise plus d’un fichier "aliment", les fichiers ne doivent pas nécessairement comporter les mêmes rubriques ni les mêmes aliments. Ces fichiers "aliment" sont lus dans l’ordre dans lequel les commandes sont données. Si plus d’un fichier "aliment" définit la même rubrique pour le même aliment, la table de composition recevra la valeur du dernier fichier "aliment". Si un fichier "aliment" définit un aliment mais qu’aucun des fichiers "aliment" ne définit toutes les rubriques pour cet aliment, les rubriques manquantes auront la valeur 0.
Si on utilise plus d’un fichier "aliment", on aura normalement des fichiers avec les mêmes rubriques mais des aliments différents ou des fichiers avec des rubriques différentes (sauf la rubrique "identité") pour les mêmes aliments. Cependant il existe des situations où il est utile d’opérer une combinaison.

Commande "catégorie:" (groups: command)

+	groups: file-name [id-field-list sep-char dec-point-char com-char] (catégories: nom du fichier [rubrique "identité", séparateur, caractère avant décimale, caractère de commentaire])

Cette commande ordonne à FoodCalc de lire le fichier "catégorie" avec le nom donné comme premier argument. Un fichier "catégorie" est un fichier de données (data file) où chaque ligne définit une catégorie. Au moins une catégorie du fichier doit être la rubrique "identité de catégorie" qui identifie la catégorie. Les valeurs d’identité de catégorie (group id values) doivent être des nombres entiers positifs uniques. Si le second argument de la commande "catégorie:" (groups:) est utilisé, ce doit être les noms des rubriques "identité de catégorie" (group id fields). Sinon la première rubrique du fichier est utilisée comme simple rubrique "identité de catégorie". Le troisième, le quatrième et le cinquième argument peuvent être utilisés pour spécifier le séparateur, le caractère avant décimale et le caractère de commentaire pour le fichier "catégorie".
Les valeurs du fichier "catégorie" seront étendues à la table de composition. Avant cette expansion on doit déjà avoir, dans la table, des rubriques avec les mêmes noms que les rubriques "identité de catégorie" dans le fichier "catégorie". On peut les appeler des rubriques "catégorie de référence" (group reference fields). Toutes les rubriques du fichier "catégorie" seront ajoutées à la table de composition. Pour tous les aliments de la table de composition les rubriques "référence" doivent avoir ou bien la valeur 0 ou bien une valeur qui peut être retrouvée en tant que nombre d’identité de catégorie dans le fichier "catégorie". Si cette valeur est retrouvée dans le fichier "catégorie", toutes les valeurs de cette catégorie seront utilisées pour l’aliment en question. Si la valeur de référence de l’aliment (food reference value) est 0 toutes les rubriques "catégorie" auront des valeurs 0 pour l’aliment en question. Les rubriques "catégorie de référence " sont des rubriques "ne-pas-calculer" (no-calc fields).
On peut utiliser autant de fichiers "catégorie" qu’on le souhaite. Les fichiers "catégorie" sont développés dans l’ordre où les commandes "catégorie:" (groups:) sont données.

Commande "recette:" (recipes: command)

+	recipes: file-name [recipe-field food-field amount-field sep-char dec-point-char com-char] (recette: nom du fichier [rubrique "recette", rubrique "aliment", rubrique "quantité", séparateur, caractère avant décimale, caractère de commentaire])

Cette commande ordonne à FoodCalc de lire le fichier "recette" avec le nom donné comme premier argument. Un fichier "recette" est un fichier de données (data file) où chaque ligne definit un ingrédient d’une recette. Une des rubriques du fichier doit être la rubrique "identité de la recette" (recipe id field) qui identifie la recette. Les valeurs d’dentification de la recette (recipe id values) doivent être des nombres entiers positifs uniques (uniques à travers tous les fichiers "recette" et tous les fichiers "aliment"). Une autre rubrique doit être la rubrique "identité de l’aliment" (ingredient id field) qui identifie l’ingrédient dans la recette. Les valeurs d’identité de l’aliment (ingredient id values) doivent figurer dans la table de composition, ce qui identifie la substance constituant l’ingrédient. Une troisième rubrique doit être la rubrique "quantité" (amount field) qui spécifie la quantité de l’ingrédient utilisée. Si le second, le troisième et le quatrième argument sont founis à la commande "recette:" (recipes:), ils doivent être les rubriques "identité de la recette" (recipe id), "identité de l’ingrédient" (ingredient id) et "quantité" (amount). Sinon les première, seconde et troisième rubriques du fichier seront utilisées. Les cinquième, sixième et septième arguments peuvent être utilisés pour spécifier le séparateur, le point avant décimale et le caractère de commentaire pour le fichier "recette".
Tous les ingrédients d’une recette doivent se suivre immédiatement dans le fichier "recette". Si on édite manuellement les fichiers "recette", on utilisera normalement le format avec astérisque (star format) avec la rubrique "recette" comme rubrique "avec astérisque" (star field).
FoodCalc calcule la teneur totale de chaque recette en nutriments, qui sont alors normalisées comme décrit pour la commande "poids de l’aliment:" (food weight:). Les valeurs résultantes seront alors entrées dans la table de composition avec une identité d’aliment (food id) identique à l’identité de la recette (recipe id). L’effet de cette opération est que la recette peut alors être utilisée comme tout autre aliment.
Si on utilise la somme des ingrédients (ingredients: sum) et qu’un fichier "recette" a de quelconques rubriques ayant le même nom que les rubriques "ne-pas-calculer" de la table de composition, les fichiers "recette" concernés auront les mêmes valeurs pour tous les ingrédients d’une recette et une copie de ces valeurs sera transférée à la table de composition lorsque la recette (ou l’aliment) sera entrée dans la table. Si on utilise le format "avec astérisque" on transformera de telles rubriques "recette" en rubriques "avec astérisque".
On peut créer autant de fichiers "recette" qu’on le souhaite. Quand la commande "recette:" (recipes:) est donnée on doit aussi donner la commande "poids de l’aliment:" (food weight:).

Commande "poids de l’aliment:" (food weight: command)

food weight: weight field-list

(poids de l’aliment: liste des rubriques "poids")

Cette commande spécifie la quantité de la table de composition et les rubriques à ajouter au poids de l’aliment. Le premier argument spécifie pour quelle quantité d’aliment les valeurs des nutriments sont données dans la table de composition. C’est ce que nous appelons la quantité de table de l’aliment (food table amount), généralement 100 grammes.
Le second argument à la commande "poids de l’aliment:" (food weight:) doit être une liste de rubriques qui sont dans la table de composition ou qui sont des rubriques "insérer" (set fields). La somme des valeurs de ces rubriques (après toutes les réductions) doit exprimer le poids total de l’aliment (on doit normalement spécifier les rubriques contenant les valeurs de tous les macro-nutriments: total des protéines, total des matières grasses, total des hydrates de carbone, alcool, cendres et eau). Dans les recettes, tous les nutriments de tous les aliments seront alors normalisés avec le même facteur, la somme de tous les ingrédients étant alors identique à la quantité de table de l’aliment.

Commande "ingrédient:" (ingredients: command)

Ingredients: keep|keepx|sum

(ingrédients: garderlgarderxlajouter)

La commande "ingredients:" peut être utilisée avec un des mots-clés "keep", "keepx" ou "sum" comme argument. Si la somme est spécifiée les recettes se comporteront exactement comme de simples aliments, par défaut. Si on utilise "keep" ou "keepx" les recettes se comporteront alors comme si chacun des ingrédients les composant était spécifié séparément dans le fichier "entrée".
Si "sum" ou "keepx" sont utilisés n’importe quelle rubrique des fichiers "recette" ayant le même nom dans la table de composition sera copiée dans cette dernière lors de l’entrée des recettes dans la table. Si on utilise "keep" de telles rubriques garderont les valeurs que les ingrédients ont dans la table.

Commande "cuisson": (cook: command)

+	cook: type-name reduce-field field-list (cuisson: nom du mode de cuisson, rubrique "réduction", liste de rubriques)

La commande "cook:" spécifie comment opérer les réductions de nutriments résultant de la cuisson. Le premier argument doit être le nom du mode de cuisson. On peut choisir librement ce nom. Le second argument doit être le nom d’une rubrique de la table de composition (cette rubrique sera une rubrique "ne-pas-calculer" - no-calc field). Cette rubrique est appelée rubrique "réduction" (reduce field). Le troisième argument doit être une liste de noms de rubriques de la table de composition. L’objectif est que, pour un mode de cuisson donné, les valeurs de toutes les rubriques du troisième argument soient réduites par une fraction qui est la valeur de la rubrique "réduction". Si la rubrique "réduction" a la valeur 0, il n’y a pas de réduction. Si elle est positive, elle sera égale ou inférieure à 1. Si elle est négative, l’effet en sera d’accroître les valeurs des rubriques du troisième argument.
D’ordinaire on aura plus d’un mode de cuisson et on aura plusieurs commandes "cook:" pour chacun de ces modes de cuisson, car on dispose, dans la table de composition, d’un certain nombre de rubriques "réduction" qui chacune réduit divers nutriments.

Commande "poids après cuisson:" (weight cook: command)

+	weight cook: type-name weight-reduce-field field-list (poids après cuisson: nom du mode de cuisson, rubrique "réduction du poids", liste de rubriques)

La commande "weight cook:" est une variante de la commande "cook:", la seule différence étant que le second argument n’est pas une rubrique "réduction" mais une rubrique "réduction du poids". La rubrique "réduction du poids" (weight reduce field) doit figurer dans la table de composition et spécifier ne fraction du poids de l’aliment. La première rubrique de la liste de rubriques devra être réduite par une fraction égale à la fraction du poids de l’aliment donnée. Toute autre rubrique de la liste de rubriques doit également être réduite par une fraction égale à la fraction par laquelle la première rubrique a été réduite. La première rubrique de la liste doit être une rubrique de la table de composition (food table field) ou une rubrique "insérer" (set field), toute rubrique additionnelle devant être une rubrique de la table de composition.
La commande "weight cook:" n’est d’ordinaire utile que lorsque la première rubrique de la liste de rubriques est un macro-nutriment (ou de la cendre ou de l’eau). On peut librement combiner l’utilisation des commandes "cook:" et "weight cook:". Si on utilise la commande "weight cook:" on doit également utiliser la commande "food weight:".

Commande "insérer: " (set: command)

+	set: field = expression insérer: rubrique = expression

La commande "insérer:" ("set:") créera une nouvelle rubrique avec le même nom que la rubrique à gauche du signe d’égalité ("=") et la même valeur que l’expression. On peut utiliser l’expression avec la syntaxe EBNF suivante:

Exp	::=	Exp1  { +|-  Exp1 }
Exp1	::=	Exp2  { *|/  Exp2 }
Exp2	::=	[ - ] Exp3
Exp3	::=	Number (nombre)
	|	Field-name (nom de la rubrique)
	|	(  Exp  )

Toute rubrique de l’expression doit être ou bien une rubrique de la table de composition ou bien une rubrique "insérer" antérieure. Toute rubrique "insérer" sera calculée pour chaque aliment calculé, et si la commande "group by:" ("catégorisation:") est utilisée elle sera ajoutée exactement comme une rubrique "nutriment". Pour chaque commande on notera si une rubrique "insérer" peut être utilisée comme argument, mais les rubriques "insérer" peuvent en général être utilisées à peu près partout où une rubrique "nutriment de la table de composition" peut l’être.

Commande "insérer catégorie:" (group set: command)

+	group set: field = expression insérer catégorie: rubrique = expression

La commande "group set:" ("catégorisation:") créera une nouvelle rubrique, de manière très semblable à la commande "set:", mais si la commande "group by:" est utilisée, les rubriques "group set" seront calculées après que les aggrégations en groupes ont été opérées, ce qui signifie qu’on peut utiliser la commande "group set:" pour calculer des objets comme les indices et les taux (par exemple le taux d’énergie totale provenant des matières grasses). Les rubriques "group set" ne peuvent être utilisées que dans la commande "output fields:" ("rubriques sortie:") et dans les commandes "group set:" ultérieures.

Commande "insérer recette:" (recipe set: command)

+	recipe set: field = expression insérer recette: rubrique = expression

La commande "recipe set:" créera une nouvelle rubrique de la même manière que la commande "set:", mais la rubrique est alors calculée pour chaque ingrédient de la recette considérée et la rubrique est alors ajoutée à la table de composition (si la rubrique figure déjà dans la table, sa valeur changera, prenant celle de l’expression). C‘est pourquoi les rubriques "recipe set" peuvent être utilisées exactement comme n’importe quelle autre rubrique de la table.
Toute rubrique de l’expression peut être une rubrique de la table de composition, une rubrique "insérer" ou une rubrique "recette".

Commande "calculer:" (calculate: command)

+	calculate: new-field additive-list calculer: rubrique nouvelle, liste additionnelle

La commande "calculate:" n’existe que pour la compatibilité rétroactive. On doit maintenant utiliser la commande "set:"!
On peut utiliser la commande "calculate:" pour créer de nouvelles rubriques dont les valeurs sont la somme des valeurs pesées (et éventuellement réduites) des rubriques de la table de composition. Le premier argument doit être le nom de la nouvelle rubrique. Le second argument doit être une liste de noms de rubriques de la table de composition (ou de rubriques antérieurement définies à l’aide de la commande "calculate:"). Les valeurs de ces rubriques seront additionnées. On peut entrer un nombre avant chaque nom de la liste (mais également séparer le nombre et le nom par une virgule). La valeur d’une telle rubrique sera ensuite pesée à l’aide de ce nombre avant d’être ajoutée à la somme.

Commande "rubriques ne-pas-calculer:" (no-calc fields: command)

+	no-calc fields: field-list rubriques ne-pas-calculer: liste de rubriques

La commande "no-calc fields:" ("rubriques ne-pas-calculer:") prend comme argument une liste de noms de rubriques de la table de composition. Ces rubriques seront alors des rubriques "ne-pas-calculer" ("no-calc fields"). Il est à noter que beaucoup d’autres commandes ont un effet secondaire, celui de créer des rubriques "ne-pas-calculer". Les rubriques de ce type sont supposées être des rubriques "nutriment". Elles ne sont pas pesées en quantités, ne seront pas aggrégées en catégories par la commande "group by:" et ne seront pas réduites par cuisson (cooking)

Commande "rubriques texte:" (text fields: command)

+	text fields: field-list rubriques texte: liste de rubriques

La commande "text fields:" prend comme argument une liste de noms de rubriques. Toutes les rubriques ayant un de ces noms dans les fichiers "aliment", "catégorie", "recette" et "entrée" seront des rubriques "texte". Ces rubriques "texte" peuvent avoir n’importe quelle valeur, mais sont totalement ignorées par FoodCalc. Toutes les rubriques qui ne sont pas des rubriques "texte" ne peuvent avoir que des valeurs numériques.

Commande "entrée:" (input: command)

!	input: file-name [id-field amount-field sep-char dec-point-char com-char] entrée: nom du fichier [rubrique "identité", rubrique "quantité", caractère de séparation, point après décimale, caractère de commentaire]

Cette commande ordonne à FoodCalc de lire le fichier "entrée" ("input file") aved les noms donnés comme premier argument. Un fichier "input" est un fichier de données ("data file") où chaque ligne donne la quantité consommée d’un aliment donné. Une des rubriques doit être la rubrique "identité consommation" ("consumption id"). Les valeurs de cette rubrique doivent figurer dans la table de composition, et elle identifie l’aliment consommé. Un autre rubrique doit être la rubrique "amount" ("quantité") qui spécifie la quantité consommée. Si les second et troisième arguments sont donnés à la commande "input:" ils doivent être les noms de la rubrique "consumption id" et celui de la rubrique "amount". Sinon, la première et la seconde rubrique du fichier seront utilisées.
FoodCalc multipliera la quantité à l’aide de l’échelle d’entrée ("input scale") et la valeur sera multipliée par toutes les rubriques "nutriment" de la table de composition (les rubriques "nutriment", "nutrient" sont toutes des rubriques "ne-pas-calculer"). Après cela, toutes les réductions et tous les calculs de nouvelles rubriques pourront être opérés.

Commande "format d’entrée:" (input format: command)

input format: text|bin-native

format d’entrée: textelbinaire-autochtone

La commande "input format:" peut être utilisée pour spécifier le format du fichier "entrée" ("input"), et elle peut être utilisée avec le mot-clé "text" comme avec le mot-clé "bin-native" comme argument. Si le mot-clé "text" est utilisé, le fichier "input" doit être un fichier de données (cependant, voir également la commande "input fields:" - "rubriques entrée:"), ceci par défaut.
Si le mot-clé "bin-native" ("binaire-autochtone") est utilisé, la commande "input fields:" doit être utilisée pour spécifier les noms des rubriques. Les fichiers "entrée" doivent seulement comprendre les valeurs, et ces dernières doivent avoir la forme d’un nombre binaire à double précision et à virgule décimale flottante sans marqueurs de fin de ligne ou de fin de fichier. Ce format sera différent selon les plates-formes. Si on génère un fichier avec un logiciel C, on emploiera des variables de type double et on devra ouvrir le fichier à l’aide du mode "wb". Si on génère le fichier avec SAS on devra employer une commande FILE avec "LRECL=(8*number-of-fields = nombre-de-rubriques) RECFM=F", et on devra appliquer le format RB8.
On ne doit utiliser le format d’entrée "bin-native" que lorsqu’on dispose d’une grande quantité de données et qu’on souhaite raccourcir la durée de l’opération. FoodCalc peut lire un fichier "bin-native" relativement plus rapidement qu’un fichier de données.

Commande "rubriques entrée:" (input fields: command)

input fields: field-list

rubriques entrée: liste de rubriques

Normalement le fichier "input" est un fichier de données où les noms des rubriques figurent dans la première ligne du fichier n’étant pas une ligne de commentaire. On peut, à la place, utiliser la commande "input fields:" pour nommer les rubriques, auquel cas il ne faut pas avoir les noms des rubriques dans le fichier "input".
Il faut toujours utiliser la commande "input fields:" ("rubriques entrée:") quand on utilise la commande "save:" ("sauvegarde:") ou la commande "input format: bin-native".

Commande "*rubriques entrée: " (input *fields: command)

input *fields: field-list

*rubriques entrée: liste de rubriques

On ne peut utiliser la commande "input *fields:" que lorsqu’on utilise aussi la commande "input fields:" ("rubriques entrée"). Quand on utilise la commande "input *fields:" le fichier "entrée" (input file) doit être en format "avec astérisque" (star format), exceptées les deux lignes de noms de rubriques. Les rubriques de la commande "input *fields:" seront des rubriques "avec astérisque" et les rubriques de la commande "input fields:" ne le seront pas.

Commande "échelle d’entrée:" (input scale: command)

input scale: scale

échelle d’entrée: échelle

L’argument de la commande "input scale:" doit être un nombre, et ce nombre est multipplié par toutes les quantités entrées et toutes les quantités des recettes. Si la table de composition a des teneurs en nutriments exprimées en n unités par aliment, et que les rubriques "quantité" utilisent les mêmes unités, on peut alors utiliser la valeur 1/n comme argument de la commande "input scale:". Si on n’utilise pas cette commande "input scale:" la valeur 1 sera utilisée.

Commande "rubrique cuisson:" (cook field: command)

cook field: cook-field type-list

rubrique cuisson: rubrique cuisson, liste de modes de cuisson

Le premier argument de la commande "cook field:" doit être le nom d’une rubrique. Si ce nom figure dans le fichier "entrée", ce fichier sera une rubrique "cuisson". Si le nom figure dans un fichier "recette", ce fichier sera une rubrique "cuisson". On peut avoir une rubrique "cook" seulement dans le fichier "entrée" ou seulement dans le fichier "recette", mais on peut également une rubrique "cuisson" à la fois dans le fichier "entrée" et le fichier "recette", auquel cas les rubriques "cuisson" ("cook") doivent avoir le même nom!
Le second argument doit être une liste de noms de modes de cuisson, tous ces modes devant être définis à l’aide des commandes "cook:".
Si une rubrique "cook" a la valeur 0, ceci spécifie que l’aliment en question ne doit pas être cuit. Sinon, la rubrique doit avoir une valeur positive inférieure ou égale au nombre de modes de cuisson du second argument de la commande "cook field:". La valeur indique le mode de cuisson qui a le même nombre ordinal dans la liste que la valeur de la rubrique "cook". La manière dont la cuisson est réalisée doit être définie à l’aide des commandes "cook:".

Commande "rubrique réduction:" (reduce field: command)

+	reduce field: reduce-field field-list rubrique réduction: rubrique réduction, liste de rubriques

La commande "reduce field:" est utilisée pour spécifier les réductions de nutriments dépendant des valeurs figurant dans le fichier "entrée" ou le fichier "recette". Le premier argument doit être le nom d’une rubrique. Si cette rubrique figure dans le fichier "entrée", cette rubrique "entrée" sera une rubrique "réduction". Si le nom de la rubrique figure dans un fichier "recette", cette rubrique "recette" sera une rubrique "réduction". On peut avoir une rubrique "réduction" seulement dans le fichier "entrée", seulement dans le fichier "recette", ou bien dans les deux, auquel cas les rubriques "réduction" doivent avoir le même nom! Le second argument doit être une liste de noms des rubriques de la table de composition.<bt> Toutes les valeurs de ces rubriques seront réduites par la fraction qui est la valeur de la rubrique "réduction". Si la rubrique "réduction" a la valeur 0, il n’y aura pas de réduction, si elle est positive, elle devra être inférieure ou égale à 1, et si elle est négative, son effet est d’accroître les valeurs des rubriques de la table de composition.
On peut définir autant de rubriques "réduction" qu’on en a besoin.

Commande "rubrique réduction du poids:" (weight reduce field: command)

+	weight reduce field: weight-reduce-field field-list rubrique réduction du poids: rubrique réduction du poids, liste de rubriques

La commande "weight reduce field:" ("rubrique réduction du poids") est une variante de la commande "reduce field:". La seule différence entre elles est que son second argument n’est pas une rubrique "réduction" mais une rubrique "réduction du poids". La rubrique "réduction du poids" doit figurer dans le fichier "entrée" et/ou dans le fichier "recette", et doit spécifier une fraction du poids de l’aliment concerné. La première rubrique de la liste de rubriques sera réduite par une quantité égale à cette fraction du poids de l’aliment. Toute autre rubrique de la liste de rubriques sera réduite par une fraction égale à la fraction par laquelle la première rubrique a été réduite. La première rubrique de la liste doit être une rubrique de la table de composition ou une rubrique "insérer" ("set field"), toute rubrique additionnelle devant être une rubrique de la table de composition.
La commande "weight reduce field:" n’est normalement utilisée que lorsque la première rubrique de la liste de rubriques est un macro-nutriment (ou de la cendre ou de l’eau). Si on utilise la commande "weight reduce field:" on doit également utiliser la commande "food weight:".

Commande "rubrique réduction de recette:" (recipe reduce field: command)

+	recipe reduce field: reduce-field field-list rubrique réduction de recette: rubrique réduction, liste de rubriques

La commande "reduce field:" est utilisée pour spécifier les réductions de nutriments dépendant des valeurs du fichier "recette". Le premier argument doit être le nom d’une rubrique. Si le nom de la rubrique figure dans un fichier "recette", cette rubrique "recette" sera une rubrique "réduction". La rubrique "réduction" doit avoir les mêmes valeurs pour tous les ingrédients d’une même recette. Si on utilise le format "avec astérisque", on doit transformer cette rubrique en rubrique "avec astérisque".
Le second argument doit être une liste de noms de rubriques de la table de composition.<bt> Pour tous les ingrédients d’une recette, toutes les valeurs des rubriques de la table de composition seront réduites par la fraction qui est la valeur de cette rubrique "réduction". Si cette rubrique a la valeur 0, il n’y aura pas de réduction, si elle est positive, elle devra être inférieure ou égale à 1 et si elle est négative, l’effet en sera un accroissement des valeurs des rubriques de la table de composition.
La commande "recipe reduce field:" est en fait un pseudonyme de la commande "reduce field:".

Commande "rubrique réduction du poids de la recette:" (recipe weight reduce field: command)

+	recipe weight reduce field: weight-reduce-field field-list rubrique réduction du poids de la recette: rubrique réduction du poids, liste de rubriques

La commande "recipe weight reduce field:" est une variante de la commande "recipe reduce field:". La seule différence entre elles est que le second argument n’est pas une rubrique "réduction" mais une rubrique "réduction du poids". Cette rubrique "réduction du poids" doit figurer dans les fichiers "recette" et doit spécifier une fraction du poids de l’aliment concerné. La rubrique "recipe weight reduce" doit avoir les mêmes valeurs pour tous les ingrédients d’une même recette. Si on utilise le format "avec astérisque", il faut transformer la rubrique "réduction du poids" en rubrique "avec astérisque".
La première rubrique de la liste des rubriques "nutriment" de la commande est une somme pour tous les ingrédients (appelons-la "n-sum"), le poids de tous les ingrédients étant lui aussi une somme (que nous appellerons "w-sum"). Si nous appelons "r" la valeur de la rubrique "réduction", FoodCalc calculera alors une fraction de réduction telle que: (r * w-sum) / n-sum. Toutes les rubriques "nutriment" de la commande sont donc réduites par cette fraction pour tous les ingrédients d’une même recette.
La première rubrique de la liste doit être une rubrique de la table de composition ou une rubrique "insérer", toute rubrique additionnelle devant etre une rubrique de la table de composition. La commande "recipe weight reduce field:" n’est normalement utile que lorsque la première rubrique de la liste est un macro-nutriment (ou de la cendre ou de l’eau). Si on utilise la commande "recipe  weight reduce field:" on doit aussi utiliser la commande "food weight:".

Commande "rubrique non-comestible:" (non-edible field: command)

non-edible field: non-edible-field [flag-field]

rubrique non-comestible: rubrique non-comestible [rubrique indicateur]

La table de composition (les fichiers "aliment" et "catégorie") ne doit contenir les teneurs en nutriments que pour la seule part comestible des aliments, et dans les rubriques "entrée" et "recette" doivent figurer des rubriques "quantité" qui spécifient les quantités consommées, sauf si on utilise la commande "non-edible field:" ("rubrique non-comestible").
Le premier argument de la commande "non-edible field:" doit être le nom d’une rubrique de la table de composition qui a pour valeur la fraction non-comestible des aliments tels qu’ils sont d’ordinaire achetés.
Si le second argument n’est pas spécifié, toutes les rubriques "quantité" des fichiers "entrée" et "recette" doivent contenir des poids totaux (le poids des parts comestible et non-comestible).
Si le second argument est spécifié, ce doit être un nom de rubrique. Si cette rubrique n’est pas un fichier "entrée" ou "recette", les quantités figurant dans ce fichier doivent représenter le poids de la part comestible. Si cette rubrique figure dans un fichier elle doit avoir la valeur 0 ou 1. Si cette valeur est 0, la quantité doit être le poids de la part comestible, si elle est 1, cette quantité doit être le poids total de l’aliment (poids additionné des parts comestible et non-comestible).

Commande "sortir:" (output: command)

!	output: file-name [sep-char dec-point-char] sortie: nom du fichier [caractère de séparation, caractère avant décimale]

Cette commande ordonne à FoodCalc d’écrire le fichier "sortie" ("output") sous le nom donné comme premier argument. Ce fichier "output" est un fichier de données (data file), (cependant voir également la commande "output format:", format "de sortie"), où chaque ligne établit une liste de nutriments consommés. Les second et troisième arguments peuvent être utilisés pour spécifier le séparateur et le caractère avant décimale.
Si on n’utilise pas la commande "group by:" ("catégorisation"), il y aura une ligne de sortie pour chaque ligne d’entrée. Si on utilise la commande "group by:" il y aura une ligne de sortie pour chaque (sous-)groupe.

Commande "format de sortie:" (output format: command)

output format: text|text-no-head|bin-native

format de sortie: texteltexte sans en-têtelbinaire autochtone

La commande "output format:" peut être utilisée pour spécifier le format du fichier "sortie", et elle peut être utilisée avec un des mots-clés "text", "text-no-head" ou "bin-native". Si le mot-clé "text" est utilisé le fichier "sortie" sera un fichier de données (data file), par défaut. Si le mot-clé "text-no-head" est utilisé le fichier "sortie" sera comme un fichier de données, mais sans ligne où figurent les noms des rubriques.
Si c’est le mot-clé "bin-native" qui est utilisé, le fichier "sortie" ne contiendra que les valeurs sous forme de nombre binaire à double précision et à décimale flottante, sans marqueurs de fin de ligne ou de fin de fichier. Ce format sera différent selon les plates-formes. Si on lit le fichier résultant à l’aide d’un logiciel C, on devra employer des variables de type double et on devra ouvrir le fichier avec le mode "rb". Si on lit le fichier en SAS, on devra employer une commande INFILE avec "LRECL=(8*number-of-fields – nombre de rubriques) RECFM=F", et on aura le format d’entrée "RB8".
On ne doit utiliser le format de sortie "bin-native" que lorsqu’on a une grosse quantité de données et qu’on souhaite raccourcir la durée de l’opération. FoodCalc peut écrire un fichier "bin-native" relativement plus rapidement qu’un fichier de données.

Commande "rubriques sortie:" (output fields: command)

output fields: field-list

rubriques sortie: liste de rubriques

Cette commande spécifie quelles rubriques sont inscrites dans le fichier "sortie". Si on n’utilise pas la commande "group by:", on peut spécifier n’importe quelle rubrique "entrée", n’importe quelle rubrique de la table de composition, n’importe quelle rubrique "insérer" et n’importe quelle rubrique "insérer catégorie" ("group set field"). Si on utilise la commande "group by:", on ne peut spécifier que les rubriques "nutriment" de la table de composition ("nutrient table fields") (rubriques "ne-pas-calculer" - "not no-calc"), les rubriques "insérer", les rubriques "insérer catégorie" ("group set fields"), et les rubriques "catégorisation par rubrique" ("group by fields"). N’importe quelle rubrique "entrée" ou "ne-pas-calculer" sera écrite exactement comme elle a été lue. Les rubriques "nutriment" seront pesées avec la quantité et l’échelle d’entrée, éventuellement réduites à l’aide des rubriques "réduction", et additionnées à l’aide de "group by".
Si on n’utilise ni les commandes "output fields:" ni la commande "group by:", par défaut on sortira toutes les rubriques du fichier "entrée", toutes les rubriques de la table de composition, toutes les rubriques "insérer" et toutes les rubriques "insérer catégorie" ("group set"). Si on n’utilise pas la commande "output fields:" mais la commande "group by:", par défaut on sortira toutes les rubriques "catégorisation" ("group by"), toutes les rubriques "nutriment", toutes les rubriques "insérer" et toutes les rubriques "insérer catégorie".
On ne doit sortir que les rubriques dont on a besoin, car moins on a de fichiers à sortir, plus FoodCalc travaille rapidement.

Commande "catégorisation:" (group by: command)

group by: field-list

catégorisation: liste de rubriques

Cette commande ordonne à FoodCalc de grouper les aliments selon les valeurs d’une ou plusieurs rubriques "catégorisation", et d’additionner les nutriments de chaque catégorie. L’argument de la commande "group by:" doit être une liste de noms de rubriques ou bien dans le fichier "entrée" ou bien dans la table de composition. Ces rubriques sont appelées rubriques "catégorisation" ("group by fields") et elles seront aussi des rubriques "ne-pas-calculer" ("no-calc fields"). Si la première rubrique ou d’autres rubriques sont des rubriques "entrée", le fichier "entrée" doit être classé dans l’ordre ascendant des rubriques. Seule la partie entière des valeurs de ces rubriques sera utilisée.
Chaque rubrique "nutriment" sera additionnée pour tous les aliments là où les rubriques "group by" ont les mêmes valeurs.

Commande "transposer:" (transpose: command)

transpose: field number field-list

transposer: nombre de rubrique, liste de rubriques

Cette commande ordonne à FoodCalc de sortir les rubriques de la liste de rubriques transposées dans la rubrique dans le premier argument. La commande "transpose:" ne peut être utilisée que lorsque la commande "group by:" est elle aussi utilisée. La rubrique du premier argument de la rubrique dans laquelle on a transposé doit être une rubrique provenant de la table de composition et une rubrique "ne-pas-calculer" ("no-calc field").
Chaque rubrique de la liste de rubriques sera transposée et doit être une rubrique de la table de composition ou une rubrique "insérer" ("set field"). En effet, chacune de ces rubriques devra être une rubrique "nombre de sortie" ("output number") comme spécifié dans le second argument. Les rubriques "sortie" seront nommées comme la rubrique "transposer" mais avec le chiffre 1 ajouté au nombre comme suffixe. On ajoutera à la rubrique "sortie" assortie du nombre n la valeur de la rubrique transposée lorsque la partie entière de la valeur de la rubrique dans laquelle on a transposé est égale à n. Si la rubrique dans laquelle on a transposé n’a pas une valeur >= 1 et <= n, cette rubrique ne sera additionnée à aucune rubrique "sortie".

Commande "où:" (where: command)

where: logical-expr

où: expression logique

L’argument de la commande "où:" ("where:") doit être une expression logique avec la syntaxe EBNF suivante:

Lexp	::=	Lexp1 { ou Lexp1 }
Lexp1	::=	Lexp2 { et Lexp2 }
Lexp2	::=	[ non ] Lexp3
Lexp3	::=	Val  =|<>  Val
	|	Val  >|>=  Val  [ >|>=  Val]
	|	Val  <|<=  Val  [ <|<=  Val]
	|	Val  [ non ]  dans ( Val { , Val } )
	|	( Lexp )
Val	::=	Field-name  |  Number [nom de rubrique l nombre]

Toute rubrique dans l’expression logique doit être une rubrique de la table de composition ou une rubrique "insérer". Cette commande ne sélectionne que les aliments pour lesquels l’expression logique équivaut à vrai ("true").

Commande "si:" (if: command)

+	if: field value-list si: liste de rubriques

La commande "if:" n’ existe que pour la comptabilité rétroactive. On doit maintenant utiliser la commande "where:"!
Le premier argument de la commande "if:" doit être le nom d’une rubrique de la table de composition et devra être une rubrique "ne-pas-calculer" ("no-calc field"). Le second argument doit être une liste de nombres. Cette commande ne sélectionne que les aliments dont la valeur de la rubrique est égale à une des valeurs du second argument. Si plus d’une commande "if:" est utilisée, un aliment sera sélectionné seulement si une seule des commandes est destinée à la sélection des aliments.

Commande "si non:" (if not: command)

+	if not: field value-list si non: liste de valeur de rubriques

La commande "if not:" n’ existe que pour la comptabilité rétroactive. On doit maintenant utiliser la commande "where:"!
Le premier argument de la commande "if not:" doit être le nom d’une rubrique de la table de composition et devra être une rubrique "ne-pas-calculer" ("no-calc field"). Le second argument doit être une liste de nombres. Cette commande ne sélectionne que les aliments dont la valeur de la rubrique est égale à une des valeurs du second argument. Si plus d’une commande "if not:" est utilisée, un aliment sera “désélectionné” seulement si une seule des commandes est destinée à la “désélection” des aliments.

Historique des diverses versions

Version	Commentaire
v1.0	Version initiale
v1.1	Traite le retour du chariot comme un blanc, ce qui permet de lire les fichiers DOS/Windows sur les systèmes UNIX. Remède à certains bogues.
v1.2	Permet des commentaires à la fin des lignes dans les fichiers de données et les fichiers de commandes. Caractère de commentaire modifiable dans les fichiers de données. Nouvelle commande "comment:". Lignes de continuation (=) dans les fichiers de données et de commandes. Rubriques "texte" dans les fichiers de données. Nouvelle commande "text fields:". Format "avec astérisque" dans les fichiers de données. Nouvelle commande "input *fields:". Les rubriques "recette" portant le même nom que les rubriques "ne-pas-calculer" de la table de composition sont désormais copiées dans la table lorsque la commande "ingredients: sum" est utilisée. Nouvelle commande "recipe weight reduce field:". Nouvelle commande "recipe reduce field:" qui est un pseudonyme de la commande "reduce field:". La commande "recipe sum:" s’appelle maintenant "food weight:". Nouvelles commandes "weight cook:" et "weight reduce field:". Nouvelle commande "non-edible field:". Nouvelle option "-v" et nouvelle commande "verbosity:". Nouvelles options "-l", "-i" et "-o". L’option "-s" ne prend plus qu’un seul argument.
v1.3	De nouvelles commandes ajoutées "set:", "group set:" et "recipe set:" exécutent des calculs plus généraux à diverses étapes de FoodCalc, rendant obsolète la commande "calculate:". La nouvelle commande ajoutée "where:" opère une sélection plus globale des aliments, rendant obsolètes les commandes "if:" et "if not:". La nouvelle commande ajoutée "transpose:" permet de transposer les rubriques "nutriment" dans une rubrique exprimant une catégorisation des aliments, ce qui est souvent plus pratique que de grouper ("group by:") par le biais d’une table de composition. La plupart des limitations à l’usage de la commande "group by:" ont été levées. On peut désormais classer en catégories plusieurs rubriques "aliment" dans la table de composition et ces rubriques ne figurent pas obligatoirement en dernier dans la liste des rubriques "catégorisation". Les fichiers "catégorisation" peuvent être maintenant identifiés à l’aide de plus d’une rubrique, par exemple à l’aide de "catégorie principale" ou "sous-catégorie". Nouvel argument "keepx" pour la commande "ingredients:" gardant les ingrédients comme le faisait l’argument "keep" mais en déplaçant les valeurs du fichier "recette" à la table de composition comme l’argument "somme" ("sum").