Tau-Argus depuis R - sur microdonnées • rtauargus

Introduction

Présentation du package

Le package rtauargus offre une interface R pour τ-Argus. Il permet de :

créer les inputs (fichiers asc et rda) à partir de données au format R ;
générer la séquence d’instructions à exécuter en mode batch (fichier arb) ;
lancer un batch τ-Argus en ligne de commande ;
récupérer les résultats dans R.

Ces différentes opérations peuvent être exécutées en une seule fois, mais aussi de manière modulaire. Elles permettent d’intégrer les tâches réalisées par τ-Argus dans une chaîne de traitement écrite en R.

La syntaxe de certains arguments colle au plus près à la syntaxe batch de τ-Argus. Ceci permet d’utiliser un grand nombre de fonctionnalités sans multiplier les arguments des fonctions. Le package pourra en outre s’adapter plus facilement à d’éventuelles modifications du logiciel (nouvelles méthodes disponibles, options supplémentaires…). Les règles de syntaxe pour l’écriture de batch figurent dans le manuel de référence de τ-Argus.

Le package a été développé sur la base des versions open source de τ -Argus (versions 4.1 et supérieures), en particulier la dernière version disponible lors du développement (4.2.3).

Il n’est pas compatible avec la version 3.5.

Pour l’instant, seules les microdonnées sont acceptées en entrée (pas les données déjà tabulées).

Objectif de ce document

Ce document vise à montrer comment les fonctionnalités principales du package peuvent être articulées, à partir d’exemples relativement simples. Une documentation détaillée d’une fonction (liste exhaustive des arguments, aspects techniques…) est disponible via la rubrique d’aide dédiée.

Pour la démonstration qui va suivre, un jeu de microdonnées fictif sera utilisé :

donnees <-
  data.frame(
    V1    = c("A", "A", "A", "A", "B", "B", "B", "C"),
    V2    = c("Y", "Z"),
    V3    = c("T1", "T2", "T1", "S_", "T1", "T1", "T1", "S_"),
    VAL   = c(100, 0, 7, 25, 0, 4, 0, 5),
    POIDS = c(1, 2.71, 4.2, 1)
  )
donnees
#>   V1 V2 V3 VAL POIDS
#> 1  A  Y T1 100  1.00
#> 2  A  Z T2   0  2.71
#> 3  A  Y T1   7  4.20
#> 4  A  Z S_  25  1.00
#> 5  B  Y T1   0  1.00
#> 6  B  Z T1   4  2.71
#> 7  B  Y T1   0  4.20
#> 8  C  Z S_   5  1.00

sommaire ↑

Installation

Les installations suivantes sont à réaliser avant la première utilisation (et plus par la suite).

τ-Argus

Les fonctions de rtauargus appelant τ-Argus nécessitent que ce logiciel soit accessible depuis le poste de travail. Le téléchargement de τ-Argus se fait sur la page dédiée du site de l’office néerlandais de statistiques.

Cependant, toutes les fonctions n’exécutent pas τ-Argus (création des microdonnées…). Ne pas l’avoir sur son poste n’est donc pas bloquant.

Dépendances

Pour fonctionner, rtauargus dépend d’autres packages R. Ceux-ci sont à installer au préalable (entre parenthèses les versions minimales requises).

• purrr (>= 0.2),
• dplyr (>= 0.7),
• data.table,
• gdata,
• stringr,
• rlang,
• zoo,
• sdcHierarchies,
• lifecycle

Package

Le package rtauargus est prêt à être installé.

sommaire ↑

Prise en main rapide

Cette partie explique comment effectuer une configuration minimale du package et comment appliquer le secret statistique en une seule instruction.

Emplacement de τ-Argus

Au chargement du package, la console affiche quelques informations :

library(rtauargus)

En particulier, un emplacement plausible pour le logiciel τ-Argus est prédéfini. Il est possible de le changer pour toute la durée de la session R. Un message indique que cet emplacement est inconnu, on le modifie donc :

