La Geometria interattiva (superiori)

Da Wikiversità, l'apprendimento libero.
Jump to navigation Jump to search
lezione
La Geometria interattiva (superiori)
Tipo di risorsa Tipo: lezione
Materia di appartenenza Materie:
Avanzamento Avanzamento: lezione completa al 100%.

Introduzione[modifica]

Cos'è la geometria interattiva, i primi oggetti.

La geometria interattiva permette di creare gli oggetti della geometria euclidea:

  • Punti.
  • Rette.
  • Circonferenze.

I punti possono essere:

  • Liberi.
  • Vincolati a una linea.
  • Intersezioni di due linee.

Le rette possono essere anche:

  • Semirette.
  • Segmenti.

I punti base possono essere trascinati con il mouse quindi, se ho realizzato una costruzione geometrica a partire da alcuni punti, quando muovo questi punti tutta la costruzione si muove. La Geometria interattiva mette in evidenza quali sono le caratteristiche invarianti e quali quelle variabili di una certa costruzione. Esistono molti programmi che permettono di operare con la geometria interattiva, a questo indirizzo se ne possono trovare ben 36: http://en.wikipedia.org/wiki/List_of_interactive_geometry_software In questo testo propongo l'uso del linguaggio Python con la libreria pyig. È comunque possibile seguire il percorso proposto anche con un programma punta e clicca invece che con un linguaggio. Per l'installazione di Python e della libreria Pygraph, che contiene anche Pyig, vedi l'introduzione alla geometria della tartaruga nel volume precedente.

Installiamo un interprete[modifica]

Cosa installare per lavorare con la geometria interattiva.

Python

Chi usa come sistema operativo Windows può installare Python a partire dal sito: www.python.org/downloads E installare la versione più recente della serie 3.x.x. Chi utilizza altri sistemi operativi può installarlo partendo dal proprio gestore di pacchetti installando Python3 e anche IDLE.

pygraph

Si può scaricare l'intero pacchetto da: bitbucket.org/zambu/pygraph/downloads A questo punto bisogna fare a mano alcune operazioni che dipendono dal proprio sistema operativo:

Windows

  • Scompattare il file scaricato.
  • Entrare nella cartella pygraph.
  • Selezionare il file pygraph.pth e la cartella pygraph lì presenti.
  • Copiarli nella cartella C:\Python3x\Lib\site-package

Dove “Python3x” potrebbe essere: “Python34”, “Python35” ...

MacOSX

  • Scompattare il file scaricato.
  • Entrare nella cartella pygraph.
  • Selezionare il file pygraph.pth e la cartella pygraph lì presenti.
  • Copiarli nella cartella HD/libreria/python/3.x/site-package

Se in “HD/libreria/python/” non è presente la cartella “3.4/site-packages”, bisogna crearla.

GNU/Linux

  • Scompattare il file scaricato.
  • Entrare nella directory pygraph.
  • Aprire un terminale in questa directory.
  • Copiare la cartella pygraph e il file pygraph.pth nella cartella /usr/lib/python3/dist-packages/

Dato che in Linux, per modificare le directory di sistema bisogna essere amministratori, il comando da dare assomiglierà a questo:

sudo cp -R python* /usr/lib/python3/dist-packages/

A questo punto se tutto è andato bene dovremmo essere in grado di avviare Python-IDLE e dare il comando: import pyig as ig Se non succede nulla vuol dire che tutto è andato a buon fine, se invece appare una scritta rossa, bisogna leggere almeno l'ultima riga e cercare di capire cosa non è andato bene. Magari ci si può far aiutare da qualcuno esperto nell'installazione di programmi. Se tutto è andato per il verso giusto possiamo procedere.

Riassumendo

  • La geometria interattiva permette di creare e di muovere gli oggetti della geometria euclidea.
  • Ci sono molti programmi che permettono di giocare con la geometria interattiva, noi utilizzeremo il linguaggio Python con la libreria pyig.
  • Gli oggetti di base sono:
    • Punti:
      • Liberi.
      • Vincolati.
      • Intersezioni.
    • Rette:
      • Rette.
      • Semirette.
      • Segmenti.
    • Circonferenze.

Elementi fondamentali[modifica]

Come creare un piano vuoto, dei punti, delle rette e altri oggetti geometrici.

La geometria interattiva permette di visualizzare facilmente elementi varianti e invarianti di una certa costruzione geometrica.

Strumenti[modifica]

In questo capitolo utilizzeremo i seguenti strumenti di Pyig:

  • Point(x, y) crea un punto con date coordinate.
  • Line(p0, p1) crea una retta passante per p0 e p1.
  • Ray(p0, p1) crea una semiretta con origine in p0 passante per p1.
  • Segment(p0, p1) crea un segmento di estremi p0 e p1.
  • Circle(centro, punto) crea una circonferenza dati il centro e un suo punto.

Problema[modifica]

Crea un piano e disegna i quattro vertici di un quadrato, poi disegna i quattro lati del quadrato. Modifica poi la figura trascinando i punti base con il mouse.

Soluzione guidata[modifica]

1. Crea un nuovo programma e salvarlo con il nome: gi01_elementi.py. Per creare un nuovo programma:

  1. Avvia IDLE (in Windows: menu-programmi-Python-IDLE).
  2. crea un nuovo editor: menu-file-new window.
  3. salvalo nella tua cartella con il nome desiderato: menu-file-save.

2. Incomincia a scrivere il programma.

  1. Scrivi un'intestazione fatta da commenti che contenga le informazioni:
  • Data.
  • Nome.
  • Titolo del programma.

Esegui il programma in modo da controllare che non ci siano errori (<F5>).

3. Il programma vero e proprio è fatto da tre parti:

  • La lettura delle librerie.
  • Il programma principale.
  • L'attivazione della finestra grafica.

A questo punto il programma assomiglierà a:

# <data>

# <autore>

# Elementi di base della geometria

""" Problema: Disegna i quattro vertici di un quadrato. Disegna i quattro lati del quadrato. """

# lettura delle librerie

# programma principale

# attivazione della finestra grafica

4. Fin qui abbiamo scritto solo commenti, ora incominciamo a scrivere comandi:

  • Leggo la libreria Pyig e le do un nome più breve, “ig”:

import pyig

  • Il programma principale consiste, per ora, in una sola istruzione, creo un “InteractivePlane” della libreria “ig” e associo questo oggetto all'identificatore (=alla parola) “ip”:

ip = pyig.InteractivePlane()

  • Rendo attiva la finestra grafica:

ip.mainloop()

5. Aggiungi le istruzioni sotto ai commenti:

# <data>

# <autore>

# Elementi di base della geometria

""" Problema: Disegna i quattro vertici di un quadrato. Disegna i quattro lati del quadrato. """

# lettura delle librerie import pyig as ig

