Variabili: trasformazioni (3)

Nota

Per le espressioni vedi anche Espressioni

transform

Esegue le istruzioni passate nel blocco per ciascun record del dataset e inserisce il risultato in una variabile.
Le istruzioni utilizzate devono essere istruzioni valide del linguaggio Ruby per manipolare direttamente i dati e non funzioni di pTabs.
Se la variabile di destinazione non esiste, verrà creata.
Se i dati sono filtrati agisce solo sui record filtrati.

Suggerimento

Il blocco di istruzioni verrà applicato direttamente sui dati di ciascun record senza ulteriori mediazioni, quindi l’esecuzione può risultare molto più veloce rispetto all’utilizzo di altre istruzioni.

Argomenti

  • :varname => [varlist]: il nome della variabile che riceverà i dati e la lista di variabili necessarie all’esecuzione delle istruzioni (eventualmente può contenere anche la variabile di destinazione)
    I parametri del blocco di istruzioni devono corrispondere nel numero e nell’ordine all’elenco di variabili specificate in [varlist], ma possono avere qualsiasi nome.
  • :all => true|false: true forza l’esecuzione su tutti i record anche in caso sia attivo un filtro (default false)
  • :label => "": (opzionale) l’etichetta della variabile
  • :levels => {}: (opzionale) le etichette dei livelli della variabile
  • :pos => :ini|:end|{:before|:after => :varname}: sposta la variabile di destinazione nella posizione indicata (default: :end)

La variante transform! imposta il parametro :all=> true.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
transform :x11 => [:d5, :d1], :all => true do |x, y|
  x.nil? || y == 2 ? 1 : 2
end

transform :x12 => [:v10, :v1, :v2, :x12] do |v10, v1, v2, x|
  if v10 && v10 > 0
    [v1, v2].compact.max
  else
    x
  end
end

apply_functions

Applica una o più funzioni a una o più variabili e crea una nuova variabile o inserisce i dati in una variabile esistente.
Per l’elenco delle funzioni si veda Espressioni.
Le funzioni e i vari parametri verranno convertiti in un’istruzione compute.

Argomenti:

  • varname: la variabile risultato
  • varlist: l’elenco delle variabili su cui applicare le funzioni
  • :fun:
    • :name: il nome funzione
    • []: un elenco di nomi di funzione
    • {}: un hash con i nomi delle funzioni e i rispettivi argomenti (se una funzione non ha argomenti inserire nil)
  • :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: true)
1
2
3
apply_functions :q8, s(:q8_, 1..10), :fun => :max
apply_functions :x, :indirizzo, :fun => {:split => [" ", 3]}, :print => false
apply_functions :x, [:citta, :provincia], :fun => {:join => [" - "], :upcase => nil}

mean_if

Assega ai casi selezionati dalla condizione il valore medio dei casi residui.

Argomenti:

  • varlist: il nome della variabile o l’elenco dei nomi delle variabili
  • expression: la condizione per selezionare i casi
  • :round => false|#: il numero di cifre a cui arrotondare il valore: se false non arrotonda, se omesso utilizza il numero di decimali del formato della variabile
1
2
 mean_if :eta, "ANY(ser_no, 1, 5, 10)"
 mean_if :eta, "OUTSIDE(eta, 18, 60)"

min_if

Assega ai casi selezionati dalla condizione il valore minimo dei casi residui.

Argomenti:

  • varlist: il nome della variabile o l’elenco dei nomi delle variabili
  • expression: la condizione per selezionare i casi
  • :round => false|#: il numero di cifre a cui arrotondare il valore: se false non arrotonda, se omesso utilizza il numero di decimali del formato della variabile
1
 min_if :eta, "LT(eta, 18)"

max_if

Assega ai casi selezionati dalla condizione il valore massimo dei casi residui.

Argomenti:

  • varlist: il nome della variabile o l’elenco dei nomi delle variabili
  • expression: la condizione per selezionare i casi
  • :round => false|#: il numero di cifre a cui arrotondare il valore: se false non arrotonda, se omesso utilizza il numero di decimali del formato della variabile
1
 max_if :eta, "GT(eta, 60)"

fun_if

Assega ai casi selezionati dalla condizione il valore calcolato applicando la funzione indicata ai casi residui.

Argomenti:

  • varlist: il nome della variabile o l’elenco dei nomi delle variabili
  • :function: la funzione da applicare ai valori
  • expression: la condizione per selezionare i casi
  • :round => false|#: il numero di cifre a cui arrotondare il valore: se false non arrotonda, se omesso utilizza il numero di decimali del formato della variabile