loc_tauargus <- "Y:/Logiciels/TauArgus/TauArgus4.2.3/TauArgus.exe"

options(rtauargus.tauargus_exe = loc_tauargus)

Ce petit réglage effectué, le package est prêt à être utilisé.

Pour une configuration plus personnalisée, consulter la section options du package.

Fonction `rtauargus`

La fonction éponyme rtauargus effectue un traitement et récupère les résultats immédiatement dans R.

S’abstrayant totalement des rouages internes de τ-Argus, elle permet de réaliser l’ensemble du traitement en une seule instruction (concrètement, tous les fichiers intermédiaires sont créés dans un répertoire temporaire qui est effacé à la fin de la session R).

rtauargus prend comme arguments obligatoires :

un data.frame contenant les microdonnées ;
une liste de 1 à 10 tabulations composées de variables du data.frame (une seule dans l’exemple ci-après) ;
la (les) règle(s) à appliquer pour le secret primaire ;
la (les) méthode(s) pour la suppression des cases en secret secondaire.

Les deux derniers arguments utilisent la syntaxe batch τ-Argus.

Exemple minimaliste

rtauargus(
  microdata        = donnees,
  explanatory_vars = "V1",
  safety_rules     = "FREQ(3,10)",
  suppress         = "GH(1,100)"
)
#> Error in rtauargus(microdata = donnees, explanatory_vars = "V1", safety_rules = "FREQ(3,10)", : could not find function "rtauargus"

Comme aucune variable de réponse n’est renseignée, un comptage est effectué (“<freq>”).

Exemple élaboré

D’autres paramètres sont disponibles. On peut par exemple compléter l’instruction précédente avec :

une deuxième tabulation (les deux tableaux seront traités indépendamment) ;
un paramètre permettant de ne pas afficher le statut du secret pour le premier tableau ;
un paramètre permettant de masquer le journal de τ-Argus dans la console.

De plus, les tables produites ne sont plus simplement envoyées dans la console. Elles sont stockées dans un objet secret1 (une liste constituée de deux data.frame), que l’on pourra continuer de manipuler.

secret1 <-
  rtauargus(
    microdata          = donnees,
    explanatory_vars   = list("V1", c("V1", "V2")), # 2 tabulations (V1, V1xV2)
    safety_rules       = "FREQ(3,10)",
    suppress           = "GH(.,100)",  # . remplace le numéro de tabulation
    output_options     = c("", "AS+"), # pas de statut pour le 1er tableau
    show_batch_console = FALSE         # pour masquer le journal
  )
#> Error in rtauargus(microdata = donnees, explanatory_vars = list("V1", : could not find function "rtauargus"

secret1
#> NULL

Note sur l’écriture suppress = "GH(.,100)" :

Le premier paramètre attendu par τ-Argus est le numéro de la tabulation. Ici, on souhaite appliquer la même méthode de suppression du secret secondaire à chaque tableau. S’il n’y a qu’une méthode et plusieurs tabulations, les caractères entre la parenthèse et la première virgule sont ignorés et les numéros des tabulations calculés automatiquement.

L’aide de la fonction ne décrit que les 4 arguments obligatoires. Les arguments optionnels disponibles sont documentés dans les fonctions élémentaires la constituant (micro_asc_rda, micro_arb, run_arb, import). Tout argument de ces fonctions peut être utilisé dans rtauargus. Leur fonctionnement est détaillé dans la section qui suit.

sommaire ↑

Décomposition du processus

Utiliser la fonction rtauargus est pratique en terme de lignes de code à saisir. Toutefois, cette manière de procéder peut s’avérer assez lourde si les tableaux à secrétiser ont en commun un certain nombre de caractéristiques.

On voudrait par exemple ne générer que les fichiers asc et rda, puis lancer plusieurs batch utilisant ces mêmes fichiers. Ce n’était pas le cas dans les exemples vus jusqu’à maintenant, où tous les fichiers intermédiaires étaient systématiquement regénérés, même si leur contenu était identique.