# programma principale ip = ig.InteractivePlane()

# attivazione della finestra grafica ip.mainloop()

6. Prova il programma premendo il tasto: <Ctrl-F5> o cliccando su menu-Run-Run module. Deve apparire una finestra grafica con un riferimento cartesiano e una griglia di punti. La finestra grafica è attiva, risponde al mouse e si può chiudere. Se non avviene questo, probabilmente è apparso un messaggio di errore in rosso nella shell di IDLE, leggi il messaggio, correggi l'errore e ritenta. Ora incominciamo ad aggiungere al programma principale le istruzioni per risolvere il problema. Incominciamo creando un punto. Aggiungiamo al programma principale il comando della libreria pyig che crea un punto associando l'oggetto appena creato all'identificatore “p_0”: p_0 = ig.Point(3, 4) È possibile trascinare con il mouse il punto nel suo piano: il punto non cambia cambiando la sua posizione. In geometria un punto non dovrebbe avere altre caratteristiche oltre la propria posizione, ma a noi fa comodo poter dare ai punti anche altre caratteristiche come: uno spessore, un colore, un'etichetta: p_0 = ig.Point(3, 4, color = 'red', width=6, name= 'A') In generale a tutti gli oggetti di pyig che possono essere visualizzati si possono assegnare le seguenti caratteristiche:

  • Colore: color=<una stringa di colore>.
  • Spessore: width=<un numero>.
  • Etichetta: name=<una stringa>.
  • Visibilità: visible=<True> o <False>.

La sintassi del costruttore dell'oggetto Point è: Point (<x> , <y> [, visible =True][, color ='green'][, width =3][, name='']) I primi due parametri, x e y, sono obbligatori, quelli messi tra parentesi quadre sono opzionali e, se non specificati, hanno il valore riportato sopra. Passiamo alla seconda richiesta del problema: disegnare una retta.Per poter tracciare una retta abbiamo bisogno di due punti infatti due punti individuano univocamente una retta (per due punti passa una e una sola retta). Possiamo utilizzare i due punti già disegnati e creare la retta passante per p_0 e p_1: s_0 = ig.Segment(p_0, p_1) Anche in questo caso possiamo modificare “colore” e “spessore” del segmento: s_0 = ig.Segment(p_0, p_1, color ='pink', width=6) # lati La sintassi del costruttore dell'oggetto Segment è: Segment(<punto_0>, <punto_1> [, visible =True][, color = 'blue'][, width =3][, name='']) È possibile trascinare con il mouse i punti base del segmento, ma il segmento continuerà a passare per quei due punti. Le sintassi dei costruttori di alcuni altri oggetti della geometria interattiva: Line(<punto_0>, <punto_1> [, visible =True][, color = 'blue'][, width =3][, name='']) Ray(<punto_0>, <punto_1> [, visible =True][, color = 'blue'][, width =3][, name='']) Circle(<centro>, <uunto> [, visible =True][, color = 'blue'][, width =3][, name='']) Ora crea tu una retta, una semiretta e una circonferenza.

Riassumendo

  • Per lavorare con la geometria interattiva dobbiamo far caricare a Python la relativa libreria ad esempio con il comando:

import pyig

  • Un programma è composto (per ora) dalle seguenti parti:

<intestazione>

<lettura delle librerie>

<programma principale>

<attivazione della finestra grafica>

  • La sintassi dei costruttori degli oggetti base della geometria è:

Point(<x> , <y> [, visible =True][, color ='green'][, width =3][, name='']) Line(<punto_0>, <punto_1> [, visible =True][, color = 'blue'][, width =3][, name='']) Ray(<punto_0>, <punto_1> [, visible =True][, color = 'blue'][, width =3][, name='']) Segment(<punto_0>, <punto_1> [, visible =True][, color = 'blue'][, width =3][, name='']) Circle(<centro>, <punto> [, visible =True][, color = 'blue'][, width =3][, name=''])

Intersezioni[modifica]

Come usare intersezioni tra oggetti.

Oltre a quelli visti nel capitolo precedente, per poter realizzare costruzioni geometriche abbiamo bisogno di poter creare l'intersezione tra due rette, tra una retta e una circondìferenza o tra due circonferenze.

Strumenti[modifica]

In questo capitolo utilizzeremo i seguenti strumenti di Pyig:

  • Point(x, y) crea un punto con date coordinate.
  • Line(p0, p1) crea una retta passante per p0 e p1.
  • Segment(p0, p1) crea un segmento di estremi p0 e p1.
  • Intersection(oggetto_0, oggetto_1, [which]) crea un punto di intersezione tra due oggetti.

Problema[modifica]

Crea un piano e inserisci:

  • Due rette nel terzo e quarto quadrante e il segmento che congiunge la loro intersezione con l'origine.
  • Una retta e una circonferenza nel secondo quadrante e i segmenti che congiungono le loro intersezioni con l'origine.
  • Due circonferenze nel primo quadrante e i segmenti che congiungono le loro intersezione con l'origine.

Soluzione guidata[modifica]

1. Crea un nuovo programma e salvarlo con il nome: gi02_intersezioni.py. Per creare un nuovo programma: vedi la soluzione guidata del capitolo precedente.

2. Scrivi un'intestazione adeguata.

3. Scrivi lo scheletro del programma:

  • La lettura delle librerie.
  • Il programma principale.
  • L'attivazione della finestra grafica.

e verifica che tutto funzioni.

4. Ora scriviamo dei commenti che indicano come intendiamo risolvere il problema:

# Creo le due rette

# Creo un punto nell'origine degli assi

# Creo l'intersezione tra le due rette

# Creo il segmento che congiunge l'origine all'intersezione

5. A questo punto il programma dovrebbe apparire circa così:

# <data>

# <nome>

# Intersezioni

# lettura delle librerie

import pyig as ig

# programma principale

ip = ig.InteractivePlane()

# Creo le due rette

# Creo un punto nell'origine degli assi

# Creo l'intersezione tra le due rette

# Creo il segmento che congiunge l'origine all'intersezione

# attivazione della finestra grafica

ip.mainloop()

6. Ora iniziamo a popolare di istruzioni il programma principale creando le due rette:

r_0 = ig.Line(ig.Point(-6, -4, width =6), ig.Point(2, -6, width =6))

r_1 = ig.Line(ig.Point(-11 , -9, width =6), ig.Point(-3, -8, width =6))

Eseguiamo il programma controllando che rispetti le specifiche.

7. Ora dobbiamo creare un segmento con un estremo nell'origine, quindi dobbiamo creare un punto nell'origine:

origine = ig.Point(0, 0, visible =False)

e siccome vogliamo che nessuno possa muoverlo, lo facciamo invisibile.

8. L'altro estremo è l'intersezione delle due rette:

i _ 0 = ig.Intersection(r_0, r_1, color ='red')

