Variabili: trasformazioni (2)¶

Nota

Per le espressioni vedi anche Espressioni

value¶

Assegna alle variabili i valori specificati. Accetta un solo valore per tutte le variabili o una lista di valori, uno per ciascuna variabile. Se le variabili non esistono, verranno create. Argomenti:

varlist: il nome della variabile o l’elenco dei nomi delle variabili
value|[values]: un solo valore da assegnare alle variabili, un array di valori da assegnare a ciascuna variabile
:level => "string": (opzionale) l’etichetta da assegnare al valore
:label => "string": (opzionale) l’etichetta da assegnare alla variabile
:pos => :ini|:end|{:before|:after => :varname}: (opzionale) inserisce la nuova variabile nella posizione indicata
:before => :varname: (opzionale) inserisce la nuova variabile prima della variabile indicata
:after => :varname: (opzionale) inserisce la nuova variabile dopo la variabile indicata

value varlist, valuelist

create :x1
value :x1, 1
value [:v1, :v2, :v3], 99
value [:v11, :v12, :v13], [6,7,8]

one, zero, void o na¶

Assegnano rispettivamente 1, 0 e valore mancante alle variabili specificate. Se le variabili non esistono, verranno create.
void e na sono equivalenti.

 one :a1
 zero :b1, :b2, :b3

 void s(:c_,1..5)
 na s(:c_,1_5)

total¶

Genera una variabile adatta a essere utilizzata come colonna del totale nel pannello: con valore 1 ed etichetta (variable label).

total :tot1
total :tot2, "Totale Italia"

codes_to_na¶

Ricodifica i valori indicati in blank (nil). Elimina anche gli eventuali livelli.

 codes_to_na s(:v41_,1..19) => [0,9]

zero_to_na¶

Ricodifica il valore 0 in blank (nil). Elimina anche l’eventuale livello.

 zero_to_na s(:v42_,1..19)

empty_to_na¶

Converte la stringa vuota o piena solo di spazi di una variabile string in blank (nil).

 empty_to_na [:indirizzo, :comune, :prov]

na_to_zero, na_to_0¶

Ricodifica il valore blank (nil) in 0. È possibile indicare l’etichetta del codice 0.

 na_to_zero s(:v42_,1..19)
 na_to_zero s(:v42_,1..19), "No"

na_to_one, na_to_1¶

Ricodifica il valore blank (nil) in 1. È possibile indicare l’etichetta del codice 1.

 na_to_1 s(:v42_,1..19)
 na_to_1 s(:v42_,1..19), "Sì"

na_to_value¶

Ricodifica il valore blank (nil) nel valore indicato. È possibile indicare l’etichetta del nuovo codice.

 na_to_value s(:v42_,1..19), 9
 na_to_value s(:v42_,1..19), 9, "Non risponde"

value_if¶

Imposta le variabili uguali al valore indicato se è vera la condizione. Accetta un solo valore per tutte le variabili o una lista di valori, uno per ciascuna variabile. Se le variabili non esistono, verranno create.

Se la condizione non è verificata, verrà inserito un valore mancante nel caso di una variabile nuova, oppure il valore preesistente nel caso di variabili esistenti. L’argomento :else => valore permette di specificare un valore alternativo.

Argomenti:

varlist: il nome della variabile o l’elenco dei nomi delle variabili
value|[values]|:varname: un solo valore da assegnare alle variabili, un array di valori da assegnare a ciascuna variabile o una variabile il cui valore deve essere assegnato alle variabili
expression: la condizione (come hash o come testo) da verificare per attribuire il valore
:if_na => false|true: false (default) considera tutti i casi; true considera solo i casi con valore blank, cioè non sovrascrive un valore valido
:else => value: (opzionale) il valore da assegnare se la condizione non è verificata (non consentito se :if_na => true)
:level => "string": (opzionale) l’etichetta da assegnare al valore
:label => "string": (opzionale) l’etichetta da assegnare alla variabile
:pos => :ini|:end|{:before|:after => :varname}: (opzionale) inserisce la nuova variabile nella posizione indicata
:before => :varname}: (opzionale) inserisce la nuova variabile prima della variabile indicata
:after => :varname}: (opzionale) inserisce la nuova variabile dopo la variabile indicata

value_if :d5, 9, :d5 => :na, :level => "Non indica"
value_if s(:d7_10), 1, "d6=1"
value_if [:d8, :x8], [6,99], :d8 => nil

E’ possibile utilizzare anche una variabile al posto del valore, ma specificandola solo come simbolo (:nomevar), non come stringa ("nomevar"):

value_if :v1, :v2_1, :v100 => 1

value_if_na¶

Come value_if, ma imposta il parametro :if_na come true.

values_if¶

Imposta i valori delle variabili in base alle condizioni indicate. Se le variabili non esistono, verranno create.

Argomenti:

varlist: il nome della variabile o l’elenco dei nomi delle variabili
value => expression, ...: le coppie di valore e espressione da verificare (è possibile usare o meno le parentesi graffe per raggrupprare le condizioni):
- value:
  - un valore
  - nil o :na per indicare il valore mancante
  - il nome di una variabile (specificato come :simbolo e non come "stringa")