Pour cela, on peut utiliser les fonctions appelées successivement par la fonction rtauargus, à savoir :

micro_asc_rda() → micro_arb() → run_arb() → import()

[1] Fonction `micro_asc_rda`

τ-Argus n’accepte en entrée que des microdonnées sous une forme bien spécifique :

un fichier texte aux colonnes de longueur fixe, sans en-tête de colonnes (fichier .asc) ;
un fichier de description des variables (fichier .rda).

La fonction micro_asc_rda produit ces deux fichiers à partir d’un data.frame.

Exemple minimaliste

On ne renseigne ici que les données et le nom du fichier asc. Comme le nom du fichier de métadonnées n’est pas spécifié, il prend le même nom que le fichier asc, mais avec l’extension .rda.

micro_asc_rda(donnees, asc_filename = "Z:/donnees.asc")

Contenu des fichiers créés :

file.show("Z:/donnees.asc", "Z:/donnees.rda", pager = "internal")

 donnees.asc            donnees.rda        
                                           
 A Y T1 100 1.00        V1 1 1             
 A Z T2   0 2.71          <RECODEABLE>     
 A Y T1   7 4.20          <TOTCODE> "Total"
 A Z S_  25 1.00        V2 3 1             
 B Y T1   0 1.00          <RECODEABLE>     
 B Z T1   4 2.71          <TOTCODE> "Total"
 B Y T1   0 4.20        V3 5 2             
 C Z S_   5 1.00          <RECODEABLE>     
                          <TOTCODE> "Total"
                        VAL 8 3            
                          <NUMERIC>        
                          <DECIMALS> 0     
                        POIDS 12 4         
                          <NUMERIC>        
                          <DECIMALS> 2

Les fonctions du package acceptent les emplacements de fichiers sous forme de chemin relatif. Par exemple, asc_filename = "donnees.asc" avec un répertoire de travail sur Z:/ est équivalent à asc_filename = "Z:/donnees.asc".

Exemple élaboré

On ajoute à l’exemple précédent :

une variable de poids ;
les informations sur une variable hiérarchique ;
des codes différenciés pour les totaux ;
un nombre minimal de décimales à écrire pour les variables numériques.

micro_asc_rda(
  microdata    = donnees,
  asc_filename = "Z:/donnees.asc",
  weight_var   = "POIDS",
  hrc          = c(V3 = "1 1"),
  totcode      = c("Ensemble", V2 = "TOTAL"),
  decimals     = 1
)

Contenu des fichiers créés :

file.show("Z:/donnees.asc", "Z:/donnees.rda", pager = "internal")

 donnees.asc              donnees.rda           
                                                
 A Y T1 100.0 1.00        V1 1 1                
 A Z T2   0.0 2.71          <RECODEABLE>        
 A Y T1   7.0 4.20          <TOTCODE> "Ensemble"
 A Z S_  25.0 1.00        V2 3 1                
 B Y T1   0.0 1.00          <RECODEABLE>        
 B Z T1   4.0 2.71          <TOTCODE> "TOTAL"   
 B Y T1   0.0 4.20        V3 5 2                
 C Z S_   5.0 1.00          <RECODEABLE>        
                            <TOTCODE> "Ensemble"
                            <HIERARCHICAL>      
                            <HIERLEVELS> 1 1    
                          VAL 8 5               
                            <NUMERIC>           
                            <DECIMALS> 1        
                          POIDS 14 4            
                            <WEIGHT>            
                            <DECIMALS> 2

Fichiers temporaires

Pour tout paramètre *_filename non renseigné, les fichiers générés sont placés dans un dossier temporaire. Il est possible de récupérer l’emplacement et le nom (aléatoire) de ces fichiers dans la valeur de retour de la fonction.

noms_asc_rda <- micro_asc_rda(donnees)
noms_asc_rda
#> $asc_filename
#> [1] "C:\\Users\\TMM7AN.AD\\AppData\\Local\\Temp\\Rtmpu6McgM\\RTA_8a4827bb513c.asc"
#> 
#> $rda_filename
#> [1] "C:\\Users\\TMM7AN.AD\\AppData\\Local\\Temp\\Rtmpu6McgM\\RTA_8a4827bb513c.rda"