9. Infine creiamo il segmento:

s_0 = ig.Segment(origine, i_0, color ='#505010')

10. A questo punto il programma dovrebbe apparire circa così:

# <data>

# <nome>

# Intersezioni

# lettura delle librerie

import pyig as ig

# programma principale

ip = ig.InteractivePlane()

# Creo le due rette

r_0 = ig.Line(ig.Point(-6, -4, width =6), ig.Point(2, -6, width =6))

r_1 = ig.Line(ig.Point(-11, -9, width =6), ig.Point(-3, -8, width =6))

# Creo un punto nell'origine degli assi

origine = ig.Point(0, 0, visible =False)

# Creo l'intersezione tra le due rette

i_0 = ig.Intersection(r_0, r_1, color ='red')

# Creo il segmento che congiunge l'origine all'intersezione

s_0 = ig.Segment(origine, i_0, color ='#505010')

# attivazione della finestra grafica

ip.mainloop()

11. Proviamo il programma e controlliamo che rispetti le specifiche richieste dal problema. Cosa succede quando muovo i punti base di una retta?

12. Se tutto funziona regolarmente possiamo passare alla seconda parte del problema:

# Creo una retta

# Creo una circonferenza

# Creo le intersezioni tra la retta e la circonferenza

# Creo i segmenti

13. Per quanto riguarda i primi due punti non dovrebbero esserci problemi, per il terzo invece presenta una novità rispetto a quanto visto per l'intersezione di due rette, infatti una retta interseca una circonferenza in due punti (e non sempre) e noi dobbiamo indicare a Python quale delle due intersezioni vogliamo:

i_1 = ig.Intersection(r_2, c_0, -1, color ='red')

i_2 = ig.Intersection(r_2, c_0, +1, color ='red')

14. Dopo aver controllato che fin qui il programma funzioni, disegniamo i due segmenti. la seconda parte dovrebbe assomigliare a questa:

# Creo una retta

r_2 = ig.Line(ig.Point(-11, 9, width =6), ig.Point(-6, 1, width =6))

# Creo una circonferenza

c_0 = ig.Circle(ig.Point(-6, 7), ig.Point(-5, 2))

# Creo le intersezioni tra la retta e la circonferenza

i_1 = ig.Intersection(r_2, c_0, -1, color ='red')

i_2 = ig.Intersection(r_2, c_0, +1, color ='red')

# Creo i segmenti

s_1 = ig.Segment(origine, i_1, color ='#10a010')

s_2 = ig.Segment(origine, i_2, color ='#10a080')

15. Proviamo il programma e controlliamo che rispetti le specifiche richieste dal problema. Cosa succede quando muovo i punti base della retta?

16. Completiamo il programma per risolvere anche la terza parte del problema.

Riassumendo

  • pyig mette a disposizione un oggetto intersezione. L'intersezione tra rette non ha bisogno di ulteriori informazioni, quella tra una retta e una circonferenza o tra due circonferenze richiede un ulteriore argomento: con -1 si indica un'intersezione, con +1 si indica l'altra.

La sintassi del costruttore di un'intersezione è:

Intersection(oggetto_0, ogget to_1[,which] [,visible =True][,color ='blue'][, width=3][, name=''])

Costruzioni geometriche[modifica]

Come usare intersezioni tra oggetti.

Lo strumento base della geometria greca era lo spago:

  • Tenendo teso un pezzo di corda si poteva rappresentare un segmento allungabile a piacere.
  • Tenendo fisso un estremo e facendo ruotare l'altro, si poteva rappresentare una circonferenza.

Con questo strumento hanno costruito la geometria euclidea e risolto innumerevoli problemi.

Strumenti[modifica]

In questo capitolo utilizzeremo i seguenti strumenti di Pyig:

  • Point(x, y) crea un punto con date coordinate.
  • Line(p0, p1) crea una retta passante per p0 e p1.
  • Segment(p0, p1) crea un segmento di estremi p0 e p1.
  • Intersection(oggetto_0, oggetto_1, [which]) crea un punto di intersezione tra due oggetti.
  • Polygon((punto0, punto1, punto2, ...)) crea un poligono dati i vertici.

Problema[modifica]

Crea un piano e disegna:

  • Nel primo quadrante: due punti e il triangolo equilatero costruito su quei due punti.
  • Nel secondo quadrante: un segmento e l'asse di quel segmento.
  • Nel terzo quadrante: un angolo e la bisettrice di quell'angolo.
  • Nel quarto quadrante: due punti e il quadrato costruito su quei due punti.

Soluzione guidata[modifica]

1. Crea un nuovo programma e salvarlo con il nome: gi03_costruzioni.py. Per creare un nuovo programma: vedi la soluzione guidata del primo capitolo.

2. Scrivi un'intestazione adeguata.

3. Scrivi lo scheletro del programma.

4. Ora scriviamo dei commenti che indicano come intendiamo risolvere il problema:

# Disegno tre punti disposti accuratamente

# Disegno il poligono che passa per i tre punti

5. Risolviamo la prima parte del problema ottenendo un programma principale simile a questo:

# programma principale

ip = ig.InteractivePlane()

# Disegno tre punti disposti accuratamente

p_0 = ig.Point(1, 2, width=6)

p_1 = ig.Point(11, 2, width=6)

p_2 = ig.Point(6, 10.66, width=6)

# Disegno il poligono che passa per i tre punti

triequi = ig.Polygon((p_0, p_1, p_2),

width=5, color ='green', intcolor ='gold')

Osservate che il costruttore di Poligon vuole un primo argomento formato da una sequenza di punti per cui i vertici del poligono devono essere racchiusi tra parentesi.

6. Proviamo il programma e controlliamo che rispetti le specifiche richieste dal problema. Cosa succede quando muovo i punti base? Accidenti, il triangolo è equilatero all'inizio, ma non lo è più quando sposto uno dei punti base. Dobbiamo affrontare il problema in un altro modo. Il terzo vertice va costruito partendo dai primi due:

# Disegno due punti in una posizione qualunque

# Disegno le due circonferenze che hanno centro in un punto e

# passano per l'altro

# Trovo un'intersezione delle due circonferenze.

# Disegno il poligono che ha per vertici i due punti e l'intersezione

7. Dovremmo ottenere un programma che assomiglia a questo:

# programma principale

ip = ig.InteractivePlane()

# Disegno due punti in una posizione qualunque

p_0 = ig.Point(1, 2, width=6)

p_1 = ig.Point(11, 2, width=6)

# Disegno le due circonferenze che hanno centro in un punto e

# passano per l'altro

c_0 = ig.Circle(p_0, p_1, width=1)

c_1 = ig.Circle(p_1, p_0, width=1)

# Trovo un'intersezione delle due circonferenze

p_2 = ig.Intersection(c_0, c_1, +1, width=6)