- expression:
  - l’espressione da verificare (come hash o come testo)
  - :else per indicare tutti i casi che non rientrano nelle altre condizioni (non consentito se presente :if_na)
  - :miss per indicare i rimanenti casi con valore mancante nella variabile
  - un array con l’espressione/:else/:miss e l’etichetta del livello (solo nel caso il valore non sia rappresentato da una variabile)
:overlap => :warn|:error|:ignore: :warn (default) genera un messaggio di warning nell’output; :error genera un errore; :ignore prosegue l’esecuzione senza segnalazioni
:direction => :forward|:backward: l’ordine di esecuzione delle condizioni (escluse :miss e :else): :forward (default) dalla prima all’ultima; :backward dall’ultima alla prima
:if_na => false|:initial|:all:
- false: (default) considera tutti i casi;
- :initial: considera solo l’insieme di casi che inizialmente non ha alcun valore sulla variabile;
- :all: per ogni condizione considera solo i casi che hanno ancora valore blank.
:label => "string": (opzionale) l’etichetta da assegnare alla variabile
:type => symbol: il tipo della variabile (se la variabile non esiste)
:size => number: la dimensione della variabile (se la variabile non esiste)
:ndec => number: il numero dei decimali della variabile (se la variabile non esiste)
:pos => :ini|:end|{:before|:after => :varname}: (opzionale) inserisce la nuova variabile nella posizione indicata
:before => :varname: (opzionale) inserisce la nuova variabile prima della variabile indicata
:after => :varname: (opzionale) inserisce la nuova variabile dopo la variabile indicata

new :v1, :single, 1.0, :label => "Sesso per età",
   :levels => {1=>"M <18", 2=>"F <18", 3=>"M >=18", 4=>"F >=18"}
values_if :v1,
  1 => "sesso=1 AND etaq<18",
  2 => "sesso=2 AND etaq<18",
  3 => "sesso=1 AND etaq>=18",
  4 => "sesso=2 AND etaq>=18"

values_if :v2, :label => "Sesso per età",
  1 => ["sesso=1 AND etaq<18"             , "M <18"  ],
  2 => ["sesso=2 AND etaq<18"             , "F <18"  ],
  3 => ["sesso=1 AND etaq>=18 AND etaq<30", "M 18-29"],
  4 => ["sesso=2 AND etaq>=18 AND etaq<30", "F 18-29"],
  9 => [:else                             , "Altri"  ]

new :v3, :single, 1.0, :label => "Età",
    :levels => {1=>"14-17 anni", 2=>"18-24 anni", 3=>"25-30 anni", 4=>"31-34 anni"}
values_if :v3, {
    :eta    => {:sesso=>1},
    :eta_db => {:sesso=>2},
  }

values_if_na¶

Come values_if, ma imposta il parametro :if_na come :initial.

typology¶

Crea una tipologia partendo da una serie di variabili. La sintassi è simile a values_if, ma invece delle espressioni si indica l’elenco delle variabili che generano la tipologia e i valori delle variabili.

typology :ty1, :label => "Label tipologia"
  :vars => [:v1, :v2, :v3],
=> [ 1..3, 0, 1, "Label codice 1"],
=> [ 1..3, 0, 2, "Label codice 2"],
=> [[4,5], 1, 1, "Label codice 3"],
=> [[4,5], 1, 2, "Label codice 4"],
=> [[4,5], 0, 1, "Label codice 5"],
=> [[4,5], 0, 2, "Label codice 6"]

md_if¶

Genera un set di multiple a partire da una serie di condizioni.

Argomenti:

root: la radice del nome delle variabili da creare
expression => label, ...: le coppie di espressione e etichetta
:other => label: genera una variabile valorizzata a 1 quando nessuna delle altre variabili è valorizzata a 1
:zero => false|true: per i casi che contengono almeno un 1, mette 0 nella altre variabilii della batteria (default true)
:label => "string": l’etichetta generale del set di multiple

md_if :x101_, :label => "Etichetta batteria",
  "v1=1 AND v1_1=2" => "Gruppo 1",
  "ANY(v3,13,7)"    => "Gruppo 2",
  "GT(v2_2,3)"      => "Gruppo 3",
  :other            => "Complemento"

one_if, zero_if¶

Come value_if, ma impostano direttamente il valore a 1 o a 0.

na_if¶

Imposta le variabili a blank se è vera la condizione. Se le variabili non esistono, verranno create.

 na_if varlist, expression

 na_if :d1, :sesso => 1

na_unless, valid_if¶

Imposta le variabili a blank se è falsa la condizione. Se le variabili non esistono, verranno create.

 na_unless :d1, :sesso => 2

 valid_if :d1, :sesso => 2

zero_unless¶

Imposta le variabili a zero se è falsa la condizione. Se le variabili non esistono, verranno create.

 zero_unless :d1, :sesso => 2

timediff¶