sommaire ↑

[2] Fonction `micro_arb`

Cette fonction construit un fichier batch exécutable par τ-Argus. Elle prend comme arguments obligatoires :

nom du fichier asc ;
tabulation(s) (jusqu’à 10, sous forme de liste) ;
règle(s) de secret primaire ;
méthode(s) de gestion du secret secondaire.

La fonction a également besoin du nom du fichier rda. S’il n’est pas spécifié, le même nom que le fichier asc avec l’extension .rda est utilisé.

La fonction ne vérifie pas l’existence des répertoires ou fichiers spécifiés. Elle ne fait que générer un fichier d’instructions, sans en évaluer la validité.

Exemple minimaliste

micro_arb(
  arb_filename     = "Z:/donnees.arb",
  asc_filename     = "Z:/donnees.asc",
  explanatory_vars = "V1",
  safety_rules     = "FREQ(3,10)",
  suppress         = "GH(.,100)",
  output_names     = "Z:/resultats/secretV1.csv"
)

Contenu du fichier créé :

file.show("Z:/donnees.arb", pager = "internal")

// Batch generated by package *rtauargus*
// (2024-01-11 16:39:53 CET)
<OPENMICRODATA> "Z:\donnees.asc"
<OPENMETADATA> "Z:\donnees.rda"
<SPECIFYTABLE> "V1"|"<freq>"||
<SAFETYRULE> FREQ(3,10)
<READMICRODATA>
<SUPPRESS> GH(1,100)
<WRITETABLE> (1,4,AS+SE+,"Z:\resultats\secretV1.csv")

Exemple élaboré

On complète l’exemple précédent avec :

une deuxième tabulation ;
une variable de réponse à sommer (au lieu d’un comptage) ;
l’ajout d’une dominance à 85 % pour le deuxième tableau ;
une pondération au premier tableau (mais pas au deuxième) ;
la suppression des croisements vides dans les deux tableaux (SE+).

Passer une seule valeur pour une option applique le même traitement à chaque tabulation. Pour des options différenciées, il faut impérativement passer un vecteur contenant autant de valeurs que de tabulations.

micro_arb(
  arb_filename     = "Z:/donnees.arb",
  asc_filename     = "Z:/donnees.asc",
  explanatory_vars = list("V1", c("V2", "V3")),
  response_var     = "VAL",
  safety_rules     = c("FREQ(3,10)", "FREQ(3,10)|NK(1,85)"),
  weighted         = c(TRUE, FALSE),
  suppress         = "GH(.,100)",
  output_options   = "AS+SE+"
)

file.show("Z:/donnees.arb", pager = "internal")

// Batch generated by package *rtauargus*
// (2024-01-11 16:39:53 CET)
<OPENMICRODATA> "Z:\donnees.asc"
<OPENMETADATA> "Z:\donnees.rda"
<SPECIFYTABLE> "V1"|"VAL"||
<SAFETYRULE> FREQ(3,10)|Wgt(1)
<SPECIFYTABLE> "V2""V3"|"VAL"||
<SAFETYRULE> FREQ(3,10)|NK(1,85)
<READMICRODATA>
<SUPPRESS> GH(1,100)
<WRITETABLE> (1,4,AS+SE+,"C:\Users\TMM7AN.AD\AppData\Local\Temp\Rtmpu6McgM\RTA_8a4869675510.sbs")
<SUPPRESS> GH(2,100)
<WRITETABLE> (2,4,AS+SE+,"C:\Users\TMM7AN.AD\AppData\Local\Temp\Rtmpu6McgM\RTA_8a48384e7b7f.sbs")

Fichiers temporaires