# Disegno il poligono che ha per vertici i due punti e l'intersezione

triequi = ig.Polygon((p_0, p_1, p_2),

width=5, color ='green', intcolor ='gold')

Osservate che è buona norma tenere le linee di costruzione più sottili rispetto alle altre, o addirittura renderle invisibili visible=False. Si può osservare che questa volta i punti liberi sono solo due, il terzo vertice è vincolato alla posizione di questi due dalla nostra costruzione. Ora, se muoviamo i punti base il nostro triangolo cambia posizione e dimensioni, ma resta sempre un triangolo equilatero come era richiesto dal problema.

8. A questo punto cerca su un libro di disegno su internet come risolvere gli altri tre problemi. Risolvili con riga e compasso, poi con pyig. Di seguito riporto le tre tracce di soluzione.

9. Asse di un segmento:

# Disegno due punti

# Disegno il segmento

# Disegno le due circ. che hanno centro in un estremo e passano per l'altro

# Chiamo i_0 e i_1 le due intersezioni delle circonferenze

# L'asse e' la retta passante per i_0 e i_1

10. Bisettrice di un angolo:

# Disegno tre punti: p_0, vertice, p_1

# Disegno i due lati dell'angolo: r_0 e r_1

# Disegno una circ. che ha centro nel vertice e passa per p_0

# Chiamo i_1 l'intersezione della circonferenze con il lato r_1

# Disegno le circonferenze di centro p_0 e i_1 passanti per il vertice

# Chiamo i_2 l'intersezione delle due circonferenze

# La retta vertice -i_2 e' la bisettrice cercata

11. Quadrato dati due vertici consecutivi:

# Disegno due punti: p_0 , p_1

# c_0 e' la circ. che ha centro in p_0 e passa per p_1

# c_1 e' la circ. che ha centro in p_1 e passa per p_0

# i_0 e' l'intersezione di queste due circonferenze c_0 e c_1

# c_2 e' la circ. che ha centro in i _ 0 e passa per p_0

# i_1 e' l'intersezione delle circonferenze c_0 e c_2

# c_3 e' la circonferenza di centro i_1 passante per p_0

# i_2 e' l'intersezione delle circonferenze c_3 e c_2

# r_0 e' la retta passante per p_0 e i_2

# p_3 e' l'intersezione della retta r_0 con la circonferenza c_0

# c_4 e' la circonferenza di centro i_3 passante per p_0

# p_2 e' l'intersezione della circonferenza c_4 con la circonferenza c_1

# Il quadrato cercato e il poligono di vertici: (p_0, p_1, p_2, p_3)

Quando il programma e complicato, come in quest'ultimo caso è importante eseguire il programma ogni volta che si aggiunge un'istruzione in modo da individuare immediatamente eventuali errori sia sintattici sia logici.

12. Completiamo il programma per risolvere anche la terza parte del problema.

Riassumendo

  • Polygon permette di disegnare un poligono data una sequenza di punti. La sintassi del costruttore di Polygon è:

Polygon(sequenza di punti[, intcolor=white] [, visible =True][, color ='blue'][, width=3][, name=''])

  • Per affrontare problemi complicati: prima pianifica la soluzione descrivendola per mezzo di commenti, poi scrivi le istruzioni per risolvere il problema eseguendo il programma ad ogni modifica.
  • Nei libri d disegno, o in internet, si possono trovare molte costruzioni geometriche che si possono realizzare con rette, circonferenze e intersezioni.

Strumenti di uso comune[modifica]

Quali altri oggetti abbiamo a disposizione.

Nel paragrafo precedente abbiamo visto come realizzare oggetti nuovi come assi, bisettrici, triangoli, quadrati, ... Ma se ho bisogno di vari assi per realizzare una costruzione complessa, non è comodo per ognuno di questi ripetere tutta la costruzione. Alcuni oggetti di uso comune sono già prefabbricati e vengono messi a disposizione dalla libreria pyig, basta chiamarli. Nei prossimi paragrafi riporto quelli di uso più comune, l'elenco completo si trova nel manuale di Pygraph che è stato scaricato assieme alle librerie.

Lettura della libreria[modifica]

Nel seguito si dà per sottinteso che all'inizio del programma sia stata caricata la libreria con l'istruzione:

import pyig as ig

InteractivePlane[modifica]

InteractivePlane Crea il piano interattivo nel fare questa operazione si possono decidere alcune caratteristiche.

Sintassi

<nome_variabile> = InteractivePlane([<parametri>])

Osservazioni

Il costruttore presenta molti parametri tutti con un valore predefinito. Nel momento in cui si crea un piano cartesiano si possono quindi decidere le sue caratteristiche. Vediamole in dettaglio:

  • Titolo della finestra, valore predefinito: “Interactive geometry”.
  • Dimensione, valori predefiniti: larghezza=600, altezza=600.
  • Scala di rappresentazione, valori predefiniti: una unità = 20 pixel.
  • Posizione dell'origine, valore predefinito: il centro della finestra.
  • Rappresentazione degli assi cartesiani, valore predefinito: True.
  • Rappresentazione di una griglia di punti, valore predefinito: True.
  • Colore degli assi valore predefinito: ‘#808080' (grigio).
  • Colore della griglia valore predefinito: ‘#808080'.
  • Riferimento alla finestra che contiene il piano cartesiano, valore predefinito: None.

Poiché tutti i parametri hanno un valore predefinito, possiamo creare un oggetto della classe InteractivePlane senza specificare alcun argomento: verranno usati tutti i valori predefiniti. Oppure possiamo specificare per nome gli argomenti che vogliamo siano diversi dal comportamento predefinito, si vedano di seguito alcuni esempi.

Esempio

Si vedano tutti gli esempi seguenti.

Point[modifica]

Scopo

Crea un punto libero date le coordinate della sua posizione iniziale. Questo oggetto è la base di ogni costruzione; dai punti liberi dipendono, direttamente o indirettamente, gli altri oggetti grafici. Quando il puntatore del mouse si sovrappone ad un punto libero questo cambia colore. Trascinando un punto libero, con il mouse, tutti gli oggetti che dipendono da lui, verranno modificati. Point essendo un oggetto che può essere trascinato con il mouse ha un colore predefinito diverso da quello degli altri oggetti.

Sintassi

Point(x, y[, visible][, color][, width][, name])

Nota: Spesso nella pratica è necessario assegnare l'oggetto creato ad un identificatore in modo da poter fare riferimento ad un oggetto nella costruzione di altri oggetti:

<identificatore> = Point(x, y[, visible][, color][, width][, name])

Si vedano gli esempi seguenti.

Osservazioni

  • x e y sono due numeri, x è l'ascissa e y l'ordinata del punto.
  • Per quanto riguarda i parametri non obbligatori si veda quanto scritto nel paragrafo relativo agli attributi degli oggetti visibili.

