Accesso diretto ai dati

f()

f(:nomevar).data o f(:nomevar).d restituisce un vettore con i dati della variabile.

f(:nomevar) << [] assegna i dati alla variabile, Il vettore deve contenere l’esatto numero di valori (uno per ciascun record).

1
2
3
4
5
6
7
8
f(:v1).data       # => [nil, nil, nil, nil, 2, 2, 1, 3, 2, 2, 3, 3, 4, 4, 2, 3, 3, 2, 2, 3, ...]
f(:v1) << [0, 0, 0, 0, 2, 2, 1, 3, 2, 2, 3, 3, 4, 4, 2, 3, 3, 2, 2, 3, ...]

f(:v1) << f(:v1).d.map { |x| x ? x : 9 }

data = f(:d5).d
d5mean = data.compact.sum.to_f / data.compact.size
f(:d5) << data.map { |x| x ? x : d5mean.round(2) }

row_index :nomevar imposta l’indice sui valori di una specifica variabile. row_index riattribuisce l’indice al numero di riga.

current_index # sposta l’indice al record indicato.

index

Le funzioni c e row possono utilizzare come indice il numero di riga oppure una variabile contenete valori univoci.

row_index :nomevar imposta l’indice sui valori di una specifica variabile.

row_index riattribuisce l’indice al numero di riga.

current_index # sposta l’indice al record indicato.

c() o cell()

c(:nomevar, index) identifica una cella della matrice di dati corrispondente alla variabile (:nomevar) per un dato record (index). Se uno o entrambi gli argomenti vengono omessi, verranno utilizzati quelli dell’istruzione c precedente.

c().value restituisce il valore della cella.

c().value = value o c() << value asseggna un valore alla cella.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
 c(:v1, 2)           # => [v1:9] 9
 c(:v1, 2).value     # => 0
 c(:v1, 2) << 9
 f(:v1).data         # => [0, 9, 0, 0, 2, 2, 1, 3, 2, 2, 3, 3, 4, 4, 2, 3, 3, 2, 2, 3, ...]

 row_index :serial_no

 c(:v1, 3450) << 7

 current_index 3456
 c(:v1) << 9
 c                   # => [v1:<3456>] 9
 c(:v1).value        # => 9
 c(3456).value       # => 9
 c.value             # => 9

E’ possibile indicare come indice il nome della variabile e il valore c(:nomevar, :index_var => index_value). In tal caso la variabile indice verrà impostata solo in modo temporaneo.

1
2
 c(:v1, :serial_no => 3450) << 7
 c(:v1, :serial_no => 3450).value

row

row restituisce il contenuto di un record del dataset sotto forma di un Hash. Il risultato può essere assegnato a una variabile. Il metodo .values dell’hash restituisce eventualmente l’elenco dei valori.

  • #: un numero che identifica il numero di riga o il valore della variabile indice se impostata
  • :id_varname => value: identifica il record con quesso specifico valore su una variabile che funge da identificativo di record
  • :keeep => varlist: permette di restituire solo le variabili specificate
1
2
3
4
5
6
7
p row(2)                                         # => {"ser_no"=>3, "sesso"=>1.0, "area"=>1, "d1"=>4, "d7_1"=>1, "d7_2"=>0, "d7_3"=>0, "d7_4"=>1,...
p row(2, :keep => s(:d7_,3))                     # => {"d7_1"=>1, "d7_2"=>0, "d7_3"=>0}
p row(:ser_no => 12)                             # => {"ser_no"=>12, "sesso"=>2.0, "area"=>1, "d1"=>4, "d7_1"=>nil, "d7_2"=>0, "d7_3"=>0, "d7_4"=...
p row(:ser_no => 12, :keep => s(:d7_,3))         # => {"d7_1"=>nil, "d7_2"=>0, "d7_3"=>0}
p row(:ser_no => 12, :keep => s(:d6_,10)).values # => [nil, 2, 2, 4, 3, 2, 3, 4, 1, 1]

rec45 = row(:ser_no => 45)

rows

rows permette di accedere ai dati del dataset un record alla volta. Se è attivo un filtro, restituisce solo i record attivi.

All’interno del blocco è possibile far riferimento al valore della variabile, sia con la sintassi c(:v1).value, sia semplicemente con il nome della variabile v1 (senza virgolette o due punti). Le espressioni, gli operatori, ecc. utilizzano la sintassi di Ruby: equal ==; and &&; or ||.

Per assegnare un valore alla variabile, è possibile utilizzare sia la sintassi c(:v1) << value (o l’equivalente c(:v1).value = value), sia la sintassi set :v1 => value (che permette anche assegnamenti su più variabili).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
rows.each do |row|
  c(:v1) << 99 if c(:v100).value == 9
  set [:v2, :v3] => 0 unless v500      # ovvero: if v500 == nil
end

rows.each do |row|
  break if row.index > 100             # .index restituisce sempre il numero del record
  if area == 1 && npc == 4 && x3 == nil
    set :v5 => 4, s(:v7_,10) => 0, [:v23, :v24, :v25] => [1, 2, 3]
  end
end

rows.each do |row|
  if d5 == nil
    puts "- (#{row.index}) Record ID: #{serial_no}"
    p [area, sesso, eta, titolo, prof, comune]
  end
end
# - (5) Record ID: 81
# [3, 2, 2, 3, 3, "AIELLI"]
# - (11) Record ID: 88
# [3, 1, 3, 3, 1, "AIRASCA"]
# - (12) Record ID: 91
# [3, 1, 3, 3, 1, "AIRUNO"]
# - (16) Record ID: 213
# [1, 2, 1, 2, 3, "ACQUANEGRA CREMONESE"]

rows.to_h(varlist) genera un vettore contenente per ciascun record un hash dei valori delle variabili specificate.

1
2
3
4
5
6
7
8
dset = rows.to_h(:serial_no, :area, :sesso, :d1, :d2, :d5)
pp dset
# [{"serial_no"=>2, "area"=>1, "sesso"=>2, "d1"=>4, "d2"=>3, "d5"=>4},
#  {"serial_no"=>99, "area"=>1, "sesso"=>2, "d1"=>-2, "d2"=>1, "d5"=>0},
#  {"serial_no"=>10, "area"=>1, "sesso"=>1, "d1"=>4, "d2"=>1, "d5"=>4},
#  {"serial_no"=>29, "area"=>1, "sesso"=>1, "d1"=>4, "d2"=>1, "d5"=>4},
#  {"serial_no"=>32, "area"=>1, "sesso"=>2, "d1"=>4, "d2"=>3, "d5"=>2},
# ...]

rows.to_a(varlist) genera un vettore contenente per ciascun record un vettore dei valori variabili specificate.

1
2
3
4
5
6
7
8
dset = rows.to_a(:serial_no, :area, :sesso, :d1, :d2, :d5)
pp dset
# [[2, 1, 2, 4, 3, 4],
#  [99, 1, 2, -2, 1, 0],
#  [10, 1, 1, 4, 1, 4],
#  [29, 1, 1, 4, 1, 4],
#  [32, 1, 2, 4, 3, 2],
# ...]

column

column restituisce un vettore con i dati della variabile. Se è attivo un filtro, restituisce solo i dati dei record attivi.

1
column :etaq  # => [15, 24, 27, 19, 25, 20, 33, 20, 34, 27, 26, 29, ...]

columns

columns restituisce un vettore con i vettori dei dati delle variabili. Se è attivo un filtro, restituisce solo i dati dei record attivi.

1
columns :area, :etaq  # =>[[1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 3, ...], [15, 24, 27, 19, 25, 20, 33, 20, 34, 27, 26, 29, ...]]

matrix

matrix restituisce un vettore con i vettori delle righe dei dati delle variabili. Se è attivo un filtro, restituisce solo i dati dei record attivi.

1
matrix :sesso, :area, :etaq   # => [[2, 1, 15], [2, 1, 24], [1, 1, 27], [1, 1, 19], [2, 1, 25], [1, 3, 20], [2, 3, 33], ...]

add o add_records

add o add_records accoda nuovi records al dataset.

Parametri:

  • number: aggiunge il numero indicato di record vuoti
  • []: un vettore contenente una riga di dati. E’ necessario specificare tanti dati quante sono le variabili
  • [[],[]...]: un vettore contenente un vettore per ciascuna riga di dati E’ necessario specificare tanti dati quante sono le variabili
  • {}: un hash con le coppie :nome variabile => valore di una riga di dati. E’ possibile non indicare tutte le variabili; i relativi dati verranno impostati a nil
  • [{},{}...]: un vettore contenente un hash per ciascuna riga di dati E’ possibile non indicare tutte le variabili; i relativi dati verranno impostati a nil
1
2
3
4
5
6
7
spss.open "datafile", :keep => [:v1, :v2, :v3, :v4, :v5]

add 2
add [401, 2, 4, 9, 0.0001]
add [ [402, 2, 4, 9, 0.0001], [403, 1, 3, 2, 1.0001] ]
add v1: 404, v2: 2, v3: 4, v4: 9, v5: 0.0001
add [ {v1: 404, v3: 4, v4: 9}, {v1: 405, v2: 1, v5: 1.0001} ]

Generazione di un dataset nello script

pTabs all’avvio o quando si crea un nuovo workspace (ws.new), genera un dataset vuoto a cui è possibile aggiungere variabili e records di dati.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
 new :serial, :type => :int, :size => 2
 new :price, :type => :float, :size => 8, :ndec => 3
 new :name, :type => :string, :size => 10

 add [
   [1,   0.2 , "AAA"],
   [2,  12.3 , "BBB"],
   [3, 124.25, "CCC"],
   [4,   1.4 , "DDD"],
 ]

add [
   {serial: 5, price: 45.67},
   {serial: 6, name: "FFF"},
 ]

 list

- la variabile <serial> è stata creata
- la variabile <price> è stata creata
- la variabile <name> è stata creata

(list 6 records)
+---+----------+-----------+---------+
| # |  serial  |   price   |  name   |
+---+----------+-----------+---------+
|   | int(2.0) | flt(8.3)  | str(10) |
+---+----------+-----------+---------+
| 1 |        1 |       0.2 | AAA     |
| 2 |        2 |      12.3 | BBB     |
| 3 |        3 |    124.25 | CCC     |
| 4 |        4 |       1.4 | DDD     |
| 5 |        5 | 12345.678 |         |
| 6 |        6 |           | FFF     |
+---+----------+-----------+---------+

Nel caso non sia stata creata nessuna variabile, pTabs le genera automaticamente in base ai dati forniti.

1
2
3
4
5
6
7
8
 ws.new :ds2
 add [
   [1,   0.2 , "AAA"],
   [2,  12.3 , "BBB"],
   [3, 124.25, "CCC"],
   [4,   1.4 , "DDD"],
 ]
 list

(list 4 records)
+---+----------+----------+--------+
| # |    v1    |    v2    |   v3   |
+---+----------+----------+--------+
|   | int(1.0) | flt(3.2) | str(3) |
+---+----------+----------+--------+
| 1 |        1 |      0.2 | AAA    |
| 2 |        2 |     12.3 | BBB    |
| 3 |        3 |   124.25 | CCC    |
| 4 |        4 |      1.4 | DDD    |
+---+----------+----------+--------+

1
2
3
4
5
6
7
8
 ws.new :ds3
 add [
   {:id => 1, :country => "PT"},
   {:id => 2, :country => "IT"},
   {:id => 3, :country => "GR"},
   {:id => 4, :country => "SP"},
 ]
 list

(list 4 records)
+---+----------+---------+
| # |    id    | country |
+---+----------+---------+
|   | int(1.0) | str(2)  |
+---+----------+---------+
| 1 |        1 | PT      |
| 2 |        2 | IT      |
| 3 |        3 | GR      |
| 4 |        4 | SP      |
+---+----------+---------+