Category Archives: Linguaggi

Linguaggi di programmazione

SICP – cap. 2 – Esercizi: intervallo aritmetico – 11

ox_1hg-z

Continuo da qui con gli esercizi, qui.

Exercise 2.8: Using reasoning analogous to Alyssa’s [post precedente], describe how the difference of two intervals may be computed. Define a corresponding subtraction procedure, called sub-interval.

Semplicissimo, basta sostiuire il segno + con - in add-interval –ahemmm NO, l’intervallo massimo si ha, vedi Bill, [a,b] − [c,d] = [a − d, b − c], ecco:

(define (sub-interval x y)
  (make-interval (- (lower-bound x) 
                    (upper-bound y))
                 (- (upper-bound x) 
                    (lower-bound y))))

Aggiungo questa procedura al file apa.rkt e eseguo:

s161

Nota per me: nel file apa.rkt mancavano le procedure lower-bound e upper-bound; aggiunte.

A questo punto mi verrebbe quasi voglia di continuare con il prossimo ma il post diventerebbe troppo lungo, rimando alla prossima puntata 😜

I miei nerds di riferimento: Bill the Lizard, sicp-ex (interessante) e Drewiki.

:mrgreen:

NumPy – 14 – Le basi degli arrays di NumPy – 3

the_house_by_the_railroad

Continuo da qui, copio qui.

Ridimensionare gli arrays
Another useful type of operation is reshaping of arrays. The most flexible way of doing this is with the reshape method. For example, if you want to put the numbers 1 through 9 in a 3×3 grid, you can do the following:

np87

Note that for this to work, the size of the initial array must match the size of the reshaped array. Where possible, the reshape method will use a no-copy view of the initial array, but with non-contiguous memory buffers this is not always the case.

Another common reshaping pattern is the conversion of a one-dimensional array into a two-dimensional row or column matrix. This can be done with the reshape method, or more easily done by making use of the newaxis keyword within a slice operation:

np88

We will see this type of transformation often throughout the remainder of the book. Da ricordarselo; io sarei per l’altra versione.

Concatenazione e suddivisione di arrays
All of the preceding routines worked on single arrays. It’s also possible to combine multiple arrays into one, and to conversely split a single array into multiple arrays. We’ll take a look at those operations here.

Concatenazione di arrays
Concatenation, or joining of two arrays in NumPy, is primarily accomplished using the routines np.concatenate, np.vstack, and np.hstack. np.concatenate takes a tuple or list of arrays as its first argument, as we can see here:

np89

You can also concatenate more than two arrays at once:

np90

It can also be used for two-dimensional arrays:

np91

For working with arrays of mixed dimensions, it can be clearer to use the np.vstack (vertical stack) and np.hstack (horizontal stack) functions:

np92

Similary, np.dstack will stack arrays along the third axis.

Suddividere arrays
The opposite of concatenation is splitting, which is implemented by the functions np.split, np.hsplit, and np.vsplit. For each of these, we can pass a list of indices giving the split points:

np93

Notice that N split-points, leads to N + 1 subarrays. The related functions np.hsplit and np.vsplit are similar:

np94

Similarly, np.dsplit will split arrays along the third axis.

:mrgreen:

Bisogna essere precisi

mib4

Jake VanderPlas rockz! 🚀 e oggi recentemente ne ha dato un’ulteriore dimostrazione, con questo tweet.

Si sa che io ci metto un po’ a capire le cose e poi c’è il rischio che me le dimentico e allora ho deciso di mettere giù tutta la storia, qui in questo post.

Intanto con l’installazione di Anaconda (sempre per merito|colpa di Jake (e del suo corso su NumPy)) sono cambiati i comandi, ecco:

i0

Questo comporterà di ridefinire la shebang in caso di proteste degli script, l’evilussione 👿

OK, sono pronto per ripetere il test di Jake:

i1

Ecco 💥 errore! 😡

Twitter impone la concisione, a volte troppo. E Jake da per scontato che chi lo segue sia smart come lui. E anche i commentatori, tutti. Mi lasciano solo 😯