Nota: Nel resto del manuale riporterò solo gli argomenti obbligatori, è sottinteso che tutti gli oggetti che possono essere visualizzati hanno anche i parametri: visible, color, width, name.

Esempio

Funzione definita in N ad andamento casuale.

import random

ip = ig.InteractivePlane('Point')

y = 0

for x in range (-14, 14):

y += random. randrange (-1 , 2)

ig.Point(x, y, color ='red')

Attributi degli oggetti geometrici[modifica]

Scopo

Point, come tutti gli oggetti geometrici ha degli attributi che possono essere determinati nel momento della creazione dell'oggetto stesso o in seguito. Questi attributi definiscono alcune caratteristiche degli oggetti che possono essere visualizzati.

  • visible stabilisce se l'oggetto sarà visibili o invisibile.
  • color imposta il colore dell'oggetto.
  • width imposta la larghezza dell'oggetto.
  • name imposta il nome dell'oggetto.

Sintassi

<oggetto>.visible = v

<oggetto>.color = c

<oggetto>.width = w

<oggetto>.name = s

Osservazioni

  • v è un valore booleano, può essere True o False.
  • w è un numero che indica la larghezza in pixel.
  • c può essere:
    • Una stringa nel formato: “#rrggbb” dove rr, gg e bb sono numeri esadecimali di due cifre che rappresentano rispettivamente le componenti rossa, verde, e blu del colore.
    • Una stringa contenente il nome di un colore.
    • Una terna di numeri nell'intervallo 0-1 rappresentanti le componenti rossa verde e blu.
  • s è una stringa.

Esempio

Disegna tre punti: uno con i valori di default, uno con colore dimensione e nome definiti quando viene creato, uno con valori cambiati dopo essere stato creato.

ip = ig.InteractivePlane('attributi')

a = ig.Point(-5, 3)

b = ig.Point(2, 3, color ='indian red', width=8, name='B')

c = ig.Point(9, 3)

c.color ='dark orange'

c.width = 8

c.name = 'C'

Metodi degli oggetti geometrici[modifica]

Scopo

Tutti gli oggetti geometrici hanno anche dei metodi che danno come risultato alcune informazioni relative all'oggetto stesso.

  • xcoord l'ascissa.
  • ycoord l'ordinata.
  • coords le coordinate.

Sintassi

<oggetto>.xcoord()

<oggetto>.ycoord()

<oggetto>.coords()

Osservazioni

Non richiedono argomenti e restituiscono un particolare oggetto che può essere utilizzato all'interno di un testo variabile.

Esempio

Scrivi ascissa, ordinata e posizione di un punto.

ip = ig.InteractivePlane('coords, xcoord, ycoord')

a = ig.Point(-5, 8, name='A')

ig.VarText(-5, -1, 'ascissa di A: {0}', a.xcoord())

ig.VarText (-5, -2, 'ordinata di A: {0}', a.ycoord())

ig.VarText (-5, -3, 'posizione di A: {0}', a.coords())

Segment[modifica]

Scopo

Crea un segmento dati i due estremi, i due estremi sono punti.

Sintassi

<identificatore> = Segment(point0, point1)

Osservazioni

point0 e point1 sono due punti.

Esempio

Disegna un triangolo con i lati colorati in modo differente.

ip = ig.InteractivePlane('Segment')

# creo i 3 vertici

v0 = ig.Point(-4, -3, width=5)

v1 = ig.Point(5, -1, width=5)

v2 = ig.Point(2, 6, width=5)

# creo i 3 lati

l0 = ig.Segment(v0, v1, color ='steel blue')

l1 = ig.Segment(v1, v2, color ='sea green')

l2 = ig.Segment(v2, v0, color ='saddle brown')

length[modifica]

Scopo

È il metodo della classe Segment che restituisce un oggetto data contenente la lunghezza del segmento stesso.

Sintassi

<obj>.length()

Osservazioni

La lunghezza è la distanza tra point0 e point1.

Esempio

Disegna un segmento e scrivi la sua lunghezza.

ip = ig.InteractivePlane('length')

p0 = ig.Point(-4, 7, width=5, name='A')

p1 = ig.Point(8, 10, width=5, name='B')

seg = ig.Segment(p0, p1)

ig.VarText(-5, -5, 'lunghezza di AB = {0}', seg.length())

MidPoints[modifica]

Scopo

Crea il punto medio tra due punti.

Sintassi

MidPoints(point0, point1)

Osservazioni

point0 e point1 sono due punti.

Esempio

Punto medio tra due punti.

ip = ig.InteractivePlane('MidPoints')

# creo due punti

p0 = ig.Point(-2, -5)

p1 = ig.Point(4, 7)

# cambio i loro attributi

p0.color = "#00a600"

p0.width = 5

p1.color = "#006a00"

p1.width = 5

# creao il punto medio tra p0 e p1

m = ig.MidPoints(p0, p1, name='M')

# cambio gli attributi di m

m.color = "#f0f000"

m.width = 10

MidPoint[modifica]

Scopo

Crea il punto medio di un segmento.

Sintassi

MidPoint(segment)

Osservazioni

segment è un oggetto che ha un point0 e un point1.

Esempio

Punto medio di un segmento.

ip = ig.InteractivePlane('MidPoint')

# creo un segmento

s = ig.Segment(ig.Point(-2, -1, color ="#a60000", width =5),

ig.Point(5, 7, color ="#6a0000", width =5),

color ="#a0a0a0")

# creo il suo punto medio

ig.MidPoint(s, color ="#6f6f00", width=10, name='M')

Line[modifica]

Scopo

Crea una retta per due punti.

Sintassi

Line(point0, point1)

Osservazioni

point0 e point1 sono, indovina un po', due punti.

Vedi anche i metodi delle classi linea presentati nella classe Segment.

Esempio

Triangolo delimitato da rette.

ip = ig.InteractivePlane('Line')

# creo i 3 punti

a = ig.Point(0, 0)

b = ig.Point(1, 5)

c = ig.Point(5, 1)

# creo i 3 lati

ig.Line(a, b, color ="#dead34")

ig.Line(b, c, color ="#dead34")

ig.Line(c, a, color ="#dead34")

Ray[modifica]

Scopo

Traccia una semiretta con l'origine in un punto e passante per un altro punto.

Sintassi

Ray(point0, point1)

Osservazioni

point0 è l'origine della semiretta che passa per point1.

Vedi anche i metodi delle classi linea presentati nella classe Segment.

Esempio

Triangolo delimitato da semirette.

ip = ig.InteractivePlane('Ray')

# creo i 3 punti

a = ig.Point(0, 0)

b = ig.Point(1, 5)

c = ig.Point(5, 1)

# creo i 3 lati

ig.Ray(a, b, color ="#de34ad")

ig.Ray(b, c, color ="#de34ad")