Dans l’exemple précédent, les noms des fichiers en sortie (output_names) n’étaient pas précisés, ce qui a conduit à la génération de noms de fichiers temporaires. Préciser le nom du fichier .arb n’est pas obligatoire non plus. Ces informations sont récupérables dans la valeur de retour de la fonction.

infos_arb <-
  micro_arb(
    asc_filename     = "Z:/donnees.asc",
    explanatory_vars = list("V1", c("V2", "V3")),
    safety_rules     = "FREQ(3,10)",
    suppress         = "GH(.,100)",
    output_type      = "4"
  )
infos_arb
#> $arb_filename
#> [1] "C:\\Users\\TMM7AN.AD\\AppData\\Local\\Temp\\Rtmpu6McgM\\RTA_8a484da665e2.arb"
#> 
#> $output_names
#> [1] "C:\\Users\\TMM7AN.AD\\AppData\\Local\\Temp\\Rtmpu6McgM\\RTA_8a48649a5045.sbs"
#> [2] "C:\\Users\\TMM7AN.AD\\AppData\\Local\\Temp\\Rtmpu6McgM\\RTA_8a4834183530.sbs"

sommaire ↑

[3] Fonction `run_arb`

Maintenant que les instructions ont été générées dans un fichier .arb, on peut le soumettre à τ-Argus en mode batch. On récupère la liste des tableaux secrétisés :

secret2 <- run_arb("Z:/donnees.arb")
#> Start of batch procedure; file: Z:\donnees.arb
#> <OPENMICRODATA> "Z:\donnees.asc"
#> <OPENMETADATA> "Z:\donnees.rda"
#> <SPECIFYTABLE> "V1"|"VAL"||
#> <SAFETYRULE> FREQ(3,10)|Wgt(1)
#> <SPECIFYTABLE> "V2""V3"|"VAL"||
#> <SAFETYRULE> FREQ(3,10)|NK(1,85)
#> <READMICRODATA>
#> Start explore file: Z:\donnees.asc
#> Start computing tables
#> Table: V1 | VAL has been specified
#> Table: V2 x V3 | VAL has been specified
#> Tables have been computed
#> Micro data file read; processing time 0 seconds
#> Tables from microdata have been read
#> <SUPPRESS> GH(1,100)
#> Start of the hypercube protection for table V1 | VAL
#> End of hypercube protection. Time used 1 seconds
#>                    Number of suppressions: 1
#> The hypercube procedure has been applied
#>                    1 cells have been suppressed
#> <WRITETABLE> (1,4,AS+SE+,"C:\Users\TMM7AN.AD\AppData\Local\Temp\Rtmpu6McgM\RTA_8a4869675510.sbs")
#> Table: V1 | VAL has been written
#>                    Output file name: C:\Users\TMM7AN.AD\AppData\Local\Temp\Rtmpu6McgM\RTA_8a4869675510.sbs
#> <SUPPRESS> GH(2,100)
#> Start of the hypercube protection for table V2 x V3 | VAL
#> End of hypercube protection. Time used 1 seconds
#>                    Number of suppressions: 2
#> The hypercube procedure has been applied
#>                    2 cells have been suppressed
#> <WRITETABLE> (2,4,AS+SE+,"C:\Users\TMM7AN.AD\AppData\Local\Temp\Rtmpu6McgM\RTA_8a48384e7b7f.sbs")
#> Table: V2 x V3 | VAL has been written
#>                    Output file name: C:\Users\TMM7AN.AD\AppData\Local\Temp\Rtmpu6McgM\RTA_8a48384e7b7f.sbs
#> End of TauArgus run

secret2
#> NULL

run_arb est la seule fonction du package qui exécute τ-Argus. Elle nécessite donc que le logiciel soit accessible depuis le poste de travail.

Seul l’argument arb_filename est obligatoire, car toutes les informations nécessaires sont présentes dans le fichier .arb. Des paramètres optionnels sont également disponibles :