1
 fun_if :eta, :max, "GT(eta, 60)"

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
1
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
1
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)
1
2
3
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

autorecode

Ricodifica automaticamente una variabile stringa in una variabile categoriale.

La variabile stringa originaria verrà sovrascritta e salvata in una copia.

Argomenti:

  • :vars => varlist: l’elenco delle variabili da ricodificare
  • :sort => :a|:d: (opzionale, default :a) l’ordine dei livelli risultanti: :a ordine aspendente; :d ordine discendente
  • :drop => false|true: (opzionale, default false) false salva una copia della variabile originaria; true elimina la variabile originaria
  • :root => "string": (opzionale, default x__string__) prefisso per la copia della variabile originaria
  • :levels => {}: (opzionale) i livelli delle variabili; eventuali voci aggiuntive verranno codificate oltre i livelli definiti
  • :meta => filename: (opzionale) utilizza per le ricodifiche un file xlsx con i codici e le etichette delle variabili (Tabella di metadati). Variabili non presenti nel file di metadati verranno ignorate
  • :ignore => "string": (opzionale) caratteri da ignorare nelle stringhe di dati
  • :ignore_symbol => false|true: (opzionale, default false) ignora simboli presenti nelle stringhe di dati: -+*=<>\[\](){}|\/,.;:°^!?
  • :ignore_number => false|true: (opzionale, default false) ignora numeri presenti nelle stringhe di dati
  • :ignore_space => false|true: (opzionale, default false) ignora spazi presenti nelle stringhe di dati
  • :ignore_case => false|true: (opzionale, default false) ignora maiuscole/minuscole
  • :syntax => false|:levels|:both: (opzionale, default false) :levels stampa le istruzioni per i livelli; :both stampa anche le istruzioni per la label

Passando codici ed etichette con :levels o con :meta, la corrispondenza verrà cercata non solo nelle etichette, ma anche nei codici, ovvero i dati potranno contenere un misto di etichette e di codici.

Con :meta è possbile convertire un file che contiene le etichette dei valori al posto dei dati, in un normale file codificato. Vedi anche xlsx.convert.

autorecode!

Come autorecode, ma con i parametri :drop => true, :syntax => :levels.

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.

1
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:
1
2
3
4
5
spss.open "file1"
country_data = f(:country).data

spss.open "file2"
fuzzy_recode :country_name, to: :country_data
  1. .get(filename).column(:varname):
1
2
3
4
country_data = spss.get("file1").column(:country)

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

mtx_vect_prod

_images/mtx_vect_prod.png

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
1
2
3
4
5
6
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 |
+----+----------+----------+----------+----------+----------+----------+----------+----------+

vardiff

Confronta i dati di due variabili e copia i valori differenti in una nuova variabile.

Argomenti:

  • var1: il nome della prima variabile da confrontare
  • var2: il nome della seconda variabile da confrontare
  • :into => varname: il nome della nuova variabile con i valori differenti
  • :blank => value: il valore da utilizzare nel caso il valore differente sia blank (default: nil)
  • :copy => 1|2: 1 copia il valore dalla prima variabile, 2 copia il valore dalla seconda variabile (default: 2)
1
vardiff :id_comu1, :id_comu2, :into => :comu_diff, :blank => 999

derotate

IN TEST

Scambia le risposte tra diversi set di variabili secondo la rotazione di appartenenza di ciascun caso.

Argomenti:

  • Le rotazioni possono essere definite in due modi:
    • da una variabile numerica che indica l’appartenenza del record a una rotazione (cella).
      • :rot => {varname => [[],[],...]}: specifica la variabile che contiene l’identificativo della rotazione e lo schema delle rotazioni come vettore multidimensionale
    • da una serie di variabili numeriche che identificano l’oggetto di ciascun set di domande somministrate. Il numero di queste variabili deve essere uguale al numero di set di variabili da derotare.
      • :rot => varlist: specifica l’elenco delle variabili che contendono l’identificativo dell’item oggetto della valutazione
  • :init: le variabili da derotare
    • :init => [[:a1, :b1, :c1], [:a2, :b2, :c2], ...]: indicate esplicitamente come vettore multidimensionale
    • :init => ["a%", "b%", "c%"]: un vettore con dei nomi che contengono il segnaposto % per il numero di ciascuna serie
  • :final: le variabili di destinazione
    • :final => [[:x1, :y1, :z1], [:x2, :y2, :x2], ...]: indicate esplicitamente come vettore multidimensionale
    • :final => ["x%", "y%", "z%"]: un vettore con dei nomi che contengono il segnaposto % per il numero di ciascuna serie
    • se omesso verranno sovrascritte le variabili iniziali (le serie di variabili iniziali e quelle finali devono coincidere)
  • :prefix => "stringa": se viene omesso :final e :init è indicato come lista con il segnaposto, la stringa di caratteri verrà anteposta al nome delle variabili iniziali per formare le variabili finali