ig.Ray(c, a, color ="#de34ad")

Orthogonal[modifica]

Scopo

Crea la retta perpendicolare ad una retta data passante per un punto.

Sintassi

Orthogonal(line, point)

Osservazioni

line è la retta alla quale si costruisce la perpendicolare passante per point.

Vedi anche i metodi delle classi linea presentati nella classe Segment.

Esempio

Disegna la perpendicolare ad una retta data passante per un punto.

ip = ig.InteractivePlane('Orthogonal')

retta = ig.Line(ig.Point(-4, -1, width =5),

ig.Point(6, 2, width =5),

width=3, color ='DarkOrange1', name='r')

punto = ig.Point(-3, 5, width=5, name='P')

ig.Orthogonal(retta, punto)

Parallel[modifica]

Scopo

Crea la retta parallela ad una retta data passante per un punto.

Sintassi

Parallel(line, point)

Osservazioni

line è la retta alla quale si costruisce la parallela passante per point.

Vedi anche i metodi delle classi linea presentati nella classe Segment.

Esempio

Disegna la parallela ad una retta data passante per un punto.

ip = ig.InteractivePlane('Parallel')

retta = ig.Line(ig.Point(-4, -1, width =5),

ig.Point(6, 2, width =5),

width=3, color ='DarkOrange1', name='r')

punto = ig.Point(-3, 5, width=5, name='P')

ig.Parallel(retta, punto)

Polygon[modifica]

Scopo

Crea un poligono data una sequenza di vertici.

Sintassi

Polygon(points)

Osservazioni

points è una sequenza di punti, può essere una lista (delimitata da parentesi quadre) o una tupla (delimitata da parentesi tonde).

Esempio

Disegna un poligono date le coordinate dei vertici.

ip = ig.InteractivePlane('24: Polygon')

# Lista di coordinate

coords = ((-8, -3), (-6, -2), (-5, -2), (-4, 2), (-2, 3), (0, 4),

(2, 3), (4, 2), (5, -2), (6, -2), (8, -3))

# Costruzione di una lista di punti partendo da una lista di coordinate :

# listcompreension

ip.defwidth = 5

points = [ig.Point(x, y) for x , y in coords]

ig.Polygon(points, color = 'HotPink3')

perimeter e surface[modifica]

Scopo

Sono metodi presenti in tutte le classi figura, restituiscono la lunghezza del contorno e l'area della superficie dell'oggetto.

Sintassi

<figura>.perimeter()

<figura>.surface()

Osservazioni

Sono metodi degli oggetti che sono figure piane e non richiede argomenti.

Esempio

Scrive alcune informazioni relative a un poligono.

poli = ig.Polygon((ig.Point(-7, -3, width=5, name="A"),

ig.Point(5, -5, width=5, name="B"),

ig.Point(-3, 8, width=5, name="C")),

width=4, color ='magenta', intcolor ='olive drab')

ig.VarText(-3, -6, "perimetro ={0}", poli.perimeter(), color ='magenta')

ig.VarText(-3, -7, "area ={0}", poli.surface(), color ='olive drab')

Circle[modifica]

Scopo

Circonferenza dato il centro e un punto o il centro e il raggio (un segmento).

Sintassi

Circle(center, point)

Circle(center, segment)

Osservazioni

center è il centro della circonferenza passante per point o di raggio segment.

Vedi anche i metodi delle classi figure piane presentati nella classe Polygon.

Esempio

Circonferenze con centro nell'origine.

ip = ig.InteractivePlane('Circle(Point, Point)')

origine = ig.Point(0, 0, visible =False, name="O")

p0 = ig.Point(-7, -3, width=5, name="P")

ig.Circle(origine, p0, color ="#c0c0de", width=4)

raggio = ig.Segment(ig.Point(-7, 9, width=5, name="A"),

ig.Point(-4, 9, width=5, name="B"))

ig.Circle(origine, raggio, color ="#c0c0de", width=4)

Intersection[modifica]

Scopo

Crea il punto di intersezione tra due oggetti.

Sintassi

Intersection(obj0, obj1)

Intersection(obj0, obj1, which)

Osservazioni obj0 e obj1 possono essere rette o circonferenze. Se uno dei due oggetti è una circonferenza è necessario specificare quale delle due intersezioni verrà restituita indicando come terzo parametro +1 o -1.

Esempio

Disegna una circonferenza tangente a una retta.

ip = ig.InteractivePlane('Intersectionlineline')

# Disegno retta e punto

retta = ig.Line(ig.Point(-4, -1, width =5),

ig.Point(6, 2, width =5),

width=3, color ='DarkOrange1', name='r')

punto = ig.Point(-3, 5, width=5, name='P')

# trovo il punto di tangenza

perpendicolare = ig.Orthogonal(retta, punto, width=1)

p_tang = ig.Intersection(retta, perpendicolare, width=5)

# disegno la circonferenza

ig . Ci r c l e ( punto , p_tang , width=4 , color = ' IndianRed ' )

Disegna il simmetrico di un punto rispetto ad una retta.

ip = ig.InteractivePlane('Intersectionlinecircle')

# disegno l'asse di simmetria e il punto

asse = ig.Line(ig.Point(-4, -11, width =5),

ig.Point(-2, 12, width =5),

width=3, color ='DarkOrange1', name='r')

punto = Point(-7, 3, width=5, name='P')

# disegno la perpendi colare all'asse passante per il punto

perp = ig.Orthogonal(asse, punto, width=1)

# trovo l'intersezione tra la perpendicolare e l'asse

piede = ig.Intersection(perp, asse)

# disegno la circonferenza di centro piede e passante per punto

circ = ig.Circle(piede, punto, width=1)

# trovo il simmetrico di punto rispetto a asse

ig.Intersection(perp, circ, -1, width=5, color ='DebianRed', name="P'")

Disegna un triangolo equilatero.

ip = ig.InteractivePlane('Intersection circle circle')

# Disegno i due primi vertici

v0 = ig.Point(-2, -1, width=5, name='A')

v1 = ig.Point(3, 2, width=5, name='B')

# Disegno le due circonferenze di centro p0 e p1 e passanti per p1 e p0

c0 = ig.Circle(v0, v1, width=1)

c1 = ig.Circle(v1, v0, width=1)

# terzo vertice: intersezione delle due circonferenze

v2 = ig.Intersection(c0, c1, 1, width=5, name='C')

# triangolo per i 3 punti

ig.Polygon((v0, v1, v2), width=4, color ='DarkSeaGreen4')

Text[modifica]

Scopo

Crea un testo posizionato in un punto del piano.

Sintassi

Text(x, y, text[, iplane=None])

Osservazioni

  • x e y sono due numeri interi o razionali relativi; x è l'ascissa e y l'ordinata del punto.
  • text è la stringa che verrà visualizzata.
  • Se sono presenti più piani interattivi, si può specificare l'argomento iplane per indicare in quale di questi la scritta deve essere visualizzata.