missing_dir : action à effectuer si un dossier où sera écrit le résultat n’existe pas (déclencher une erreur ou le créer)
tauargus_exe : pour changer l’exécutable (surcharge l’option rtauargus.tauargus_exe le temps de la fonction) ;
logbook : emplacement et nom du fichier contenant le journal d’erreurs ;
show_batch_on_console : pour afficher ou non le déroulement du batch dans la console ;
import : si désactivé, la fonction ne fait que générer les fichiers texte sans les importer dans R (voir section suivante pour plus de détails).

Si les tabulations ont reçu un nom dans micro_arb, ces noms sont utilisés pour la liste de data.frames en sortie de run_arb (pas de noms définis dans l’exemple ci-dessus).

Des vérifications sont effectuées avant le lancement effectif de τ-Argus : existence du logiciel sur le poste, des fichiers asc et rda, des dossiers où écrire les résultats, des variables à utiliser (croisements, variable de réponse, …) dans les métadonnées (fichier rda).

sommaire ↑

[4] Fonction `import`

Cette fonction importe les résultats produits par τ-Argus (fichiers texte) à partir des informations contenues dans un fichier arb. Elle nécessite donc que le batch se soit déroulé sans erreur et que les fichiers soient toujours présents.

Pour cette dernière raison, la fonction import est typiquement appelée depuis run_arb en paramétrant import = TRUE. Elle est aussi utilisable de manière indépendante (par exemple si on ne souhaite pas relancer un batch qui a mis beaucoup de temps à s’exécuter).

secret2 <- import("Z:/donnees.arb")
#  produit le même résultat que run_arb("Z:/donnees.arb", import = TRUE)

Formats acceptés

Il n’est possible (à l’heure actuelle) que d’importer les résultats de type :

"2" : csv for pivot-table
"4" : sbs output format

Si l’import est impossible pour une tabulation donnée, un data.frame vide est retourné (avec un message d’avertissement).

Attributs des tabulations

À chaque data.frame de la liste est associé un ensemble d’attributs, des métadonnées gardant une trace des spécifications passées à τ-Argus.

Par exemple, pour secret2[[2]] (le deuxième tableau de secret2), on y retrouve les paramètres que l’on a transmis à la fonction (les autres correspondent à des valeurs par défaut du package).

str(secret2[[2]])
#>  NULL

sommaire ↑

Options du package

Les options du package définissent les comportements par défaut des fonctions.

Ces options sont utilisées si un argument obligatoire d’une fonction n’est pas renseigné. Elles permettent de ne pas répéter systématiquement le même paramètre à chaque appel d’une fonction. Le nom de l’option est le nom de l’argument d’une fonction précédé de rtauargus. :

Par exemple, rtauargus.decimals sera la valeur utilisée si l’argument decimals de la fonction micro_asc_rda n’est pas renseigné par l’utilisateur.

Au chargement, le package attribue une valeur par défaut à toutes les options de rtauargus qui ne sont pas encore déclarées. Les options déjà définies par l’utilisateur gardent leurs valeurs.

Les options disponibles ainsi que leurs valeurs par défaut sont listées ci-dessous :

Option	Valeur par défaut	Type	Fonction concernée
rtauargus.decimals	0	integer	tab_rda
rtauargus.decimals	0	integer	micro_asc_rda
rtauargus.totcode	“Total”	character	tab_rda
rtauargus.totcode	“Total”	character	micro_asc_rda
rtauargus.missing	“”	character	micro_asc_rda
rtauargus.hierleadstring	“@”	character	micro_asc_rda
rtauargus.hierleadstring	“@”	character	tab_rda
rtauargus.separator	“,”	character	tab_arb
rtauargus.separator	“,”	character	tab_rda
rtauargus.response_var	“<freq>”	character	micro_arb
rtauargus.weighted	FALSE	logical	micro_arb
rtauargus.linked	FALSE	logical	micro_arb
rtauargus.output_type	“4”	character	tab_arb
rtauargus.output_type	“4”	character	micro_arb
rtauargus.output_options	“”	character	micro_arb
rtauargus.output_options	“”	character	tab_arb
rtauargus.missing_dir	“stop”	character	run_arb
rtauargus.tauargus_exe	“Y:/Logiciels/TauArgus/TauArgus.exe”	character	run_arb
rtauargus.show_batch_console	FALSE	logical	run_arb
rtauargus.import	FALSE	logical	run_arb
rtauargus.is_tabular	TRUE	logical	run_arb