Nell’esempio, le ipotetiche domande a, b e c vengono ripetute per tre volte per testare tre diversi oggetti. Le domande vengono somministrate ai vari soggetti in quattro diverse sequenze. E’ da notare che il numero di oggetti da testare e il numero di permutazioni non sono necessariamente uguali.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
 # Metodo 1: con id rotazione

 # :rotazione è la variabile che identifica la rotazione/cella
     rotazione
   1     2
   2     4
   3     3
   4     1
   5     1
   6     2
   ...

 # rschema contiene l'elenco delle permutazioni utilizzate (deve corrispondere ai livelli della variabile :rotazione)
 rschema = [ [1,2,3],            # per :rotazione = 1
             [2,3,1],            # per :rotazione = 2
             [3,1,2],            # per :rotazione = 3
             [1,3,2] ]           # per :rotazione = 4

 derotate :init => ["a%","b%"]+s("c%_#",1..10), :prefix => 'x', :rot => {:rotazione => rschema}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
 # Metodo 2: con variabili sequenza

 # le variabili :ro1, :ro2 e :ro3 contengono la sequenza degli elementi (l'ordine dei test)
     ro1 ro2 ro3
   1   2   3   1
   2   1   3   2
   3   3   1   2
   4   1   2   3
   5   1   2   3
   6   2   3   1
   ...

 derotate :init => ["a%","b%"]+s("c%_#",1..10), :prefix => 'x', :rot => s(:ro,3)

seqvars

Genera una sequenza numerica e inserisce ciascun elemento in una variabile.

Argomenti:

  • varlist: le variabili in cui inserire la sequenza numerica. Se non esistono verranno create.
  • :from => #|varname: il numero da cui partire o il nome di una variabile contenente il numero (default 1)
  • :to => #|varname: il numero a cui arrivare o il nome di una variabile contenente il numero
  • :step => #: l’incremento tra un elemento e l’altro della serie (default 1)
  • :n => #: il numero di elementi da generare (default il numero di variabili)
  • :rnd => true|false: randomizza il risultato (default false)
  • :seed => #: il seed per replicare i risultati (quando specificato :rnd)
  • :rev => true|false: ordina in senso inverso il risultato (default false)
  • :size => #: la dimensione delle variabili se non esistono (default 1)
1
2
3
4
5
seqvars s(:a,1..3)

seqvars s(:b,1..10), :to => :maxnum, :random => true

seqvars s(:c,1..15), :from => 10, :step => 10

.mutate_temp

Il metodo .mutate_temp, applicabile a un nome di variabile o a una lista di nomi di variabili, memorizza e ripristina i dati delle variabili, le etichette e i valori mancanti.
Ovvero, varlist.mutate_temp ...:

  • memorizza i dati e gli attributi contenuti nelle variabili elencate (varlist)
  • esegue il codice contenuto nel blocco
  • ricopia i dati e gli attributi mememorizzati nelle variabili (varlist)

Argomenti:

  • :data => false|true: se true memorizza e ripristina i dati delle variabili (default true)
  • :attributes => false|true: se true memorizza e ripristina le etichette delle variabili, le etichette dei livelli e le definizioni dei valori mancanti (default true)
1
2
3
4
:eta.mutate_temp do |v|
  classify :eta => {[1,2] => "14-24 anni", [3,4] => "25-34 anni"}
  cat :eta
end

1
2
3
4
5
6
7
base_multi :all
[1,2,3,4].each do |i|
   s(:v7_,1..10).mutate_temp(:attributes => false) do |varlist|
     valid_if varlist, :v6 => i
     md varlist
  end
end

1
2
3
4
s(:v7_,1..10).mutate_temp(:data => false) do |varlist|
  levels s(:v7_,1..10) => {1 => "Sì", 0 => "No"}
  xcat s(:v7_,1..10)
end

Attenzione

Solo i dati delle variabili su cui si applica il metodo verranno ripristinate, non eventuali altre variabili modificate all’interno del blocco

Suggerimento

.mutate_temp è utile, per esempio, quando occorre selezionare un sottoinsieme di casi, ma non è possibile utilizzare la funzione filter, quando si vuove riclassificare in modo temporaneo una variabile o modificarne temporaneamente le etichette