Però, dai, l’avevo già sentita questa raccomandazione: import * neanche una volta; che si potrebbe anche dire, con parole mie mai import *.
Verifico:

i2

Ecco, proprio come dice Jake: import *. Not even once.
Perché sum viene ridefinita in un modulo di Numpy, con altri argomenti.
OK, l’informatica e il mondo sono salvi; e io posso pensare ad altro 🎶 🎵 😄
:mrgreen:

SICP – cap. 2 – Esercizi: intervallo aritmetico – 10

nikon-small-world-air-bubbles-formed-from-melted-ascorbic-acid-crystals

Continuo da qui, oggi copio qui.

Esercizio esteso: intervallo aritmetico
Alyssa P. Hacker is designing a system to help people solve engineering problems. One feature she wants to provide in her system is the ability to manipulate inexact quantities (such as measured parameters of physical devices) with known precision, so that when computations are done with such approximate quantities the results will be numbers of known precision.
Alyssa è una lisp hacker 😜

Electrical engineers will be using Alyssa’s system to compute electrical quantities. It is sometimes necessary for them to compute the value of a parallel equivalent resistance Rp of two resistors R1 and R2 using the formula

s158

Resistance values are usually known only up to some tolerance guaranteed by the manufacturer of the resistor. For example, if you buy a resistor labeled “6.8 ohms with 10% tolerance” you can only be sure that the resistor has a resistance between 6.8 − 0.68 = 6.12 and 6.8 + 0.68 = 7.48 ohms. Thus, if you have a 6.8-ohm 10% resistor in parallel with a 4.7-ohm 5% resistor, the resistance of the combination can range from about 2.58 ohms (if the two resistors are at the lower bounds) to about 2.97 ohms (if the two resistors are at the upper bounds).

Alyssa’s idea is to implement “interval arithmetic” as a set of arithmetic operations for combining “intervals” (objects that represent the range of possible values of an inexact quantity). The result of adding, subtracting, multiplying, or dividing two intervals is itself an interval, representing the range of the result.

Alyssa postulates the existence of an abstract object called an “interval” that has two endpoints: a lower bound and an upper bound. She also presumes that, given the endpoints of an interval, she can construct the interval using the data constructor make-interval. Alyssa first writes a procedure for adding two intervals. She reasons that the minimum value the sum could be is the sum of the two lower bounds and the maximum value it could be is the sum of the two upper bounds:

(define (add-interval x y)
  (make-interval (+ (lower-bound x) 
                    (lower-bound y))
                 (+ (upper-bound x) 
                    (upper-bound y))))

Alyssa also works out the product of two intervals by finding the minimum and the maximum of the products of the bounds and using them as the bounds of the resulting interval. (min and max are primitives that find the minimum or maximum of any number of arguments.)

(define (add-interval x y)
  (make-interval (+ (lower-bound x) 
                    (lower-bound y))
                 (+ (upper-bound x) 
                    (upper-bound y))))

To divide two intervals, Alyssa multiplies the first by the reciprocal of the second. Note that the bounds of the reciprocal interval are the reciprocal of the upper bound and the reciprocal of the lower bound, in that order.

(define (add-interval x y)
  (make-interval (+ (lower-bound x) 
                    (lower-bound y))
                 (+ (upper-bound x) 
                    (upper-bound y))))

OK, con questo ecco…

Exercise 2.7: Alyssa’s program is incomplete because she has not specified the implementation of the interval abstraction. Here is a definition of the interval constructor:

(define (make-interval a b) (cons a b))

Define selectors upper-bound and lower-bound to complete the implementation.

Raccolgo per comodità nel file apa.rkt le 4 procedure che caricherò in Racket.

s159

A questo punto ecco i risultati

s160

AhemmmmBill the Lizard e sicp-ex.

Mi sa che si continuerà con questa roba, prossimamente 😳

:mrgreen:

NumPy – 13 – Le basi degli arrays di NumPy – 2

and-ng

Continuo dal post precedente, sempre copiando qui.

Suddividere arrays, costruire sub-arrays
Just as we can use square brackets to access individual array elements, we can also use them to access subarrays with the slice notation, marked by the colon (:) character. The NumPy slicing syntax follows that of the standard Python list; to access a slice of an array x, use this:

