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
• :else => value: (opzionale) il valore da assegnare se la condizione non è verificata
• :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

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
    • :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
• :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"

new :v2, :single, 1.0, :label => "Sesso per età"
values_if :v2,
  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},
  }

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, ..., :other => label}: le coppie di espressione e etichetta. :other 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_ => {
    "v1=1 AND v1_1=2" => "Gruppo 1",
    "ANY(v3,13,7)"    => "Gruppo 2",
    "GT(v2_2,3)"      => "Gruppo 3",
    :other            => "Complemento"
  }, :label => "Etichetta batteria"

one_if, zero_if

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

value_if_na

Come value_if, ma imposta il valore solo se la variabile ha valore blank, cioè non sovrascrive un valore valido. Se le variabili non esistono, verranno create. L’argomento :else non è consentito.

value_if_na varlist, valuelist[, expression]

value_if_na :v1, 1, "v1=2"
value_if_na s(:d7_10), 1, :d6 => 1

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_,10)
count :c6b, nil, s(:d6_,10)
count :c6c, [nil,0], s(:d6_,10)
count :c6d, :valid, s(:d6_,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

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_,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
• :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 sono 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. Eventuali valori che non rientrano nelle classi specificate verranno riportati
• :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

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

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)
• :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"

 lump s(:v32,5), :n => 10, :into => s(:x32,5), :renum => true

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:

1. f(:varname).data:

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

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

2. .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_,10)
reduce :q10, :sum, s(:q10_,10), :labels => false
reduce :q12, :sum, s(:q12_,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)

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_,10), :names => "%{var}_sex%{group}", :labels => "%{group}: %{var}"

 # assegna a varlist l'elenco delle variabili create
 varlist = split_vars :sesso => [:d1,:d2]+s(:d7_,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 |
+----+----------+----------+----------+----------+----------+----------+----------+----------+