Esempio

Scrive un titolo in due finestre grafiche.

ip0 = ig.InteractivePlane('Text pale green', w=400, h=200)

ip1 = ig.InteractivePlane('Text blue violet', w=400, h=200)

ig.Text(-2, 2, "Prove di testo blue violet",

color = 'blue violet', width =20)

ig.Text(-2, 2, "Prove di testo pale green",

color = 'pale green', width=20, iplane=ip0)

VarText[modifica]

Scopo

Crea un testo variabile. Il testo contiene dei “segnaposto” che verranno sostituiti con i valori prodotti dai dati presenti nel parametro variables.

Sintassi

VarText(x, y, text, variables[, iplane=None])

Osservazioni

  • x e y sono due numeri interi o razionali relativi x è l'ascissa e y l'ordinata del punto.
  • text è la stringa che contiene la parte costante e i segnaposto.
  • In genere i segnaposto saranno nella forma: “{0}” che indica a Python di convertire in stringa il risultato prodotto dal dato.
  • variables è un dato o una tupla di dati.
  • Se sono presenti più piani interattivi, si può specificare l'argomento iplane per indicare in quale di questi la scritta deve essere visualizzata.

Esempio

Un testo che riporta la posizione dei un punto.

ip = ig.InteractivePlane('VarText')

p0 = ig.Point(7, 3, color ='green', width=10, name='A')

ig.VarText(-4, -3, "Posizione del punto A: ({0}; {1})",

(p0.xcoord(), p0.ycoord()),

color ='green', width =10)

PointOn[modifica]

Scopo Punto disegnato su un oggetto in una posizione fissa. Sintassi

PointOn(obj, parameter)

Osservazioni

L'oggetto deve essere una linea o una retta o una circonferenza, parameter è un numero che individua una precisa posizione sull'oggetto. Sia le rette sia le circonferenze hanno una loro metrica che è legata ai punti base dell'oggetto. Su una retta una semiretta o un segmento point0 corrisponde al parametro 0 mentre point1 corrisponde al parametro 1. Nelle circoferenze il punto di base della circonferenza stessa corrisponde al parametro 0 l'intera circonferenza vale 2. Il punto creato con PointOn non può essere trascinato con il mouse.

Esempio

Disegna il simmetrico di un punto rispetto ad una retta.

ip = ig.InteractivePlane('PointOn')

# disegno l'asse di simmetria e il punto

asse = ig.Line(ig.Point(-4, -11, width =5),

ig.Point(-2, 12, width =5),

width=3, color ='DarkOrange1', name='r')

punto = ig.Point(-7, 3, width=5, name='P')

# disegno la perpendicolare all'asse passante per il punto

perp = ig.Orthogonal(asse, punto, width=1)

# trovo il simmetrico di punto rispetto a asse

ig.PointOn(perp, -1, width=5, color ='DebianRed', name="P'")

ig.Text(-5, -6, """P' e'il simmetrico di P.""")

ConstrainedPoint[modifica]

Scopo

Punto legato ad un oggetto.

Sintassi

ConstrainedPoint(obj, parameter)

Osservazioni

Per quanto riguarda parameter, valgono le osservazioni fatte per PoinOn. Questo puntoperò può essere trascinato con il mouse pur restando sempre sull'oggetto. Dato che può essere trascinato con il mouse ha un colore di default diverso da quello degli altri oggetti.

Esempio

Circonferenza e proiezioni sugli assi.

ip = ig.InteractivePlane('ConstrainedPoint', sx =200)

# Circonferenza

origine = ig.Point(0, 0, visible =False)

unix = ig.Point(1, 0, visible =False)

uniy = ig.Point(0, 1, visible =False)

circ = ig.Circle(origine, unix, color ="gray10")

# Punto sulla circonferenza

cursore = ig.ConstrainedPoint(circ, 0.25, color ='magenta', width=20)

# assi

assex = Line(origine, unix, visible =False)

assey = Line(origine, uniy, visible =False)

# proiezioni

py = ig.Parallel(assey, cursore, visible =False)

hx = ig.Intersection(assex, py, color ='red', width=8)

px = ig.Parallel(assex, cursore, visible =False)

hy = ig.Intersection(assey, px, color ='blue', width=8)

parameter[modifica]

Scopo

I punti legati agli oggetti hanno un metodo che permette di ottenere il parametro.

Sintassi

<constrained point>.parameter()

Osservazioni

In PointOn il parametro è fissato nel momento della costruzione dell'oggetto. In ConstrainedPoint il parametro può essere variato trascinando il punto con il mouse.

Esempio

Scrivi i dati relativi a un punto collegato a un oggetto.

ip = ig.InteractivePlane('parameter')

c0 = ig.Circle(ig.Point(-6, 6, width =6), ig.Point(-1, 5, width =6))

c1 = ig.Circle(ig.Point(6, 6, width =6), ig.Point(1, 5, width =6 ))

a = ig.PointOn(c0, 0.5, name='A')

b = ig.ConstrainedPoint(c1, 0.5, name='B')

ig.VarText(-5, -1, 'ascissa di A: {0}', a.xcoord())

ig.VarText(-5, -2, 'ordinata di A: {0}', a.ycoord())

ig.VarText(-5, -3, 'posizione di A: {0}', a.coords())

ig.VarText(-5, -4, 'parametro di A: {0}', a.parameter())

ig.VarText(5, -1, 'ascissa di B: {0}', b.xcoord())

ig.VarText(5, -2, 'ordinata di B: {0}', b.ycoord())

ig.VarText(5, -3, 'posizione di B: {0}', b.coords())

ig.VarText(5, -4, 'parametro di B: {0}', b.parameter())

Angle[modifica]

Scopo

Angolo dati tre punti o due punti e un altro angolo. Il secondo punto rappresenta il vertice.

Il verso di costruzione dell'angolo è quello antiorario.

Sintassi

Angle(point0, vertex, point1[, sides])

Angle(point0, vertex, angle[, sides])

Osservazioni

L'argomento sides può valere:

  • True(o(0, 1)): vengono disegnati i lati.
  • 0: viene disegnato il lato 0.
  • 1: viene disegnato il lato 1.

Angle fornisce i seguenti metodi dal significato piuttosto evidente:

  • extent: ampiezza dell'angolo.
  • bisector: bisettrice.

Esempio

Disegna un angolo e un angolo con i lati.

ip = ig.InteractivePlane('Angle(Point, Point, Point)')

ip.defwidth = 5

a = ig.Point(-2, 4, color ="#40c040", name="A")

b = ig.Point(-5, -2, color ="#40c040", name="B")

c = ig.Point(-8, 6, color ="#40c040", name="C")