x[start:stop:step]

np77

A potentially confusing case is when the step value is negative. In this case, the defaults for start and stop are swapped. This becomes a convenient way to reverse an array:

np78

Sub-arrays con arrays-multidimensionali
Multi-dimensional slices work in the same way, with multiple slices separated by commas.

np79

Finally, subarray dimensions can even be reversed together:

np80

Accedere a righe e colonne dell’array
One commonly needed routine is accessing of single rows or columns of an array. This can be done by combining indexing and slicing, using an empty slice marked by a single colon (:):

np81

In the case of row access, the empty slice can be omitted for a more compact syntax:

np82

Visualizzazione di subarrays senza copiare
One important –and extremely useful– thing to know about array slices is that they return views rather than copies of the array data. This is one area in which NumPy array slicing differs from Python list slicing: in lists, slices will be copies. Consider our two-dimensional array from before:

np83

Now if we modify this subarray, we’ll see that the original array is changed! Observe:

np84

This default behavior is actually quite useful: it means that when we work with large datasets, we can access and process pieces of these datasets without the need to copy the underlying data buffer.

Creare copie di arrays
Despite the nice features of array views, it is sometimes useful to instead explicitly copy the data within an array or a subarray. This can be most easily done with the copy() method:

np85

If we now modify this subarray, the original array is not touched:

np86

Continua 😀
:mrgreen:

Gestione dati esterni in Octave

Kazimir Majorinc

Kazimir Majorinc

Un altro post perso(nale) su Octave. Una continuazione di questo.

A volte, anzi spesso, capita di dover elaborare dati provenienti da altre applicazioni o da chissà dove. Si può fare.

Ecco un esempio elementare, nella directory corrente ci sono i due files carica.m e elab.m che definiscono le due funzioni che intenderemo usare.

carica.m:

function res = carica()
    global dati
    dati = [1, 2, 3, 4, 5];
endfunction

elab.m:

function res = elab()
    global dati
    res = (dati(1) + dati(2)) * (dati(3) + dati(4)) / dati(5); 
endfunction

g0

OK, notare che dati è in memoria ma non presente nell’ambiente; occorre l’invocazione a global

g1

Spesso i dati arrivano da un foglio di calcolo, come questi:

g2

In questo caso è sufficiente salvarli come CSV

1,2,3
4,5,6
7,8,9

e l’intervento per trasformare il file risultante in funzione risulta minimo.

Non è sempre così immediato: consideriamo numeri non interi, con la virgola come siamo abituati noi (nel foglio di calcolo, non come programmatori):

g3

In questo caso il CSV può, a seconda delle impostazioni, essere così

"1,1","2,2","3,3"
"4,4",5,6

in cui essendo il separatore di campo la virgola (convenzione usuale per gli americani) i numeri reali vengono trasformati in stringhe. C’è un quirk aggiuntivo per Octave: gli interi verranno trasformati in float, in genere non dovrebbe essere un problema.

Non è però possibile mischiare numeri e stringhe, se del caso suddividere i files di dati:

g4

La soluzione alternativa, che io preferisco, è di reimpostare il separatore di campo a punto-virgola. È tra l’altro, a quanto mi risulta, una condizione abituale. In questo caso il CSV diventa

1,1;2,2;3,3
4,4;5;6

Per renderli usabili con Octave sono necessarie un po’ di modifiche in entrambi i casi. Con Linux sono semplicissime, basta uno script; altrimenti un programmino di poche righe (con Python, probabilmente).

:mrgreen:

SICP – cap. 2 – cosa s’intende per dati? – esercizi – 9

mib2

Oggi qui, continuando da qui.

Exercise 2.6: In case representing pairs as procedures wasn’t mind-boggling enough, consider that, in a language that can manipulate procedures, we can get by without numbers (at least insofar as nonnegative integers are concerned) by implementing 0 and the operation of adding 1 as

(define zero (lambda (f) (lambda (x) x)))

(define (add-1 n)
  (lambda (f) (lambda (x) (f ((n f) x)))))