Affichage

Pour afficher les options définies pour la session en cours :

rtauargus_options()
#> $rtauargus.decimals
#> [1] 0
#> 
#> $rtauargus.hierleadstring
#> [1] "@"
#> 
#> $rtauargus.import
#> [1] FALSE
#> 
#> $rtauargus.is_tabular
#> [1] TRUE
#> 
#> $rtauargus.linked
#> [1] FALSE
#> 
#> $rtauargus.missing
#> [1] ""
#> 
#> $rtauargus.missing_dir
#> [1] "stop"
#> 
#> $rtauargus.output_options
#> [1] "AS+SE+"
#> 
#> $rtauargus.output_type
#> [1] "4"
#> 
#> $rtauargus.response_var
#> [1] "<freq>"
#> 
#> $rtauargus.separator
#> [1] ","
#> 
#> $rtauargus.show_batch_console
#> [1] FALSE
#> 
#> $rtauargus.tauargus_exe
#> [1] "Y:/Logiciels/TauArgus/TauArgus4.2.3/TauArgus.exe"
#> 
#> $rtauargus.totcode
#> [1] "Total"
#> 
#> $rtauargus.weighted
#> [1] FALSE

Les valeurs sont identiques aux valeurs par défaut, hormis l’emplacement de τ-Argus, qui a été préalablement modifié. Elles apparaissent dans l’ordre alphabétique.

sommaire ↑

Modification, réinitialisation

Pour modifier une ou plusieurs options, utiliser la syntaxe suivante (la même que celle employée pour modifier l’emplacement de τ-Argus) :

options(
  rtauargus.show_batch_console = FALSE,
  rtauargus.output_options     = "AS+SE+",
  rtauargus.output_type        = "4",
  rtauargus.response_var       = "VAL"
)

str(rtauargus_options())
#> List of 15
#>  $ rtauargus.decimals          : int 0
#>  $ rtauargus.hierleadstring    : chr "@"
#>  $ rtauargus.import            : logi FALSE
#>  $ rtauargus.is_tabular        : logi TRUE
#>  $ rtauargus.linked            : logi FALSE
#>  $ rtauargus.missing           : chr ""
#>  $ rtauargus.missing_dir       : chr "stop"
#>  $ rtauargus.output_options    : chr "AS+SE+"
#>  $ rtauargus.output_type       : chr "4"
#>  $ rtauargus.response_var      : chr "VAL"
#>  $ rtauargus.separator         : chr ","
#>  $ rtauargus.show_batch_console: logi FALSE
#>  $ rtauargus.tauargus_exe      : chr "Y:/Logiciels/TauArgus/TauArgus4.2.3/TauArgus.exe"
#>  $ rtauargus.totcode           : chr "Total"
#>  $ rtauargus.weighted          : logi FALSE

Pour réinitialiser certaines options :

reset_rtauargus_options("rtauargus.response_var", "rtauargus.output_type")

# Il est possible d'omettre le préfixe 'rtauargus.'
# L'instruction suivante est équivalente :
reset_rtauargus_options("response_var", "output_type")

str(rtauargus_options())
#> List of 15
#>  $ rtauargus.decimals          : int 0
#>  $ rtauargus.hierleadstring    : chr "@"
#>  $ rtauargus.import            : logi FALSE
#>  $ rtauargus.is_tabular        : logi TRUE
#>  $ rtauargus.linked            : logi FALSE
#>  $ rtauargus.missing           : chr ""
#>  $ rtauargus.missing_dir       : chr "stop"
#>  $ rtauargus.output_options    : chr "AS+SE+"
#>  $ rtauargus.output_type       : chr "4"
#>  $ rtauargus.response_var      : chr "<freq>"
#>  $ rtauargus.separator         : chr ","
#>  $ rtauargus.show_batch_console: logi FALSE
#>  $ rtauargus.tauargus_exe      : chr "Y:/Logiciels/TauArgus/TauArgus4.2.3/TauArgus.exe"
#>  $ rtauargus.totcode           : chr "Total"
#>  $ rtauargus.weighted          : logi FALSE

Pour remettre toutes les valeurs par défaut (y compris le chemin vers τ-Argus modifié en début de démonstration), ne spécifier aucun argument :

reset_rtauargus_options()

sommaire ↑

Portée locale ou globale

Comme toute fonction R, le paramétrage s’effectue en spécifiant chacun des arguments au moment de l’appel de la fonction (portée locale).

Le système d’options du package permet par les instructions options(rtauargus.<option> = <valeur>) de définir des options de manière plus globale. Selon l’endroit où sont écrites ces instructions, la configuration perdurera plus ou moins longtemps :

dans le script, pour un effet sur la session en cours uniquement ;
dans un fichier de configuration utilisateur (.Rprofile…), pour permettre à un utilisateur de garder en mémoire ses préréglages d’une session sur l’autre.

Le deuxième façon de procéder est à déconseiller si la chaîne de traitement se veut reproductible. En effet, un script identique exécuté sur deux machines différentes pourrait produire deux résultats différents.

sommaire ↑

Autres informations

Autres fonctionnalités

Certaines fonctionnalités du package ne sont pas évoquées dans ce document de prise en main :

gestion de tableaux liés (argument linked dans micro_arb)
création de variables hiérarchiques à partir de microdonnées (fonction write_hrc).
prise en compte de fichier apriori (argument apriori dans micro_arb)
utilisation de la fonction rtauargus à partir de microdonnées déjà sous forme de fichier texte (et non de data.frame)
lancement optimisé d’un grand nombre de croisements ayant les mêmes paramètres (règles de secret primaire, méthode de secret secondaire, …) : fonction rtauargus_plus

Consulter l’aide de ces fonctions pour plus d’informations.

Idées pour la suite

implémenter paramètres request…
prendre en compte des données tabulées en entrée
…

Signaler un problème, suggérer une amélioration

Le package est en cours de construction. Toutes les fonctionnalités de τ-Argus n’ont pas été intégrées (la finalité n’est pas de les intégrer toutes, seulement les plus fréquemment utilisées).

Pour tout retour ou signalement d’erreur, utiliser de préférence ce lien (cliquer sur “New issue”). Nécessite d’être connecté au gitlab-Insee.

À propos de cette vignette

Auteur : Pierre-Yves Berrard
Dernière mise à jour : 11/01/2024
Version de rtauargus utilisée : 1.2.0
Version de τ-Argus utilisée : TauArgus 4.2.3
Version de R utilisée : 4.2.3

sommaire ↑

Tau-Argus depuis R - sur microdonnées

¶ Package {rtauargus} ¶

Introduction

Présentation du package

Objectif de ce document

Installation

τ-Argus

Dépendances

Package

Prise en main rapide

Emplacement de τ-Argus

Fonction rtauargus

Exemple minimaliste

Exemple élaboré

Décomposition du processus

[1] Fonction micro_asc_rda

Exemple minimaliste

Exemple élaboré

Fichiers temporaires

[2] Fonction micro_arb

Exemple minimaliste

Exemple élaboré

Fichiers temporaires

[3] Fonction run_arb

[4] Fonction import

Formats acceptés

Attributs des tabulations

Options du package

Affichage

Modification, réinitialisation

Portée locale ou globale

Autres informations

Autres fonctionnalités

Idées pour la suite

Signaler un problème, suggérer une amélioration

À propos de cette vignette

¶
Package {rtauargus} ¶

Fonction `rtauargus`

[1] Fonction `micro_asc_rda`

[2] Fonction `micro_arb`

[3] Fonction `run_arb`

[4] Fonction `import`