Crea una variabile con la differenza tra due variabili data o data e ora. Con due variabili di tipo :date restituisce il numero di giorni e imposta la variabile come :integer. Con due variabili di tipo :datetime restituisce il numero di secondi e imposta la variabile come :time. Quando una variabile è di tipo :date e una di tipo :datetime viene considerata la sola data per entrambe le variabili.

 timediff :diff1, :giorno, :giorno2, :label => "Giorni"
 timediff :diff2, :ora, :ora2, :label => "Ore"                              # viene impostata come :time
 timediff :diff3, :ora, :ora2, :label => "Numero secondi", :type => :float  # forza il tipo a :float

count¶

Crea una variabile con il conteggio delle occorrenze di uno o più valori.

Argomenti:

nome variabile: il nome della variabile in cui memorizzare il risultato (se la variabile non esiste, verrà creata)
lista valori: un valore o un vettore di valori. E’ possibile indicare il valore mancante con nil o con :na e i valori validi con :valid
lista variabili: l’elenco delle variabili in cui contare le occorrenze dei valori
:label => string: (opzionale) l’etichetta della variabile
:levels => {}|:auto: (opzionale) le etichette dei livelli. :auto imposta le etichette uguale ai valori
:classify => ricodifiche: (opzionale) ricodifica ed etichetta i valori conteggiati (vedi classify)
:else: (opzionale) identifica tutti i valori non specificati (vedi classify)
:start => #: (opzionale) numero di partenza della serie dei nuovi valori (vedi classify)
:recode => ricodifiche: (opzionale) ricodifica i valori conteggiati (vedi recode)
:base => :all|:vars: imposta la base della nuova variabile sul totale record (:all) o sui casi validi delle variabili da contare (:vars) (default :all)

count :nmiss, [nil, 99, 999], :sex, :area, :studio, :abb
count :c6a, 3, s(:d6_, 1..10)
count :c6b, nil, s(:d6_, 1..10)
count :c6c, [nil, 0], s(:d6_, 1..10)
count :c6d, :valid, s(:d6_, 1..10)

count :x6, 4..5, s(:d6_, 1..10), :classify => {0 => "Zero", 1..5 => "Da 1 a 5", 6..10 => "Da 6 a 10"}, :start => 0

count :z6, 4..5, s(:d6_, 1..10), :recode => {0 => nil, else => 1}

count2 o countv¶

Come count, ma imposta il parameteo :base => :vars.

compute¶

Assegna il risultato dell’espressione alla variabile. Se la variabile non esiste, verrà creata, altrimenti i valori verranno sovrascritti.
Nel caso di generazione di una nuova variabile, non trascurare di definire il tipo di variabile e la dimensione.

Argomenti:

lista variabili => espressione: è possibile utilizzare una sola variabile oppure un array con più nomi di variabili.
:type => symbol: il tipo della variabile
:size => number: la dimensione della variabile
:ndec => number: il numero dei decimali della variabile
:label => string: l’etichetta della variabile
:levels => hash: le etichette dei livelli della variabile
:w => array|hash: un array o un hash con i pesi da utilizzare al posto dei valori nel calcolo del risultato. In caso di mancata corrispondenza tra valore e peso, verà attribuito il valore nil
:if => expression: filtro per applicare le trasformazioni solo a un sottoinsieme di casi

Per la sintassi, vedere la sezione Espressioni.

 compute :d5bis => :d5
 compute :d5bis => "d5"

 compute :id => "NROW()", :type => :int, :size => 4
 compute :x5 => "IF(d5, d5+1 , nil)", :type => :int, :size => 1
 compute :s100 => "SUM(d101, d102, 50)"
 compute :n7 => "IF(ALL(0,#{s(:d7_, 1..10).join(',')}), 1, null)", levels: {1=>"NESSUNA CITAZIONE"}
 compute :b2 => "UPCASE(TEXT(a2))", type: :string, size: 50
 compute :x0 => "MAX(q21, q22, q23, q24)"
 compute :pr => "NROW()/N()*100"
 compute :x3 => "CONCAT(LABEL(d5), ' ', LEVEL(d5))"

 compute :x3 => nil
 compute :x3 => :na

 compute :x5 => {:d5 => [0, 1, 2]}  # equivale a:
 compute :x5 => "IF(ANY(d5, 0, 1, 2), 1, nil)"

E’ possibile definire nuove funzioni con il metodo add_function.

Consiglio

compute è una funzione generica e flessibile, ma è probabile che esista una funzione più specifica e diretta per risolvere il proprio problema di calcolo

recode¶

Ricodifica i valori delle variabili in nuovi valori.

Argomenti:

lista variabili => ricodifiche:
- lista variabili:
  - è possibile utilizzare una sola variabile oppure un array con più nomi di variabili
- ricodifiche:
  - le ricodifiche sono un hash di coppie valori da ricodificare => nuovo valore
  - se si utilizza un semplice array, i nuovi valori verranno imputati progressivamente a partire da 1
  - è possibile passare i valori da ricodificare come singolo elemento, array, range o anche un array contenete altri array e range
  - il nuovo valore può essere passato come array di due elementi dove il primo elemento è il nuovo valore, mentre il secondo è l’etichetta (in alternativa si può utilizzare il parametro :levels)
  - è possibile utilizzare come valore da ricodificare un’espressione che restituisca un valore logico iniziando l’espressione con il carattere =. Nell’espressione l’unico parametro variabile consentito è il nome della variabile che si sta ricodificando.
:into permette di specificare il nome o i nomi delle nuove variabile in cui ricodificare i dati. Il numero di variabili deve corrispondere al numero di variabili da ricodificare. Se non specificato :into, vengono ricodificate le variabili originarie.
:else identifica tutti i valori non specificati, compresi i valori mancanti:
- :else => value: assegna value per tutti i valori non specificati, compresi i valori mancanti
- :else => :copy: copia i valori non specificati (default se non è specificato :into)
- :else => :delete: elimina i valori non specificati (default se è specificato :into)
:valid => value: assegna value per tutti i valori validi non specificati (i valori mancanti vengono lasciati blank)
:type => symbol: il tipo della variabile
:size => number: la dimensione della variabile
:ndec => number: il numero dei decimali della variabile
:label => string|[strings]: la/le etichetta/e della/e) variabile/i
:levels => hash: le etichette dei livelli della variabile (se specificato :x verranno copiate e unite le etichette originarie)
:levsep => string: il separatore da usare quando vengono unite le etichette dei livelli quando si utilizza :x
:pref => string: aggiunge il testo all’inizio dell’etichetta della variabile
:suff => string: aggiunge il testo alla fine dell’etichetta della variabile
:if => expression: filtro per applicare le ricodifiche solo in un sottoinsieme di casi
:simplify => false|true: nel caso di stringhe, semplifica i caratteri estesi: virgolette, ellissi, ecc. (default: false).
:pos => :ini|:end|{:before|:after => :varname}: (opzionale) inserisce la nuova variabile nella posizione indicata
:before => :varname: (opzionale) inserisce la nuova variabile prima della variabile indicata
:after => :varname: (opzionale) inserisce la nuova variabile dopo la variabile indicata

Se non specificato diversamente, eventuali etichette dei valori non vengono modificate.

Per le variabili stringa i valori possono essere specificati come stringa ('text' o "text") oppure come espressione regolare (/regex/). Il confronto viene fatto eliminando nei dati gli spazi iniziali e finali. Nel caso di valori stringa il confronto è case insensitivi.

Quando si ricodificano variabili stringhe in una variabile numerica, i valori stringa da ricodificare sono usati come etichette della variabile numerica.

recode :x1 => {0 => nil}
recode :x2 => {(1..3) => 5, [4,5] => 1, :else => :delete}
recode :x3 => {1..3 => 5, [4,5] => 1, 6 => 2, :else => :copy}, :into => :z1

recode :mese => [1..3, 4..6, 7..9, 10..12], :into => :trims

recode :x7 => {1..5 => 0, 6..10 => 1}, :levels => {0 => "Basso", 1 => "Alto"}
recode :x7 => {1..5 => [0, "Basso"], 6..10 => [1, "Alto"]}

recode :x4 => {"NO" => 1, "NE"=> 2, "C"=> 3, "S"=> 4}, into: :area
recode :x5 => {/^[molto|abbastanza].+$/i => 1, :else => 0}, into: :x5b

recode :x6 => { [11,14,[15,16],20..24,34] => 1, 28..31 => 2 }

recode s(:c15_,1..10) => {nil=>nil, 0=>0, :else=>1}, :levels => {}

recode :str1 => {"=CONTAIN(str1, \"musica\")" => 1, "=CONTAIN(str1, \"sport\")" => 2}, :into => :str2

recode :num1 => {"=num1 AND ROUND(num1, 0)>=5" => 1}, :into => :num2

classify¶

Ricodifica i valori delle variabili discrete in classi.

Argomenti:

lista variabili => ricodifiche: è possibile utilizzare una sola variabile oppure un array con più nomi di variabili. Le ricodifiche sono un hash di coppie valori da ricodificare/etichetta. E’ possibile passare i valori da ricodificare come singolo elemento, array o range. I nuovi valori verranno attribuiti consecutivamente. Al posto dell’etichetta è possibile indicare :x per copiare e unire le etichette originarie
:start => #: numero di partenza della serie dei nuovi valori (default: 1)
:into: permette di specificare il nome o i nomi delle nuove variabile in cui ricodificare i dati. Il numero di variabili deve corrispondere al numero di variabili da ricodificare. Se non specificato :into, vengono ricodificate le variabili originarie.
:else: identifica tutti i valori non specificati.
- :else => :copy: copia i valori non specificati (default se non è specificato :into).
- :else => :delete: elimina i valori non specificati (default se è specificato :into).
:valid => value: assegna value per tutti i valori validi non specificati (i valori mancanti vengono lasciati blank)
:label => string: l’etichetta della variabile
:levsep => string: il separatore da usare quando vengono unite le etichette dei livelli quando si utilizza :x

classify :q12 => {1 => "1 sola uscita", 2..5  => "2/ 5 uscite", 6..10 => "6/10 uscite ", :else => "Più di 10 uscite"}

classify s(:d3_, 1..6) => {1..2 => :copy, 3..4 => :copy, 5 => :copy}, :into => s(:rd3_, 1..6)

classify0¶

Come classify, ma imposta il parametro :start => 0.

bins¶

Ricodifica i valori di una variabile continua in classi.

Argomenti:

variabile di origine => variabile di destinazione
:floor => []: la lista dei valori che devono essere considerati come limiti inferiori delle classi
:ceiling => []: la lista dei valori che devono essere considerati come limiti superiori delle classi
:levels => []: la lista delle etichette delle classi
:label => "": l’etichetta della nuova variabile

I parametri :fool e :ceiling non possono essere indicati contemporaneamente. I valori devono essere uguali al numero di classi da creare meno uno.

bins :spesa => :spesa2, :floor => [2.5, 4.5, 7.5], :levels => ["Meno di 2,50 ", "Da 2,50 a 4.49 ", "Da 4,50 a 7.49 ", "7,50  o più"]

# percentuali in 20 classi a step di 5
bins :percent => :percent2,
     :ceiling => (1..100).to_a.each_slice(5).map(&:last),
     :levels => ["0-5 %"]+(1..100).to_a.each_slice(5).map{|gr| ">#{gr.first-1}-#{gr.last} %"}[1..-1]

tiles¶

Ricodifica i valori delle variabili in percentili.

lista variabili: è possibile utilizzare una sola variabile oppure un array con più nomi di variabili.
:perc: i percentili da utilizzare. Default [25, 50, 75, 100], i quartili. E’ possibile omettere il 100 finale.
:n: il numero di percentili da creare (è alternativo a :perc).
:into: permette di specificare il nome o i nomi delle nuove variabile in cui ricodificare i dati. Il numero di variabili deve corrispondere al numero di variabili da ricodificare. Se non specificato :into, vengono ricodificate le variabili originarie.
:label: l’etichetta della variabile. Se non specificata utilizza l’etichetta della variabile originaria.
:levels: le etichette dei livelli della variabile. E’ possibile specificarle esplicitamente (con un vettore o un hash) oppure specificare un template per comporre l’etichetta, dove %(x) indica il valore (o l’etichetta, se presente) inferiore della classe, %(y) il valore (o l’etichetta, se presente) superiore e %(#) il progressivo delle classi. Se non indicato il template di default è "%(x)-%(y)".
:w => false: utilizza i valori grezzi anche in caso di ponderazione attiva.
lista codici => "etichetta": è possibile indicare uno o più codici che devono essere ignorati nel calcolo. Se viene specificata un’etichetta verranno ricodificati nella nuova variabile (utilizzando il primo codice disponibile), se specificato nil i valori verranno ricodificati a blanck. E’ possibile indicare più coppie valori/etichetta-nil.

tiles :euro, :perc => [25,50,75], :into => :prezzo
tiles :v100, :levels => "%(#)° quartile (%(x)-%(y))", 0 => "NON INDICA", [97,98] => "NON RISPONDE", 9999 => nil, :w => false

lump¶

Aggrega i livelli più piccoli di una variabile in un unico gruppo.

Argomenti:

varlist: l’elenco dei nomi delle variabili
il criterio di aggregazione dei livelli:
- se non specificato, aggrega i livelli in modo che il nuovo gruppo non sia superiore per numerosità a nessuno dei gruppi residui
- :nlev => #: un numero che indica il numero complessivo finale di livelli
- :plev => #.#: un numero che indica la percentuale massima che può avere il nuovo livello
- :n => #: il livello verrà aggregato se ha una numerosità minore o uguale a quella indicata
- :perc => #.#: il livello verrà aggregato se ha una frequenza percentuale minore o uguale a quella indicata
:ord => :ini|:end: i livelli vengono aggregati seguendo l’ordine originario, a partire dall’estremità inferiore (:ini) o da quella superiore (:end)
:code: il codice del nuovo livello (default: il valore successivo/precedente rispetto ai codici della variabile)
:label: l’etichetta del nuovo livello altrimenti concatena le etichette dei livelli che vengono aggregati
:drop => false|true: imposta a valore mancante i livelli da aggregare (default: false)
:renumber|:renum => true|false: rinumera i livelli della variabile a partire da 1 (default: false)
:force => false|true: forza la generazione del nuovo livello anche se c’è un unico livello da “aggregare” o se non ce ne è nessuno (default false)
:exclude => []: eventuali codici che devono essere esclusi dall’aggregazione
:into => namelist: i nomi delle nuove variabili se non si vuole modificare quelle originali. Se specificato, il parametro :force sarà impostato a true

La variante lump! imposta il parametro :force a true.

 lump :v1

 lump :v2, :v3, :nlev => 3

 lump! :v4, :prop => 0.20, :code => 9, :label => "Altro"

fuzzy_recode¶

Calcola la distanza tra ciascuna voce di due liste di stringhe e cerca le voci con la somiglianza maggiore. Stampa nel log un report con le corrispondenze trovate e le istruzioni per ricodificare la prima lista nell’altra oppure esegue direttamente l’istruzione di recode.
Può essere applicata a liste di valori (array) oppure a variabili.

Argomenti:

:varname|list: il nome della variabile o la lista di valori da ricodificare
:to => :varname|list: il nome della variabili o la lista di valori verso cui ricodificare i dati
:min_pct => #: la percenduale di similitutine minima accettabile
:alt => #: il numero di alternative da mostrare (default 1)
:exec => true|false: true esegue il comando recode (default false). Il primo argomento deve essere una variabile, il parametro :into deve essere specificato, :alt deve essere uguale a 1.
:into => :varname: il nome della variabili di destinazione

La variante fuzzy_recode! imposta il parametro :exec => true.

fuzzy_recode :country_name, to: :country, :min_pct => 55

+ fuzzy recode:
+ +-- 100 % match: 23
+ +-- fuzzy match: 5
+ +-- 0 % match: 3:
+     +-- Bolivia
+     +-- Venezuela
+     +-- Dominica
recode :country_name => {
    "Antigua & Barbuda" => "Antigua and Barbuda", # (88.89)
    "Brasil" => "Brazil", # (83.33)
    "Bahamas" => "Bahamas (the)", # (70.0)
    "Dominican Rep." => "Dominican Republic (the)", # (68.42)
    "United States" => "United States of America (the)", # (60.47)
    :else => :copy
  }, :into => :varname2

Qualora la variabile da confrontare sia presente in un altro file, è possibile recuperare i dati con le istruzioni:

f(:varname).data:

spss.open "file1"
country_data = f(:country).data

spss.open "file2"
fuzzy_recode :country_name, to: :country_data

.get(filename).column(:varname):

country_data = spss.get("file1").column(:country)

spss.open "file2"
fuzzy_recode :country_name, to: :country_data

zscore¶

Standardizza le variabili:

y = (x - mean) / stdev

Argomenti:

varlist: l’elenco delle variabili da standardizzare
:into => varlist: l’elenco delle variabili destinazione (opzionale se non indicato, modifica le variabili originarie)
:size => n: la dimensione della variabile di destinazione
:ndec => n: il numero di decimali della variabile di destinazione

zscore s(:v100_,1..10), :into => s(:z100_,1..10)

center¶

Centra le variabili sulla media:

y = x - mean

Argomenti:

varlist: l’elenco delle variabili da centrare
:into => varlist: l’elenco delle variabili destinazione (opzionale se non indicato, modifica le variabili originarie)
:size => n: la dimensione della variabile di destinazione
:ndec => n: il numero di decimali della variabile di destinazione

venter s(:v100_,1..10), :into => s(:z100_,1..10)

rescale¶

Riscala le variabili rispetto a un minimo e a un massimo:

y = (x - from.min) / (from.max-from.min) * (to.max-to.min) + to.min

Argomenti:

varlist: l’elenco delle variabili da standardizzare
:into => varlist: l’elenco delle variabili destinazione (opzionale se non indicato, modifica le variabili originarie)
:from => min..max: l’intervallo della scala della variabile originaria
:to => min..max: l’intervallo della scala da generare
:size => n: la dimensione della variabile di destinazione (default: il numero di cifre del valore massimo di from)
:ndec => n: il numero di decimali della variabile di destinazione (default: 2)
:others => value: il valore per i casi non compresi nell’intervallo from (default: nil)

rescale s(:s10, 1..5), :into => s(:z10, 1..5), :from => 1..10, :to => 0..100

rescale s(:s10, 1..5), :into => s(:z10, 1..5), :from => 1..10, :to => 0..1

reduce¶

Applica una funzione a un set di variabili e crea una nuova variabile o inserisce i dati in una variabile esistente.

La funzione riceverà come argomenti la lista dei valori (o dei pesi) delle variabili specificate.

Argomenti:

varname: la variabile risultato
:function: la funzione da applicare
varlist: l’elenco delle variabili su cui applicare le funzioni
:label => true|false: assegna l’etichetta della variabile a partire dalle variabili di varlist (default: true)
:labels => true|false: assegna le etichette dei livelli della variabile a partire dalle variabili di varlist (default: true)
:w => array|hash: un array o un hash con i pesi da utilizzare al posto dei valori nel calcolo del risultato. In caso di mancata corrispondenza tra valore e peso, verà attribuito il valore nil
:print => false|true: stampa l’espressione generata (default: false)

reduce :q8, :max, s(:q8_, 1..10)
reduce :q10, :sum, s(:q10_, 1..10), :labels => false
reduce :q12, :sum, s(:q12_, 1..10), :w => [1, 2, 8, 15, 30, 46], :labels => false

apply¶

Applica una o più funzioni a una o più variabili e crea una nuova variabile o inserisce i dati in una variabile esistente.

Argomenti:

varname: la variabile risultato
varlist: l’elenco delle variabili su cui applicare le funzioni
:fun => {}: un hash con le funzioni e i rispettivi argomenti
:label => true|false: assegna l’etichetta della variabile a partire dalle variabili di varlist (default: true)
:labels => true|false: assegna le etichette dei livelli della variabile a partire dalle variabili di varlist (default: true)
:w => array|hash: un array o un hash con i pesi da utilizzare al posto dei valori nel calcolo del risultato. In caso di mancata corrispondenza tra valore e peso, verà attribuito il valore nil
print => false|true: stampa l’espressione generata (default: false)

apply :x, :indirizzo, :fun => {:split => [" ", 3]}, :print => true
apply :x, [:citta, :provincia], :fun => {:join => [" - "], :upcase => nil}, :print => true

interaction¶

Combina i livelli di due o più variabili in un’unica variabile.
Le variabili devono avere i livelli completamente definiti a meno che non sia specificato :levels => false.

Argomenti:

varname => [varlist]: il nome della variabile da creare e l’elenco delle variabili da combinare.
Se si utilizza :expr come varname, non crea nessuna variabile, ma restituisce un vettore con le espressioni per selezionare i casi di ciascuna combinazione
:sep => "": il separatore delle etichette dei livelli che vengono concatenati (default: ": ")
:label => "": l’etichetta della nuova variabile
:drop => true|false: true elimina le combinazioni che non hanno casi (default: false)
:levels => true|false: true considera solo i livelli definiti delle variabili e genera un errore se sono presenti valori non etichettati (o li ignora nel caso di :expr); false include anche i valori non etichettati (default: true)
:codes => :n|:merge: numera i nuovi codici progressivamente (:n) o unisce i codici delle variabili originarie (:merge) (default: :n)

interaction :mcrsexeta => [:mcr, :sesso, :eta], :drop => true
interaction :sexeta => [:sesso, :eta], :sep => " - ", :label => "CLASSI DI ETA' PER SESSO"

interaction :expr => [:sesso, :area]
# => ["sesso=1 AND area=1", "sesso=1 AND area=2", "sesso=1 AND area=3", "sesso=1 AND area=4", "sesso=2 AND area=1", "sesso=2 AND area=2", "sesso=2 AND area=3", "sesso=2 AND area=4"]

expand¶

Genera un set di variabili dummy da una o più variabili. Le nuove variabili vengono etichettate con l’etichetta del livello corrispondente. I livelli considerati sono quelli etichettati (levels).

Argomenti:

varname|varlist => root: la variabile o l’elenco di variabili originarie e la radice del nome delle variabili da creare
:name => :var_code|:var_lev|:lev: la modalità di definizione dei nomi delle variabili:
- :var_code: nome variabile più codice (default); se root contiene un cancelletto (#), il codice verrà sostituito al cancelletto invece di essere usato come suffisso
- :var_lev: nome variabile più etichetta del livello;
- :lev: solo etichetta del livello.
:zero => true|false: indica se effettuare il padding con lo zero del codice nei nomi delle variabili create (default: false)
:label => :label|:level|text: specifica l’etichetta delle variabili create:
- :label: come l’etichetta della variabile originaria (default);
- :level: come l’etichetta del livelllo;
- text: il testo indicato.
:type => :md|:int: il tipo di variabile da creare (default: :md)
:reflev => code: se specificato non genera la variabile per il codice specificato (livello di riferimento)

 expand :eta => :age_     # genera: age_1, age_2, age_3, ecc.
 expand :eta => "age#_1"  # genera: age1_1, age2_1, age3_1, ecc.

 varlist = expand [:sesso, :area, s(:x_,3)] => :p_, :label => "SOCIODEMO"
 md varlist

 varlist = [:seat, :cargo, :eng, :prince].map do |x|
   expand x => "#{x}", :name => :var_lev, :type => :int, :reflev => 1
 end.flatten
 p varlist # ["seat7", "seat8", "cargo3ft", "enghyb", "engelec", "prince35", "prince40"]

compress¶

Genera una variabile singola da più variabili. Il caso più comune è la ricostruzione di una variabile singola a partire da variabili dummy che in realtà non sono multiple.

I valori vengono attribuiti seguendo l’ordine in cui sono state elencate le variabili. In caso di sovrapposizione, i nuovi valori sovrascrivere le precedenti assegnazioni.

Argomenti:

varlist => varname|[varname, label]: l’elenco delle variabili da unire e la variabile di destinazione o la variabile di destinazione e la label
:codes => value|valuelist: il codice da considerare (default: 1). E’ possibile inoltre indicare un codice diverso per ciascuna variabile

 compress varlist => [newvar, "label"], :codes => value|valuelist

 compress s(:eta_,5) => [:eta, "ETA'"]
 compress s(:eta_,5) => [:eta, "ETA'"], :codes => 1
 compress s(:eta_,5) => [:eta, "ETA'"], :codes => [1,2,3,4,5]

pack¶

Genera una variabile singola tenendo il primo valore valido di un set di variabili. Il caso più comune è l’unione di variabili singole che sono state filtrate su basi diverse, ma che complessivamente costituiscono un unico vettore di dati.
Le etichette dei livelli vengono accumulate tra tutte le variabili secondo l’ordine definito dal parametro :multi: nuovi livelli vengono agggiunti, livelli esistenti vengono sovrascritti.

Argomenti:

varlist => varname: l’elenco delle variabili da unire e la variabile di destinazione
:label => :first|:last|text: l’etichetta della variabile di destinazione. Se non presente, la variabile risultante verrà etichettata con il testo comune, se trovato, delle etichette delle variabili o con l’etichetta della prima variabile
:multi => :first|:last|:min|:max: valore da tenere nel caso ci siano più valori sul record (default: :first). :multi influenza anche l’ordine in cui venono accumulate le etichette dei livelli: con :last si parte dalla prima, altrimenti dall’ultima.
:overlap => :warn|:error: comportamento in caso di più di un valore valido sulla riga di dati (default: warn)
:zero => :exclude|:drop: non considera lo zero un valore valido. Se non sono presenti altri valori validi :exclude restituisce zero, mentre :drop restistuisce blank (default: nil)
:values => valuelist: limita i valori da considerare validi a quelli elencati

 pack varlist => newvar

 pack [:v1, :v2] => :x1
 pack s(:v10_,1..5) => :x10, :mulyi => :last, :overlap => :error

compact¶

In una batteria di variabili, compatta i valori validi nelle prime variabili.

Argomenti:

varlist: l’elenco delle variabili da compattare

 compact varlist

 compact s(:v10_, 1..10)

unify¶

Unisce più variabili in una variabile mantenendo separati eventuali codici uguali. Le variabili devono essere numeriche con i livelli definiti. I livelli risultanti saranno numerati progressivamente a partire da uno.

Argomenti:

varlist => varname: la lista delle variabili da unire e la variabile risultato
:levels => []: (opzionale) l’elenco delle etichette dei livelli

 unify [:a1, :a2] => :atot

split¶

Separa i livelli di una variabile in più variabili.

Argomenti:

varname => [codes_groups]: il nome della variabile e un vettore con i gruppi di codici da separare nelle nuove variabili
:into => [varnames] l’elenco delle nuove variabili
:relevel => true|false se ricodificare da 1 i livelli delle variabili (default: true)

 split :p2 => [[1,2,3,7..14], 15..42], :into => s(:p2_,1,2)

split_vars¶

Crea nuove variabili uguali alle variabili di partenza, ma che contengono solo i gruppi di casi definiti da una data variabile. Restituisce un vettore con i nomi delle variabili create.

Argomenti:

:names: definisce un modello per i nomi delle nuove variabili: %{group} è il segnaposto per il livello della variabile che definisce i gruppi, %{var} è il segnaposto per il nome della variabile di origine. Se :names non viene specificato, i nomi vengono generati automaticamente secondo il modello %{var}_NomeVariabileGruppi_%{group}.
:labels: definisce un modello per le etichette delle variabili: %{group} è il segnaposto per l’etichetta del livello della variabile che definisce i gruppi, %{var} è il segnaposto per l’etichetta della variabile di origine. Se :labels non viene specificato, viene utilizzato il template: %{var} [%{group}].

 split_vars variable_group => variables_list, :names => template, :labels => template

 # crea delle copie delle variabili per ciascun livello di :sesso
 split_vars :sesso => [:d1, :d2] + s(:d7_, 1..10), :names => "%{var}_sex%{group}", :labels => "%{group}: %{var}"

 # assegna a varlist l'elenco delle variabili create
 varlist = split_vars :sesso => [:d1, :d2] + s(:d7_, 1..10)

 # genera variabili per il pannello
 create :tt, :value => 1, :label => "Totale"
 split_vars :sesso => [:tt, :area, :eta], :names => "%{var}_s%{group}", :labels => "%{var}"
 panels.add "Maschi" => [:tt_s1, :area_s1, :eta_s1], "Femmine" => [:tt_s2, :area_s2, :eta_s2]

mtx_vect_prod¶

Moltiplica la matrice dei dati delle variabili per un vettore di valori (matrice di una colonna). E’ normalmente utilizzata per moltiplicare una matrice design per un vettore di coefficienti. Restituisce il vettore dei risultati.

Argomenti:

varlist => vector: l’elenco delle variabili e il vettore dei valori da moltiplicare (il numero dei valori deve essere uguale al numero delle variabili)
:varname => size.ndec la variabile in cui inserire il risultato e il formato numerico

varlist = [:seat7, :seat8, :cargo3ft, :enghyb, :engelec, :prince35, :prince40]
coef = [0.9139369, -0.2927732,  0.7674734, -0.3228812, -0.9391472, -0.4761387, -1.4644974]

mtx_vect_prod varlist => coef, :util => 2.5

list varlist, :util, :sample => 5

(list 5 records of 54)
+----+----------+----------+----------+----------+----------+----------+----------+----------+
| #  |  seat7   |  seat8   | cargo3ft |  enghyb  | engelec  | prince35 | prince40 |   util   |
+----+----------+----------+----------+----------+----------+----------+----------+----------+
|    | int(1.0) | int(1.0) | int(1.0) | int(1.0) | int(1.0) | int(1.0) | int(1.0) | flt(2.5) |
+----+----------+----------+----------+----------+----------+----------+----------+----------+
|  9 |        0 |        0 |        0 |        0 |        1 |        0 |        1 | -2.40364 |
| 13 |        0 |        0 |        1 |        1 |        0 |        0 |        0 |  0.44459 |
| 23 |        1 |        0 |        0 |        1 |        0 |        1 |        0 |  0.11492 |
| 34 |        1 |        0 |        1 |        0 |        1 |        0 |        0 |  0.74226 |
| 45 |        0 |        1 |        0 |        0 |        1 |        0 |        1 | -2.69642 |
+----+----------+----------+----------+----------+----------+----------+----------+----------+