This representation is known as Church numerals, after its inventor, Alonzo Church, the logician who invented the λ-calculus.

Define one and two directly (not in terms of zero and add-1). (Hint: Use substitution to evaluate (add-1 zero)). Give a direct definition of the addition procedure + (not in terms of repeated application of add-1).

Devo confessare che non ci sono riuscito 👿
Ho provato per un po’ ma non sono andato oltre a questo:

s155

che è solo la verifica che zero e add-1 sono procedure correttamente definite. In questi casi attivo il liz-segnale e arriva Bill the Lizard 😄 che risolve spiegando tutto.

È tutto di là, riporto solo il risultato, semplicissimo (una volta fatto 😜), questo

(define one
  (lambda (f) (lambda (x) (f x))))

s156

A questo punto diventa semplice definire two, basta chiamare una volta in più la f dentro lambda:

(define two
  (lambda (f) (lambda (x) (f (f x)))))

s157

Di lì Bill generalizza per i numeri successivi, Bill davvero über-rockz 😄.

Una cosa simile anche da sicp-ex e Spaceman Aki ma manca la spiegazione.

SICP a volte è troppo impegnativo per me. O dovrei essere più motivato, sapere di dover passare l’esame, senza l’aiuto di Bill &co.

:mrgreen:

Arrotondamento con Octave e bc

nikon-small-world-scales-of-a-butterfly-wing

Post che interessa probabilmente solo me, perso(nale), ma mi devo anche autogiustificare per tempo perso per chissà quale errore (mio) 😡
Ieri mi sono perso a rifare con Octave una cosa elementare, c’è e funziona perfettamente con il foglio di calcolo (tipo Excel) di Libre Office.
Forse è uno skill che ho acquisito nel tempo: quando sono sotto pressione, con qualcuno che ti fa fretta, “è pronto?”, “quanto ci vuole?” non riesco a produrre niente di buono. E se, come ieri, non si lavora nello stesso ufficio la situazione peggiora, diventa più macchinoso confrontarsi, scambiarsi le opinioni.
OK, finito il pippone ecco la soluzione in due versioni. Una premessa: uso il terminale (sono l’unico) ma ovviamente è per l’ambiente integrato. Inoltre ho il solito (mio) alias:

a-1

Il problema –semplicissimo– è di arrotondare un numero, float, alla seconda cifra decimale. È poi immediata la generalizzazione a qualsiasi altra cifra.
La prima soluzione, quella usuale è di moltiplicare il numero per 100, convertirlo in intero (in realtà no per Octave ma diventa intero nel senso che perde la parte decimale) e infine dividerlo per 100. Così:

a0

La verifica visualizza che il nuovo numero, na, sia davvero senza coda. L’operazione potrebbe sembrare perversa ma ci sono dei casi in cui si devono fare somme e moltiplicazioni nelle quali il risultato dev’essere “esatto” 👽

Un approccio diverso è quello di trasformare il numero in stringa formattandola con una funzione della famiglia di printf e poi ricavare il numero dalla stringa ottenuta, così:

a1

OK 😄 Semplice vero? eppure ieri non veniva 😡

E con bc? questione che ha deviato la discussione e –mysteryousamente– fatto evaporare il bug 😜

Al solito ho un alias, lo rimuovo per essere standard

b0

Chi non è abituato a Linux trova cose strane: solo interi! Ma è subito pronta l’opzione, via scale, numero di cifre decimali:

b1

Solo che non fa quello che si vuole: invece dell’arrotondamento si ha il troncamento 😯
Ma, come si faceva anticamente in Fortran, basta aggiungere mezzo centesimo al numero da arrotondare e tutto torna (vero Giòrs? (chissà se mi legge)).

b2

Notare che la divisione per 1 in questo caso è richiesta. Uh poteva essere anche una moltiplicazione 😜

Una particolarità di bc che sorprende i nuovi: il risultato è corretto per quante cifre si vuole ma non per tutte quelle visualizzate. Ecco l’esempio con π, calcolato come si faceva –OOPS! 😯  già detto– a() è l’arcotangente.

b3

Per quel che ne so basta non fidarsi delle ultime 2.