d = ig.Point(8, 6, color ="#40c040", name="D")

e = ig.Point(5, -2, color ="#40c040", name="E")

f = ig.Point(2, 4, color ="#40c040", name="F")

# angolo senza i lati

ig.Angle(a, b, c, color ="#40c040")

# angolo con i lati

ig.Angle(d, e, f, color ="#c04040", sides=True)

Somma di due angoli.

ip = ig.InteractivePlane('Angle(Point, Point, Angle)')

# i 2 angoli di partenza

a = ig.Angle(ig.Point(-3, 7, width =6),

ig.Point(-7, 5, width =6),

ig.Point(-6, 8, width =6),

sides =(0,1), color ="#f09000", name='alfa')

b = ig.Angle(ig.Point(9, 2, width =6),

ig.Point(2, 3, width =6),

ig.Point(6, 4, width =6),

sides =(0, 1), color ="#0090f0", name='beta')

# Punti di base dell'angolo somma di a b

v = ig.Point(-11, -8, width=6)

p0 = ig.Point(3, -10, width=6)

# la somma degli angoli

b1 = ig.Angle(p0, v, b, (0,1), color ="#0090f0")

p1 = b1.point1()

a1 = ig.Angle(p1, v, a, sides=True, color ="#f09000")

ig.Text(-4, -12, "Somma di due angoli")

Bisector[modifica]

Scopo

Retta bisettrice di un angolo.

Sintassi

<Bisector>(<angle>)

Osservazioni

Vedi Ray.

Esempio

Disegna l'incentro di un triangolo.

ip = ig.InteractivePlane('Bisector')

# I tre vertici del triangolo

a = ig.Point(-7, -3, color ="#40c040", width=5, name="A")

b = ig.Point( 5, -5, color ="#40c040", width=5, name="B")

c = ig.Point(-3, 8, color ="#40c040" , width=5, name="C")

# Il triangolo

ig.Polygon((a, b, c))

# Due angoli del triangolo

cba = ig.Angle(c, b, a)

bac = ig.Angle(b, a, c)

# Le bisettrici dei due angoli

b1 = ig.Bisector(cba, color ="#a0c040")

b2 = ig.Bisector(bac, color ="#a0c040")

# L'incentro

ig.Intersection(b1, b2, color ="#c040c0", width=5, name="I")

Calc[modifica]

Scopo

Dato che contiene il risultato di un calcolo.

Sintassi

Calc(function, variables)

Osservazioni

  • function è una funzione python, al momento del calcolo, alla funzione vengono passati come argomenti il contenuto di variables.
  • variables è un oggetto Data o una tupla che contiene oggetti Data. Il risultato è memorizzato all'interno dell'oggetto Calc e può essere visualizzato con VarText o utilizzato per definire la posizione di un punto.

Esempio

Calcola il quadrato di un lato e la somma dei quadrati degli altri due di un triangolo.

ip = ig.InteractivePlane('Calc')

ig.Circle(ig.Point(2, 4), ig.Point(-3, 4), width=1)

ip.defwidth = 5

a = ig.Point(-3, 4, name="A")

b = ig.Point(7, 4, name="B")

c = ig.Point(-1, 8, name="C")

ab = ig.Segment(a, b, color ="#40c040")

bc = ig.Segment(b, c, color ="#c04040")

ca = ig.Segment(c, a, color ="#c04040")

q1 = ig.Calc(lambda a: a*a, ab.length())

q2 = ig.Calc(lambda a, b: a*a+b*b, (bc.length(), ca.length()))

ig.VarText(-5, -5, "ab^2 = {0}", q1, color ="#40c040")

ig.VarText(-5, -6, bc^2 + ca^2 = {0}", q2, color ="#c04040")

Riassumendo

  • In questo paragrafo sono stati presentati i seguenti oggetti.
    • Angle Angolo dati tre punti o due punti e un angolo, il secondo punto rappresenta il vertice. Il verso di costruzione dell'angolo è quello antiorario.
    • Bisector Retta bisettrice di un angolo.
    • Circle Circonferenza dato il centro e un punto o il centro e un raggio (un segmento).
    • ConstrainedPoint Punto legato ad un oggetto.
    • Calc Dato che contiene il risultato di un calcolo.
    • InteractivePlane Crea il piano cartesiano e inizializza gli attributi del piano.
    • Intersection Crea il punto di intersezione tra due rette.
    • Line Crea una retta per due punti.
    • MidPoint Crea il punto medio di un segmento
    • MidPoints Crea il punto medio tra due punti.
    • Orthogonal Crea la retta perpendicolare ad una retta data passante per un punto.
    • Parallel Crea la retta parallela ad una retta data passante per un punto.
    • Point Crea un punto libero date le coordinate della sua posizione iniziale.
    • PointOn Punto disegnato su un oggetto in una posizione fissa.
    • Polygon Crea un poligono data una sequenza di vertici.
    • Ray Traccia una semiretta con l'origine in un punto e passante per un altro punto.
    • Segment Crea un segmento dati i due estremi, i due estremi sono punti.
    • Text Crea un testo posizionato in un punto del piano.
    • VarText Crea un testo variabile. Il testo contiene dei “segnaposto” che verranno sostituiti con i valori prodotti dai dati presenti nel parametro variables.
  • In questo paragrafo sono stati presentati i seguenti attributi.
    • <oggetto_visibile>.color Attributo degli oggetti geometrici: imposta il colore dell'oggetto;
    • <oggetto_visibile>.name Attributo degli oggetti geometrici: imposta il nome dell'oggetto.
    • <oggetto_visibile>.visible Attributo degli oggetti geometrici: stabilisce se l'oggetto sarà visibili o invisibile;
    • <oggetto_visibile>.width Attributi degli oggetti geometrici: imposta la larghezza dell'oggetto.
  • In questo paragrafo sono stati presentati i seguenti metodi.
    • <circonferenza>.radius Metodo delle classi circonferenza che restituisce un oggetto data che contiene la lunghezza del raggio della circonferenza.
    • <figura>.perimeter Metodo delle classi figura che restituisce un oggetto data contenente la lunghezza del contorno dell'oggetto.
    • <figura>.surface Metodo delle classi figura che restituisce un oggetto data contenente l'area della superficie dell'oggetto.
    • <oggetto_visibile>.coords Restituisce un dato che contiene le coordinate.
    • <oggetto_visibile>.xcoord Metodo degli oggetti visualizzabili: restituisce un dato che contiene l'ascissa.
    • <oggetto_visibile>.ycoord Metodo degli oggetti visualizzabili: restituisce un dato che contiene l'ordinata.
    • <punto_legato>.parameter Metodo dei punti legati agli oggetti che restituisce un oggetto data contenente il parametro.
    • <segmento>.length Metodo della classe Segment che restituisce un oggetto data contenente la lunghezza del segmento stesso.