Lo so che è un post perso, ma mi sono sfogato. Voi non leggetelo.

:mrgreen:

NumPy – 12 – Le basi degli arrays di NumPy – 1

larry

Copio qui, continuando da qui.

Data manipulation in Python is nearly synonymous with NumPy array manipulation: even newer tools like Pandas (Chapter 3 [prossimamente]) are built around the NumPy array. This section will present several examples of using NumPy array manipulation to access data and subarrays, and to split, reshape, and join the arrays. While the types of operations shown here may seem a bit dry and pedantic, they comprise the building blocks of many other examples used throughout the book. Get to know them well!

We’ll cover a few categories of basic array manipulations here:

  • Attributes of arrays: Determining the size, shape, memory consumption, and data types of arrays
  • Indexing of arrays: Getting and setting the value of individual array elements
  • Slicing of arrays: Getting and setting smaller subarrays within a larger array
  • Reshaping of arrays: Changing the shape of a given array
    Joining and splitting of arrays: Combining multiple arrays into one, and splitting one array into many

Attributi degli arrays di NumPy
First let’s discuss some useful array attributes. We’ll start by defining three random arrays, a one-dimensional, two-dimensional, and three-dimensional array. We’ll use NumPy’s random number generator, which we will seed with a set value in order to ensure that the same random arrays are generated each time this code is run:

np68

Each array has attributes ndim (the number of dimensions), shape (the size of each dimension), and size (the total size of the array):

np69

Another useful attribute is the dtype, the data type of the array (which we discussed previously [post precedente]):

np70

Other attributes include itemsize, which lists the size (in bytes) of each array element, and nbytes, which lists the total size (in bytes) of the array:

np71

Indicizzazione degli arrays, accedere singoli elementi
If you are familiar with Python’s standard list indexing, indexing in NumPy will feel quite familiar. In a one-dimensional array, the ith value (counting from zero) can be accessed by specifying the desired index in square brackets, just as with Python lists:

np72

To index from the end of the array, you can use negative indices:

np73

In a multi-dimensional array, items can be accessed using a comma-separated tuple of indices:

np74

Values can also be modified using any of the above index notation:

np75

Keep in mind that, unlike Python lists, NumPy arrays have a fixed type. This means, for example, that if you attempt to insert a floating-point value to an integer array, the value will be silently truncated. Don’t be caught unaware by this behavior!

np76

La storia è ancora lunga, pausa 😉

:mrgreen:

SICP – cap. 2 – cosa s’intende per dati? – esercizi – 8

nikon-small-world-mouse-retinal-ganglion-cells

Continuo a copiare, oggi qui.

Exercise 2.5: Show that we can represent pairs of nonnegative integers using only numbers and arithmetic operations if we represent the pair a and b as the integer that is the product 2a3b. Give the corresponding definitions of the procedures cons, car, and cdr.

Panico! 👽  Mica sicuro di aver capito cosa si vuole che faccia 😯

La prima parte è semplice:

s152

Meno facile dal numero ottenuto ricavare i componenti a e b. Serve l’equivalente del comando di sistema factor:

s153

Devo determinare quante volte il numero è divisibile per 2 e 3, ahemmm, l’ha fatto uno dei miei nerds

(define (num-divs n d)
  (define (iter x result)
    (if (= 0 (remainder x d))
        (iter (/ x d) (+ 1 result))
        result))
  (iter n 0))

Applicando num-divs per 2 e 3 si ottiene la coppia –pair– di (a . b):

(define (pair num)
  (cons (num-divs num 2)
        (num-divs num 3)))

ho raccolto le due procedure nel file get-pair.rkt, ottengo:

s154

😄 Per avere a e b basta usare car e cdr della pair ottenuta, banale, non la riporto.

Da Bill the Lizard ho preso num-divs, più pulita della mia.
sicp-ex costruisce la funzione exp invece di usare expt built-in; poi diventa quasi normale.
La soluzione migliore è quella di Spaceman Aki, usa anche lui la funzione built-in remainder (ah! saperlo ricordarlo 💥).
Una soluzione simile anche da Drewiki.

:mrgreen: