38
1
1
2
LLOOWWEERR SSEECCOONNDDAARRYY SSCCHHOOOOLLSS
SSccuuoollaa SSeeccoonnddaarriiaa ddii II GGrraaddoo SSttaattaallee ““SSaanntt’’AAnnddrreeaa””
SSaanntt’’AAnnddrreeaa AAppoossttoolloo ddeelllloo JJoonniioo ((CCZZ))
DDiirriiggeennttee SSccoollaassttiiccoo: Domenico A. Servello
DDoocceennttee ssppeerriimmeennttaattoorree: Adriana Ramogida
AAlluunnnnii: Vanessa Procopio, Maria Clelia Varano CCllaassssee IIIIII AA
PPrrooggrraammmmaa:: “Orsetto”
Gli studenti sono stati invitati a realizzare un oggetto legato al loro vissuto quotidiano, utilizzando l’ambiente di programmazione MatCos. Nasce, così, il programma “Orsetto”, figura tenera legata alla sfera affettiva dell’età evolutiva dei giovanissimi studenti. Tra i concetti fondamentali che figurano nel programma, si segnalano quello di circonferenza e di cerchio per la Matematica e quello di ciclo per l’Informatica. A=punto; ColorePenna(128,0,0); ColoreRiempimento (128,64,0); circ(A,30); ColorePenna(128,0,0); ColoreRiempimento (128,64,0); B=punto; circ(B,30); ColorePenna(128,0,0); ColoreRiempimento (128,64,0); C=punto; circ(C,50); ColorePenna(128,0,0); ColoreRiempimento (128,64,0); L=punto; circ(L,70); S=punto; circ(S,20); T=punto; circ(T,20); ColorePenna(128,0,0); ColoreRiempimento (106,0,0);
D=punto; circ(D,20); ColorePenna(128,0,0); ColoreRiempimento (106,0,0); N=punto; circ(N,20); K=punto; ColoreRiempimento(0,0,0); circ(K,10); J=punto; ColoreRiempimento(0,0,0); circ(J,10); Y=punto; ColoreRiempimento(0,0,0); circ(Y,10); X=punto; ColoreRiempimento (106,0,0); n=legginum; r=15; per(i da 1 a n)esegui; circ(X,r); r=r+5; fine; W=punto; ColoreRiempimento (106,0,0);
p=legginum; r=15; per(i da 1 a p); circ(W,r); r=r+5; fine; B=punto; ColoreRiempimento (106,0,0); n=legginum; r=7; per(i da 1 a n)esegui; Circ(b,r); r=r+5; fine; G=punto; ColoreRiempimento (106,0,0); n=legginum; r=7; per(i da 1 a n); circ(G,r); r=r+5; fine; cancella(K,Y,J,X,W,B,G);
L’uso di MatCos mi ha offerto l’opportunità di introdurre in modo sistematico, nella pratica dell’insegnamento, il computer, che si è rivelato un valido supporto nell’apprendimento della matematica; ma, il punto di forza del software MatCos sta nell’avviare i ragazzi alla pratica della programmazione con naturalezza,
3
attraverso un linguaggio alla portata delle loro capacità intellettive. Questa nuova metodologia didattica, ha stimolato gli allievi a formulare e verificare congetture logiche e consequenziali, ha consentito un insegnamento più efficace producendo un apprendimento più consapevole nel consolidamento delle strutture matematiche.
4
IIssttiittuuttoo CCoommpprreennssiivvoo ““VViivvaarriieennssee”” -- SSqquuiillllaaccee --
SSccuuoollaa MMeeddiiaa SSqquuiillllaaccee LLiiddoo ((CCZZ))
DDiirriiggeennttee SSccoollaassttiiccoo:: Rosario Tavano
DDoocceennttee ssppeerriimmeennttaattoorree:: Maria Antonia Procopio
AAlluunnnnii:: Mattia Mazza, Alberto Muccari CCllaassssee IIII BB
PPrrooggrraammmmaa:: “Semaforo”
Il programma nasce dall’idea di progettare e costruire gli oggetti della realtà che ci circonda. I concetti matematici utilizzati sono di tipo geometrico: punto, poligono, circonferenza. Per l’implementazione dell’algoritmo in MatCos sono state utilizzate semplici istruzioni generiche oltre ad istruzioni di natura geometrica. Si tratta di un listato molto semplice che fa capire come è possibile costruire oggetti significativi con poche e semplici istruzioni.
L’ambiente di programmazione MatCos mi ha permesso di lavorare sulle tematiche della matematica in modo nuovo e più attraente grazie ad un linguaggio di programmazione semplice, di facile interpretazione ed efficace nella costruzione dei percorsi didattici classici della matematica. E’ un ambiente di programmazione dove lo studente, con un linguaggio accessibile, percorre linee logiche di pensiero, progettando la risoluzione delle situazioni problematiche che si presentano con il rigore logico del metodo scientifico. In definitiva, MatCos consente un insegnamento più fruibile ed efficace, quindi un apprendimento immediato e consapevole.
Sccuuoollaa MMeeddiiaa SSttaattaallee ““AA.. MMoorroo”” MMaarraannoo MMaarrcchheessaattoo ((CCSS))
DDiirriiggeennttee SSccoollaassttiiccoo: Maurizio Corrado Baldino
DDoocceennttee ssppeerriimmeennttaattoorree: Matilde Vaccaro
AAlluunnnnii: Antonio Ritacca, Alessio Zicarelli CCllaassssee IIII CC
PPrrooggrraammmmaa:: “Il mio primo giocattolo: la macchina”
Per la realizzazione del programma, sono state utilizzate sia istruzioni di geometria sia istruzioni generiche. Quest’ultime hanno consentito, in una sorta di gioco divertente e reale, di perfezionare la veste grafica del disegno. Ad esempio, l’uso del “coloreriempimento” è servito ad evidenziare la gomma e il cerchione della ruota anteriore. Il comando “ Trasla” ha consentito la traslazione della ruota costruita, ottenendo, così, la ruota posteriore. La carrozzeria, invece, è stata
stampa("semaforo con poligono"); A=punto; B=punto; C=punto; D=punto; ColorePenna(0,0,0); SpessorePenna(3); poligono(A,B,C,D); s=segmento(C,D); E=punto_su(s); F=punto_su(s); G=punto; H=punto; poligono(E,F,G,H); cancella(A,B,C,D,E,F,G,H); L=punto; r=20; ColoreRiempimento(255,0,0); C=CIRC(L,r); ColoreRiempimento(255,255,0); L1=punto; c1=circ(L1,r); L2=punto; oloreRiempimento(0,128,0); c2=circ(L2,r);
5
realizzata in maniera consequenziale e logica, mediante il disegno dei vari diversi poligoni: trapezio scaleno, triangoli rettangoli rettangolo. La maniglia della portiera è stata delineata con il comando “Segmento (Punto,Punto)”.
Coloresfondo (192,192,192); X=punto; L=Punto; Spessorepenna (4); I=legginum ("inserire raggio 1° circ"); Coloreriempimento (255,255,255); I1=Legginum ("inserire raggio 2° circ"); Poligono (F,X,E); ColoreRiempimento(0,0,0); P=Punto; V=Circ (L,I); Y=Punto; ColoreRiempimento(128,128,128); T=Punto; V1=Circ(L,I1); Coloreriempimento (255,255,0); n=Segmento_or (L,Punto); Poligono (P,Y,T); ColoreRiempimento(0,0,0); Z=Punto; Trasla(V,N) ; K=Punto; ColoreRiempimento(128,128,128);
S=Punto; Trasla(V1,N); Coloreriempimento (255,255,0); A=Punto; Poligono (Z,K,S); B=Punto; Coloreriempimento (255,255,255); C=Punto; Spessorepenna (4); D=Punto; Poligono (Punto, Punto, Punto, Punto); E=Punto; Coloreriempimento (255,0,0); F=Punto; Spessorepenna (4); G=Punto; Poligono (Punto, Punto, Punto, Punto); H=Punto; Segmento (Punto, Punto); U=Punto; Coloreriempimento (255,255,255); ColoreRiempimento(255,0,0); Poligono (G,H,U); Poligono (A,B,C,D,E,F,G,H,U); Cancella (A,B,C,D,E,F,G,H,U,X,P,Y,T,Z,K,S);
L’iniziativa della giornata di lavoro con gli studenti protagonisti si commenta da sola:
• risultati didatticamente validissimi; • conferma metodologicamente efficace; • “giusto riscatto” di chi ha sempre creduto fortemente nel progetto; • coinvolgimento entusiasmante di alunni, famiglie, docenti, dirigenti
scolastici e autorità accademiche. La scuola Media Statale “A. .Moro” di Marano Marchesato (CS) ringrazia tutti gli organizzatori del convegno per l’offerta formativa di carattere culturale - educativo ricevuta.
SSccuuoollaa SSeeccoonnddaarriiaa ddii II GGrraaddoo ““PP.. ddee CCoouubbeerrttiinn”” RReennddee ((CCSS))
DDiirriiggeennttee SSccoollaassttiiccoo: Immacolata Cairo
DDoocceennttee ssppeerriimmeennttaattoorree: Giselda R. Magnelli
AAlluunnnnoo: Carlo Del Console CCllaassssee IIII BB
PPrrooggrraammmmaa:: “Lavagna con figure geometriche”
Il programma nasce dall'idea di riprodurre ciò che gli studenti vivono quotidianamente nella classe durante le ore di Matematica: disegnare alla lavagna gli enti geometrici fondamentali e le prime figure geometriche. I concetti matematici utilizzati sono: punto, linea, segmento ed angolo. Per l'implementazione dell'algoritmo in MatCos sono state utilizzate sia istruzioni di geometria sia istruzioni generiche.
ColorePenna(128,64,0); SpessorePenna(10); coloreSfondo(0,0,128); A = Punto; B = Punto; C = Punto; D = Punto; Segmento(A,B); Segmento(A,C); Segmento(B,D); Segmento(C,D); ColorePenna(255,255,255); SpessorePenna(1); E = Punto_a_caso;
Linea(F,G); H = Punto; F = Punto; G = Punto; I = Punto; Segmento(H,I); L = Punto; M = Punto; N = Punto; Angolo(L,M,N); O = Punto; P = Punto; Q = Punto; Segmento(O,P); Segmento(P,Q); Segmento(O,Q); R = Punto; S = Punto; T = Punto; V = Punto; Segmento(R,S); segmento(R,T); segmento(V,S); Segmento(V,T); Cancella(A,B,C,D,F,G,H,I,L,M,N,O,P,Q,R,S,T,V);
E
L'utilizzo del MatCos consente di costruire percorsi didattici originali. E' un ambiente di programmazione dove lo studente opera in modo naturale in quanto riflette, organizza e codifica in un linguaggio di programmazione; pertanto, MatCos favorisce un insegnamento più fruibile e dinamico, quindi, un apprendimento diretto e consapevole.
SSccuuoollaa MMeeddiiaa SSttaattaallee ““GG.. DDeell FFoossssoo”” RRoogglliiaannoo ((CCSS))
DDiirriiggeennttee SSccoollaassttiiccoo: Pasquale Berardi
DDoocceennttee ssppeerriimmeennttaattoorree: Francesca Prestia AAlluunnnnii: Mariangela Cozza, Lorenzo Mirabelli, Rosachiara Salvino
CCllaassssee IIIIII AA
PPrrooggrraammmmaa:: “CinCionCian”
La fantasia ed un’attenta riflessione sulla nostra società, che sta diventando sempre più multietnica, hanno indotto gli studenti a ricordare la comunità cinese, perfettamente integrata e sempre più presente nel nostro territorio. È nato, quindi, il programma “CinCionCian”. I concetti matematici utilizzati sono: punto, retta, segmento, rette perpendicolari, rette parallele, poligono, simmetria assiale.
Per l’implementazione dell’algoritmo in MatCos sono state utilizzate le seguenti strutture di programma: istruzioni geometriche e istruzioni generiche.
A=punto; B =punto; C=retta(A,B); D=perpendicolare(C,A); E=segmento(A,B); F=punto_medio(E); G=segmento(B,F); H=punto_medio(G); I=perpendicolare(C,H); L=punto_su(I); M=segmento(F,L); N=segmento(L,B); cancella(I); O=punto_su(D); P=segmento(O,B); Q=punto_su(D); R=parallela(C,Q); S=punto_su(R); T=segmento(O,S); U=punto_su(R); V=punto_su(D); Z=segmento(U,V); W=segmento(U,Q); X=parallela(C,O); Y=punto_su(X); K=perpendicolare(X,Y); j=punto_su(K); A1=segmento(O,Y); B1=segmento(Y,J); 1=segmento(J,O); cancella(X,K,C,R); D1=poligono(O,J,Y); VA=segmento(V,A); ColoreRiempimento(255,255,0); G1=poligono(V,Q,S,U); ColoreRiempimento(255,255,0); H1=poligono(Q,S,O);
ColoreRiempimento(255,255,0); I1=poligono(O,A,F,H,B); ColoreRiempimento(255,255,0); L1=poligonO(F,H,B,L); ColoreRiempimento(255,255,0); M1=poligono(Y,J,O); simmetria_ass(G1,D); ColoreRiempimento(255,255,0); simmetria_ass(H1,D); ColoreRiempimento(255,255,0); simmetria_ass(L1,D); ColoreRiempimento(255,255,0); simmetria_ass(I1,D); ColoreRiempimento(255,255,0); simmetria_ass(M1,D); ColoreRiempimento(255,255,0); poligono(Q,S,U,V); poligono(Q,S,O); poligono(O,A,F,H,B); poligono(O,Y,J); poligono(F,H,B,L); cancella(G1,H1,I1,L1,D,VA,A1,B1,C1);
L’utilizzo del MatCos si è rivelato un valido supporto nell’insegnamento della Matematica in quanto gli studenti, con l’utilizzo di un linguaggio chiaro e preciso, hanno potenziato, ampliato e interiorizzato i concetti affrontati collegandoli alla realtà del proprio vissuto quotidiano.
IIssttiittuuttoo CCoommpprreennssiivvoo SSccuuoollaa MMeeddiiaa CCiirròò ((KKRR))
DDiirriiggeennttee SSccoollaassttiiccoo: Vincenzo Gabriele
DDoocceennttee ssppeerriimmeennttaattoorree: Perlita Brasacchio
AAlluunnnnaa: Enza Marincola CCllaassssee IIII AA
PPrrooggrraammmmaa:: “Girandola”
Il programma nasce dall’idea di riprodurre un gioco molto semplice ed ancora molto usato: la girandola. I concetti matematici utilizzati sono: punto, segmento, circonferenza, poligono, intersezione, rotazione. Per l’implementazione dell’algoritmo in MatCos sono state utilizzate istruzioni di geometria ed istruzioni generiche.
a= punto; b = punto; s = segmento (a,b); l = LeggiNum("200"); c = Circ(a,l); c1 = circ (b,l); d = intersezione(c,c1); ColoreRiempimento(128,0,0); e = poligono (a,b,d); ColoreRiempimento(255,0,255); ruota(e,a,30,orario); ColoreRiempimento(255,0,0); ruota(e,a,60,orario); ColoreRiempimento(128,0,128); ruota(e,a,90,orario); ColoreRiempimento(0,255,255); ruota(e,a,120,orario); ColoreRiempimento(255,0,0); ruota(e,a,150,orario); ColoreRiempimento(255,0,255); ruota(e,a,180,orario); ColoreRiempimento(0,128,128); ruota(e,a,210,orario); ColoreRiempimento(0,0,128); ruota(e,a,240,orario); ColoreRiempimento(0,255,128);
ruota(e,a,270,orario); ColoreRiempimento(255,255,0); ruota(e,a,300,orario); ColoreRiempimento(255,128,0); ruota(e,a,330,orario); ColoreRiempimento(128,0,255); ruota(e,a,360,orario); ColoreRiempimento(255,0,128); Cancella(c,c1,D,A,B);
L’utilizzo del MatCos, mi ha permesso di costruire percorsi didattici più idonei all’apprendimento della Matematica. È un ambiente di programmazione dove lo studente opera in modo naturale in quanto favorisce lo sviluppo delle capacità intuitive - deduttive. Pertanto, l’utilizzo di MatCos consente un insegnamento mirato sui concetti chiave della disciplina, quindi una Matematica non più appiattita nell’applicazione di regole e formule, ma legata ad un insieme di concetti e quindi consente un apprendimento diretto e consapevole.
IIssttiittuuttoo ddii II GGrraaddoo ““GG.. GGaalliilleeii”” RReeggggiioo CCaallaabbrriiaa
DDiirriiggeennttee SSccoollaassttiiccoo: Giuseppina Cellini
DDoocceennttee ssppeerriimmeennttaattoorree: Rosaria Gioffrè
AAlluunnnnaa: Silvia Picara CCllaassssee IIIIII FF
PPrrooggrraammmmaa:: “Mosaico 3”
Il programma nasce dall’idea di riprodurre il particolare di un mosaico del pavimento di una chiesa monumentale che sorge nei pressi della scuola utilizzando le isometrie (costruzione del quadrato, di un quadrilatero intrecciato, rotazione, traslazione). Per l’implementazione dell’algoritmo in MatCos sono state utilizzate istruzioni di geometria come “segmento(punto,numero)”, rotazione, poligono, segmento orientato, traslazione, e l’ istruzione generica “ coloreriempimento”.
A=punto; s=segmento(a,120); s1=ruota(s,a,90,antiorario); B=s1.estremo(2); s2=ruota(s1,b,90,antiorario); c=s2.estremo(1); s3=ruota(s2,c,90,antiorario); d=s.estremo(2); p=poligono(a,b,c,d); ColoreRiempimento(128,0,128); p1=poligono(b,c,a,d); F=punto; s4=segmento(F,120); G=s4.estremo(2); v=segmento_or(f,g);
p2=trasla(p,v); ColoreRiempimento(255,255,255); p3=trasla(p1,v); p4=trasla(p2,v);
ColoreRiempimento(128,0,128); p5=trasla(p3,v);p6=trasla(p4,v); ColoreRiempimento(255,255,255); p7=trasla(p5,v);F1=punto; s5=segmento(f1,120); g1=s5.Estremo(2); v1=segmento_or(f1,g1); trasla(p,v1); ColoreRiempimento(128,0,128); trasla(p1,v1);trasla(p2,v1); ColoreRiempimento(255,255,255); trasla(p3,v1);trasla(p4,v1); ColoreRiempimento(128,0,128);
trasla(p5,v1);trasla(p6,v1); ColoreRiempimento(255,255,255); trasla(p7,v1);
L’utilizzo del MatCos mi ha consentito la trattazione di alcuni concetti della geometria non solo in maniera puramente intuitiva, badando a far nascere negli allievi un’immagine mentale corretta legata alle esatte definizioni ma identificandone anche i termini nella pratica. Gli studenti apprendono i concetti in modo chiaro e naturale scoprendoli, pian piano, quasi autonomamente. MatCos si è rivelato, pertanto, un ausilio prezioso poiché consente l’acquisizione agevole di concetti in modo preciso, rigoroso e soprattutto facilmente verificabile.
SSeeccoonnddaarriiaa ddii II GGrraaddoo ““RRooccccoo CCaammiinniittii””
VViillllaa SSaann GGiioovvaannnnii ((RRCC))
DDiirriiggeennttee SSccoollaassttiiccoo: Caterina Interdonato
DDoocceennttee ssppeerriimmeennttaattoorree: Giuliana Siclari
AAlluunnnnii: Francesco Cotroneo, Andrea Martina Guida CCllaassssee IIIIII EE
PPrrooggrraammmmaa:: “Mondrian e la Matematica”
L’idea di riprodurre una composizione dell’astrattista Mondrian, è scaturita dal fatto che si è sempre pensato alla Matematica come ad un’attività creativa; allora se Mondrian ha usato rigorosi concetti geometrici per le sue opere, noi studenti ci siamo voluti cimentare nella riproduzione di un suo dipinto usando il MatCos e la Matematica come pennelli! Siamo riusciti ad eseguire un listato (Kilometrico!!) che riproduce l’opera, ma per mandarlo in esecuzione è necessario avere davanti il disegno cartaceo. Per quanto riguarda i concetti matematici utilizzati, oltre al concetto di proporzionalità diretta, ci sono tutti i riferimenti alla geometria euclidea; il listato è un tripudio di segmenti, rette perpendicolari e parallele. Le strutture di programma usate sono semplicemente quelle inerenti la geometria, previste dal modulo MatCos 2.2.
Qui, di seguito, si riporta il listato, l’output grafico ed il disegno cartaceo sul quale, noi studenti, abbiamo lavorato.
A=punto; AA=punto; ColorePenna(0,0,0); SpessorePenna(2); r=retta(a,AA); m=legginum("lato quadrato di 500 pixel"); s=segmento(A,m,r); B=s.estremo(2); p=perpendicolare(r,A); l=segmento(A,m,p); D=l.estremo(2); pa=parallela(r,D); p1=perpendicolare(r,B); C=intersezione(pa,p1); m1=legginum("116 pixel"); l1=segmento(D,m1,pa); E=l1.estremo(2); m2=legginum("195 pixel"); l2=segmento(E,m2,pa); F=l2.estremo(2); m3=legginum("171 pixel"); l3=segmento(F,m3,pa); G=l3.estremo(2); m4=legginum("18 pixel"); l4=segmento(G,m4,pa); C=l4.estremo(2); m5=legginum("129 pixel"); l5=segmento(A,m5,p); H=l5.estremo(2); m6=legginum("371 pixel"); l6=segmento(H,m6,p); D=l6.estremo(2); m7=legginum("60 pixel");l7=segmento(A,m7,r);
O=l7.estremo(2); l10=segmento(B,m5,p1); K=l10.estremo(2); 11=segmento(K,m6,p1); C=l11.estremo(2); r1=retta(H,K); m12=legginum("492 pixel"); l12=segmento(K,m12,r1); kk=l12.estremo(2); l21=segmento(g,m13,pa);vv=l21.estremo(2); r8=perpendicolare(r,vv); N=intersezione(r,r8); r9=perpendicolare(r,f); m16=legginum("13 pixel"); l22=segmento(vv,m16,r8); xx=l22.estremo(2); l23=segmento(g,m16,r3);yy=l23.estremo(2); l24=segmento(n,m13,r8); t=l24.estremo(2); tt=intersezione(r3,r); l25=segmento(tt,m13,r3); bb=l25.estremo(2); r10=parallela(p,kk); et=intersezione(r10,r4); ev=intersezione(r10,r5); l26=segmento(zz,m1,r3); tv=l26.estremo(2); l29=segmento(TV,m13,r3); VT=l29.estremo(2); r11=parallela(r,TV); XY=intersezione(r11,p4);YX=intersezione(r5,p4); UV=intersezione(r5,r8);VU=intersezione(r11,r8); l30=segmento(VU,m13,r8);DD=l30.estremo(2); m18=legginum("5 pixel"); l27=segmento(F,m18,r9); AR=l27.estremo(2); l28=segmento(V,m18,p4);AS=l28.estremo(2); l31=segmento(XY,m13,p4);FF=l31.estremo(2); l32=segmento(DD,m1,r8);GG=l32.estremo(2);
l33=segmento(FF,m1,p4); LL=l33.estremo(2); r12=parallela(r,GG); FT=intersezione(r5,r9);FR=intersezione(r5,r6); FS=intersezione(r6,r12);TR=intersezione(r9,r12); l34=segmento(E,m13,p5);CR=l34.estremo(2); l35=segmento(EE,m13,p6); RC=l35.estremo(2); R=intersezione(r4,p5); SS=intersezione(r4,p6); AD=intersezione(p,r4); AB=intersezione(r4,r9); l36=segmento(X,m13,r7);CM=l36.estremo(2);
m13=legginum("8 pixel"); l13=segmento(K,m13,p1); Z=l13.estremo(2); r2=parallela(r1,Z); l14=segmento(Z,m12,r2); cc=l14.estremo(2); r3=perpendicolare(r,G); Q=intersezione(r2,r3); m15=legginum("53 pixel"); l15=segmento(G,m15,r3); QQ=l15.estremo(2); r4=parallela(r,QQ); l16=segmento(QQ,m13,r3); ZZ=l16.estremo(2); r5=parallela(r4,ZZ); l17=segmento(F,m13,pa); V=l17.estremo(2); p4=perpendicolare(r,V); l18=segmento(E,m13,pa); EE=l18.estremo(2); p5=perpendicolare(r,E);
p6=perpendicolare(r,EE); r6=perpendicolare(r,O); l19=segmento(O,m15,r6); OO=l19.estremo(2); l20=segmento(O,m13,r); X=l20.estremo(2); r7=parallela(p,X); PG=intersezione(r11,r10); l38=segmento(PG,m13,r10); RG=l38.estremo(2); GR=intersezione(r7,r11); l39=segmento(GR,m13,r7); AX=l39.estremo(2); SA=intersezione(r7,r1); K5=l44.estremo(2); l45=segmento(K5,m13,r12); K6=l45.estremo(2); l46=segmento(K4,m13,r14); K7=l46.estremo(2); l47=segmento(N,m4,r8); K8=l47.estremo(2); r15=parallela(r,K8); l48=segmento(K8,m13,r8); K9=l48.estremo(2); K10=intersezione(p4,r15); r16=parallela(r,K9); K13=intersezione(p4,r16);
K11=intersezione(r2,r8); K12=intersezione(r2,p4); m48=legginum("134 pixel"); l48=segmento(K10,m48,r15); K20=l48.estremo(2); r21=parallela(r,OX); OY=intersezione(r9,r21); AP=intersezione(r9,r15); BP=intersezione(r4,p4); BR=intersezione(r8,r4);
l37=segmento(O,m13,r6);MC=l37.estremo(2); OK=intersezione(r5,r7);GP=intersezione(r7,r2); poligono(a,b,c,d); ColorePenna(0,0,0); ColoreRiempimento(0,0,0); poligono(k,kk,cc,z); poligono(yy,xx,t,bb); poligono(qq,et,ev,zz); poligono(FF,DD,VU,XY);poligono(CR,RR,SS,RC); poligono(OK,CM,MC,FR);poligono(PG,RG,AX,GR); poligono(FS,CB,CK,GG);poligono(K4,K5,K6,K7); Poligono(XZ,OO,K31,K30); poligono(K13,K10,K8,K9); Poligono(PS,OA,RA,RO);
Poligono(OA,K21,K10,K30); poligono(OO,OA,OB,CB); Poligono(AR,AS,K10,AP); ColoreRiempimento(234,206,47); poligono(UV,YX,XY,VU); poligono(H,KK,CC,GP,CM,MC,O,A); Poligono(F,AR,AS,BP,BR,XX,YY,G); ColoreRiempimento(255,0,0); poligono(FR,FS,TR,FT);poligono(Q,Z,B,N,T,BB); ColoreRiempimento(225,223,225); poligono(AD,RR,E,D);poligono(E,CR,RC,SS,AB,F); poligono(AD,ET,EV,OK,GR,PG,RG,AX,SA,H); l49=segmento(K20,m13,r15); K21=l49.estremo(2); r20=parallela(p,K21); KO=intersezione(r1,r3);r13=parallela(r,OO); l40=segmento(FS,m13,r6);CB=l40.estremo(2); l41=segmento(GG,m13,r8);CK=l41.estremo(2); K2=intersezione(r1,p4); K3=intersezione(r1,r8); l42=segmento(LL,m13,p4);K1=l42.estremo(2); r14=perpendicolare(p,DD); m43=legginum("73 pixel"); l43=segmento(DD,m43,r14); K4=l43.estremo(2);l44=segmento(GG,m43,r12);
XZ=intersezione(r21,r6); r22=parallela(p,K20); PS=intersezione(r13,r22); l60=segmento(K20,m13,r22); RO=l60.estremo(2); l70=segmento(K21,m13,r20); RA=l70.estremo(2); K30=intersezione(r21,p4); K31=intersezione(r13,p4); OA=intersezione(r20,r13); r18=parallela(r,K1); OB=intersezione(r18,r20);
OC=intersezione(r9,r18); OD=intersezione(r1,r9); OE=intersezione(r1,r20); LA=intersezione(r20,r2); LB=intersezione(r2,r9); l50=segmento(OA,m13,r20); OX=l50.estremo(2); poligono(G,KO,K,C); Poligono(O,OO,PS,RO,RA,K21, K8,N); poligono(K1,K2,K3,CK); Poligono(FF,K7,K6,LL); poligono(K4,DD,GG,K5); Poligono(OB,OC,OD,OE); Poligono(OX,OY,LB,LA); ColoreRiempimento(0,0,128); Poligono(K11,K12,K13,K9); cancella(r,r15,r16,r13,r21,r2,r1,r18,r12,r14,r11,r5,r4,pa,p,r10,r7,r6,p5,p6,r22,r20,r9,p4,r8,r3,p1); cancella(AA,A,B,C,X,O,RO,RA, CM,MC,AP,K10,N,TT,BB,T,Z,K, KO,TV,VT,QQ,YY);
L’utilizzo del MatCos nella pratica didattica ha consentito un apprendimento più partecipe e consapevole di concetti, sia aritmetici che geometrici. La programmazione di situazioni si è rivelata agevole e naturale e gli studenti, autonomamente, sono andati alla ricerca di cosa “programmare per stupire”. Ecco perché Mondrian! MatCos ha quindi consentito, oltre alla matematizzazione della realtà, una corretta acquisizione del linguaggio specifico della Matematica. Chissà cosa vorranno programmare, dopo Mondrian!
HHIIGGHHEERR SSEECCOONNDDAARRYY SSCCHHOOOOLLSS
LLiicceeoo SScciieennttiiffiiccoo SSttaattaallee ““FF.. SSeevveerrii”” CCaasstteellllaammmmaarree ddii SSttaabbiiaa ((NNAA))
DDiirriiggeennttee SSccoollaassttiiccoo: Carlo Tozza
DDoocceennttee ssppeerriimmeennttaattoorree: Francesco di Paola Bruno AAlluunnnnii: Stanislao Grazioso, Antonino Massano CCllaassssee IIII CC
SSppeerriimmeennttaazziioonnee PP..NN..II.. -- MMaatteemmaattiiccaa ee FFiissiiccaa
PPrrooggrraammmmaa:: “Ruotarcobaleno”
Utilizzando la rotazione delle figure nel piano, è nata l’idea di creare una ruota generata da 120 poligoni, ognuno ottenuto ruotando il precedente di 3 gradi mediante un ciclo. Per colorarla come l’arcobaleno, sono state usate 3 funzioni che forniscono per ogni poligono i valori da 0 a 255 delle componenti rosso, verde e blu, con tutte le sfumature intermedie, come illustrato più in dettaglio dal successivo programma “Colori”.
/* Programma Ruotarcobaleno */ ColoreSfondo(0,0,0); ColorePenna(0,0,0); RifCart; ColorePenna(255,255,255); Stampa("disegnare i 4 vertici di un quadrilatero"); A=Punto; B=Punto; C=Punto; D=Punto; quadrilatero=Poligono(A,B,C,D); Stampa("disegnare il centro di rotazione"); O=Punto; Cancella(A,B,C,D); x0=0; x1=20; x2=40; x3=60; x4=80; x5=100; x6=120; PER (x da x0 a x6) ESEGUI; Rosso=Int(255*(1-ValoreAss((x-x1)/(2*(x2-x1)))+ ValoreAss((x-x2)/(2*(x2-x1)))+
ValoreAss((x-x4)/(2*(x5-x4)))- ValoreAss((x-x5)/(2*(x5-x4))))); Verde = Int(255*(ValoreAss((x-x0)/(2*(x1-x0)))- ValoreAss((x-x1)/(2*(x1-x0)))+ - ValoreAss((x-x3)/(2*(x4-x3)))+ ValoreAss((x-x4)/(2*(x4-x3))))); Blu = Int(255*(ValoreAss((x-x2)/(2*(x3-x2)))- ValoreAss((x-x3)/(2*(x3-x2)))- ValoreAss((x-x5)/(2*(x6-x5)))+ ValoreAss((x-x6)/(2*(x6-x5))))); ColorePenna(Rosso,Verde,Blu); quadrilatero = Ruota(quadrilatero,O,3,orario); FINE;
PPrrooggrraammmmaa:: “Colori”
Questo programma ha il solo scopo di illustrare le 3 funzioni utilizzate nel precedente programma “Ruotarcobaleno”. Si tratta di 3 funzioni a gradino mediante valori assoluti che al variare di x da 0 a 120 assumono valori da 0 a 255 secondo lo schema visualizzato dal programma, dove partendo dai valori (255,0,0) per il rosso, si passa a (255,255,0) giallo, (0,255,0) verde, (0,255,255) azzurro, (0,0,255) blu, (255,0,255) viola per poi ritornare con (255,0,0) di nuovo al rosso.
/* Programma colori */ ColorePenna(255,255,255); RifCart(5,0.4); x0=0; x1=20; x2=40; x3=60; x4=80; x5=100; x6=120; SpessorePenna(2); FRosso = Funzione("340+int(255*(1-abs((x-x1)/(2*(x2-x1)))" || "+abs((x-x2)/(2*(x2-x1)))" || "+abs((x-x4)/(2*(x5-x4)))" || "-abs((x-x5)/(2*(x5-x4)))))"); ColorePenna(255,0,0); GraficoFunz(FRosso); FVerde = Funzione ("20+int(255*(abs((x-x0)/(2*(x1-x0)))" ||
"-abs((x-x1)/(2*(x1-x0)))" || "-abs((x-x3)/(2*(x4-x3)))" || "+abs((x-x4)/(2*(x4-x3)))))"); ColorePenna(0,255,0); GraficoFunz(FVerde); FBlu = Funzione ("-300+int(255*(abs((x-x2)/(2*(x3-x2)))" || "-abs((x-x3)/(2*(x3-x2)))" || "-abs((x-x5)/(2*(x6-x5)))" || "+abs((x-x6)/(2*(x6-x5)))))"); ColorePenna(0,0,255); GraficoFunz(FBlu);SpessorePenna(10); ColorePenna(255,0,0); rosso = Punto(x0,-400); ColorePenna(255,255,0); giallo = Punto(x1,-400); ColorePenna(0,255,0); verde = Punto(x2,-400); ColorePenna(0,255,255); azzurro=Punto(x3,-400); ColorePenna(0,0,255); blu = Punto(x4,-400); ColorePenna(255,0,255); viola = Punto(x5,-400); ColorePenna(255,0,0); rosso1 = Punto(x6,-400); SpessorePenna(1); StilePenna(5); ColorePenna(0,0,0); retta(rosso,Punto(x0,700)); retta(giallo,Punto(x1,700));retta(verde,Punto(x2,700)); retta(azzurro,Punto(x3,700)); retta(blu,Punto(x4,700)); retta(viola,Punto(x5,700)); retta(rosso1,Punto(x6,700));
PPrrooggrraammmmaa:: “Sierpinsky”
La scelta a caso di uno dei tre vertici di un triangolo mediante un generatore di numeri casuali 1, 2 o 3 unita al semplice calcolo delle coordinate del punto medio di un segmento, note quelle degli estremi, ripetute in un ciclo 2000 o più volte, consentono a questo programma di creare una figura in un primo momento molto caotica, ma poi sempre più definita, tendente al frattale noto come “triangolo di Sierpinsky”.
Stampa("Frattale detto ""Triangolo di Sierpinsky"""); ColorePenna(255,255,255); RifCart; ColorePenna(0,0,255); A=Punto(-10,-6); B=Punto(10,-6); C=Punto(0,6); P=Punto(0,0); xp=P.X; yp=P.Y; per (i da 1 a 2000) esegui; n=int(numero_a_caso(0,3))+1; se (n=1) allora esegui; xi=a.x; yi=a.y; fine; se (n=2) allora esegui; xi=b.x; yi=b.y; fine; se (n=3) allora esegui; xi=c.x; yi=c.y; fine; xp=(xi+xp)/2; yp=(yi+yp)/2; punto(xp,yp); fine;
Con MatCos è risultato abbastanza semplice far realizzare agli studenti del biennio i precedenti lavori, soprattutto per le potenzialità grafiche che permettono un’immediata rappresentazione di oggetti geometrici, legata più ad aspetti matematici che informatici, paragonabile a quella dei software interattivi di geometria dinamica. Il fatto, poi, di essere programmabile, permette agli studenti di comprendere come alcune operazioni che concettualmente sono facili da realizzare, di fatto, poi, sono impossibili da eseguirsi a mano interattivamente, se occorre ripeterle un notevole numero di volte come ad esempio la determinazione dei colori e della posizione dei 120 quadrilateri nel programma “Ruotarcolabeno” e le 2000 o più iterazioni dei semplici passi che portano alla costruzione dei punti del “triangolo di Sierpinsky”.
DDoocceennttee ssppeerriimmeennttaattoorree: Rosa Porciello AAlluunnnnoo: Francesco Schettino CCllaassssee IIVV HH
SSppeerriimmeennttaazziioonnee PP..NN..II.. -- MMaatteemmaattiiccaa ee FFiissiiccaa
PPrrooggrraammmmaa:: “Piano inclinato”
Il programma nasce dall’idea di poter esemplificare il moto di un corpo lungo un piano inclinato con o senza attrito. I concetti matematici utilizzati sono la conoscenza delle funzioni seno, coseno e tangente. Per l’implementazione dell’algoritmo in MatCos sono state utilizzate le seguenti strutture di programma: ciclo per ( i da 1 a..) esegui;
ColorePenna(255,255,255); Rifcart; b=legginum("Lunghezza della base del piano inclinato(cm)");
h=legginum("Altezza del Piano inclinato(cm)"); M=legginum("Massa del Corpo"); l=radiceq(b^2+h^2); Fp=M*9.8; PII=Fp*(h/l); Px=Fp*(b/l); k=legginum("Coefficiente d'attrito"); Fa=k*Px; P=punto(0,h); P1=punto(b,0); o=punto(0,0); ColorePenna(0,0,0); SpessorePenna(3); l1=segmento(o,p); l2=segmento(p,p1); l3=segmento(p1,o); G=punto(b/3,h); r=retta(P,P1); d=distanza(g,r); c=circ(g,d); OP1P=angolo(P,P1,o); a=ampiezza(OP1P); Stampa("L'ampiezza dell'angolo a è di ",a,"°"); Stampa("La forza peso del corpo è pari a ",Fp,"N, che equivalgono a ",Fp/9.8,"Kgp"); Stampa("La forza di attrito è di ",Fa,"N"); ColorePenna(0,255,255); SpessorePenna(1); s=parallela(r,g); s1=perpendicolare(r,g); ColorePenna(0,0,255);SpessorePenna(3);
F=punto(g.x,g.y-1/2*h); Vp=segmento_or(G,F);s2=parallela(r,f); s3=perpendicolare(r,f); C1=intersezione(s,s3); C2=intersezione(s1,s2); ColorePenna(0,182,128); Vc=segmento_or(g,c1); Vc1=segmento_or(g,c2); ColorePenna(128,128,128);sv=segmento(g,c1); i=punto_medio(sv);StilePenna(6); Vv=segmento_or(g,i); StilePenna(1); ColorePenna(0,0,0);Cv=circ(g,d);cancella(r,G,F,C1,C2,s2,s3,p,p1,o,sv,i); se(Fa>=PII) Allora esegui; stampa("Il corpo resta in uno stato di equilibrio"); fine; altrimenti esegui; acc=(Px-Fa)/m;
stampa("Il corpo si muove con un accelerazione di ",acc,"m/s^2");Pausa(3000); stampa("Attendere qualche secondo per il movimento"); Per(i da 1 a 100) esegui pausa(160); ColorePenna(128,128,128); t=trasla(C,Vv); cancella(C); C=t; Fine; fine;
L’utilizzo del MatCos mi ha permesso di costruire percorsi didattici di supporto alle esercitazioni per la risoluzione di problemi sul moto dei corpi. E’ un ambiente di programmazione dove lo studente opera in modo naturale in quanto la codifica è molto simile al linguaggio usato per la descrizione dei problemi proposti. Pertanto, l’utilizzo di MatCos consente un insegnamento più fruibile e variegato e quindi un apprendimento immediato e consapevole da parte di tutti gli studenti.
II..II..SS..SS.. LLiicceeoo SScciieennttiiffiiccoo ““VV..JJuulliiaa”” AAccrrii ((CCSS))
DDiirriiggeennttee SSccoollaassttiiccoo: Luigi Aiello
DDoocceennttee ssppeerriimmeennttaattoorree: Sara Reale AAlluunnnnii: Anna Gencarelli, Marco Taranto, Ilaria Vocaturo CCllaassssee IIVV BB
PPrrooggrraammmmaa:: “Risoluzione dei triangoli”
Si è voluto affrontare lo studio della risoluzione dei triangoli perché trova applicazione in svariati settori della scienza e della tecnica. Gli studenti hanno verificato le applicazioni nell’ambito della Fisica e della Topografia. Il programma è stato sviluppato considerando i diversi casi di risoluzione (3 lati, 1 lato e 2 angoli,
2 lati e l’angolo compreso, 2 lati e l’angolo non compreso). I concetti matematici: condizioni per la determinazione di un triangolo, disuguaglianza triangolare, funzioni trigonometriche e loro inverse, teorema dei seni, Teorema di Carnot, somma degli angoli di un triangolo. Per l’implementazione dell’algoritmo in MatCos sono state utilizzate le seguenti strutture di programma: assegnazioni, istruzioni di controllo, funzione, valutafunz, punto, segmento, angolo.
Stampa(“Questo programma risolve un triangolo nel caso in cui sono dati 3 lati”); a=legginum("dammi la misura di un lato"); b=legginum("dammi la misura di un altro lato"); c=legginum("dammi la misura del terzo lato"); se(a<b+c)E(b<a+c)E(c<b+a)allora esegui; cosalfa=(c^2+b^2-a^2)/(2*c*b); f=funzione("arccos(x)"); alfar=valutafunz(f,cosalfa); alfa=alfar*180/PI; cosgamma=(a^2+b^2-c^2)/(2*a*b); f=funzione("arccos(x)"); gammar=valutafunz(f,cosgamma); gamma=gammar*180/PI; beta=180-alfa-gamma; stampa("gli elementi del triangolo sono: LATI ",a," ",b," ",c," ; ANGOLI: ",alfa," ",beta," ",gamma); stampa("inizia la costruzione del triangolo"); G=punto; s=segmento(G,a); Angolo(s,gamma,orario); stampa("posiziona il cursore sul vertice dell'angolo e traccia il nuovo segmento sul secondo lato"); colore(15); F=punto; Colore(12); t=segmento(F,b); H=punto; m=segmento(H,c);F=punto; fine; altrimenti esegui; stampa("non è possibile costruire il triangolo perché non è verificata la disuguaglianza triangolare"); fine; Stampa(“Questo programma risolve un triangolo nel caso in cui sono dati 1 lato e 2 angoli”); a=legginum("dammi la misura di un lato"); alfa=legginum("dammi la misura di un angolo in gradi"); beta=legginum("dammi la misura di un altro angolo in gradi"); se(alfa+beta<180)allora esegui; gamma=180-alfa-beta; b=a*sen(beta)/sen(alfa); c=b*sen(gamma)/sen(beta); stampa("gli elementi del triangolo sono: LATI ",a," ",b," ",c," ; ANGOLI: ",alfa," ",beta," ",gamma); stampa("inizia la costruzione del triangolo");G=punto; s=segmento(G,a); angolo(s,gamma,orario); stampa("posiziona il cursore sul vertice dell'angolo e traccia il nuovo segmento sul secondo lato"); colore(15); F=punto; Colore(12); t=segmento(F,b); H=punto; m=segmento(H,c);F=punto; fine; altrimenti esegui; stampa("la somma dei due angoli è >180° e non è possibile costruire il triangolo"); fine; Stampa(“Questo programma risolve un triangolo nel caso in cui sono dati 2 lati e l’ angolo compreso”); a=legginum("dammi la misura di un lato"); b=legginum("dammi la misura di un altro lato"); gamma=legginum("dammi la misura dell'angolo compreso in gradi"); c=RadiceQ(a^2+b^2-2*a*b*cos(gamma)); cosalfa=(c^2+b^2-a^2)/(2*c*b); f=funzione("arccos(x)"); alfar=valutafunz(f,cosalfa); alfa=alfar*180/PI; beta=180-alfa-gamma; stampa("gli elementi del triangolo sono: LATI ",a," ",b," ",c," ; ANGOLI: ",alfa," ",beta," ",gamma); stampa("inizia la costruzione del triangolo"); G=punto; s=segmento(G,a); Angolo(s,gamma,orario);
stampa("posiziona il cursore sul vertice dell'angolo e traccia il nuovo segmento sul secondo lato"); colore(15); F=punto; Colore(12); t=segmento(F,b); H=punto; m=segmento(H,c);F=punto; Stampa(“Questo programma risolve un triangolo nel caso in cui sono dati 2 lati e l’ angolo non compreso”); a=legginum("dammi la misura di un lato"); b=legginum("dammi la misura di un altro lato"); beta=legginum("dammi la misura di un angolo non compreso in gradi"); se(a*sen(beta)<=b)allora esegui; senalfa=(a*sen(beta))/b; f=funzione("arcsin(x)"); alfar=valutafunz(f,senalfa); alfa=alfar*180/PI; gamma=180-alfa-beta; c=RadiceQ(a^2+b^2-2*a*b*cos(gamma)); stampa("gli elementi del triangolo sono: LATI ",a," ",b," ",c," ; ANGOLI: ",alfa," ",beta," ",gamma); stampa("inizia la costruzione del triangolo"); G=punto; s=segmento(G,a); Angolo(s,gamma,orario); stampa("posiziona il cursore sul vertice dell'angolo e traccia il nuovo segmento sul secondo lato"); colore(15); F=punto; Colore(12); t=segmento(F,b); H=punto; m=segmento(H,c);F=punto; fine; altrimenti esegui;
stampa("non è possibile costruire il triangolo perchè risulta a*sen(beta)>b"); fine;
Sono convinta che lo scopo principale dell’uso dell’Informatica in Matematica è quello di fornire all’allievo la capacità di utilizzare l’elaboratore per la soluzione di problemi fornendogli un’adeguata conoscenza operativa di uno specifico linguaggio di programmazione. Il linguaggio prescelto dovrebbe poter essere utilizzato come strumento per la rappresentazione di algoritmi prima ancora che come strumento di codifica. E’ proprio per questo motivo, che da cinque anni, ho aderito al Progetto “Matematica & Computer” del C.I.R.D. dell’Università della Calabria, sperimentando l’uso del “MATCOS” ed abbandonato l’uso del “Pascal”, poiché quest’ultimo risulta complicato per la risoluzione di problemi più complessi; mentre il primo si presta in maniera naturale alla “costruzione strutturata” di programmi rispecchiando il linguaggio specifico degli argomenti di Matematica trattati nel P.N.I.
II..II..SS..SS.. IInnddiirriizzzzoo TTeeccnniiccoo CCoommmmeerrcciiaallee CCaassssaannoo IIoonniioo ((CCSS))
DDiirriiggeennttee SSccoollaassttiiccoo: Agata Foti
DDoocceennttee ssppeerriimmeennttaattoorree: Maria Luisa Fasanella
AAlluunnnnii: Maria Francesca Fallace, Elvira Pinto CCllaassssee IIVV BB
PPrrooggrraammmmaa:: “Applicazioni dell’analisi all’economia”
Il programma è nato per risolvere, nell’ambito delle applicazioni della matematica in campo economico, problemi di scelta relativi alla determinazione del massimo profitto e del minimo costo medio. I principali concetti matematici utilizzati sono quelli di funzione, di derivata di una funzione, di massimo e minimo di una funzione di una sola variabile. Per l’implementazione dell’algoritmo in MatCos sono state utilizzate strutture di controllo, assegnazioni, ed istruzioni relative alle funzioni.
rifcart(30,10); coloresfondo(175,235,235); C=funzione("0.2*x^2-20*x+600"); graficofunz(C); funzionecosto=punto(62.5,130); colorepenna(255,0,255);
R=funzione("4*x"); graficofunz(R); funzionericavo=punto(8,30); U=R-C; stampafunz(U); colorepenna(0,128,128); graficofunz(U); funzioneprofitto=punto(79,50); colorepenna(255,0,0); g=derivatafunz(U); stampafunz(g); graficofunz(g); z=fzero(g,60.5,0.5,0.1); stampa(z); b=valutafunz(U,z); stampa(b); P=punto(z,b); f=derivatafunz(g); stampafunz(f); a=valutafunz(f,z); se a<0 allora stampa("z è il punto di massimo profitto"); altrimenti stampa("z non è il punto di massimo profitto"); z=punto(z,0); z2=Fzero(U,85.5,0.1,0.1); stampa(z2); z1=fzero(U,45.5,0.1,0.1); Stampa(z1); reak_point=punto(z2,0); break_point=punto(z1,0); stampa("il profitto massimo realizzabile vale 120 centinaia di euro",b); a1=valutafunz(R,z1); P1=punto(z1,a1); b1=valutafunz(R,z2); P2=punto(z2,b1); zona_di_utile=Punto;
Rifcart(30,10); C=funzione("10+x^2+3*x"); graficofunz(C); funzionecosto=punto(1,13.7); Cm=funzione("(10+x^2+3*x)/x"); colorepenna(255,0,255); spessorepenna(1); graficofunz(Cm); Costomedio=punto(8,12.2); g=derivatafunz(Cm); stampafunz(g); colorepenna(255,0,0); graficofunz(g); z1=fzero(g,4.5,0.1,0.1); f=derivatafunz(g); stampafunz(f); a=valutafunz(f,z1);
se a>0 allora esegui; stampa("z è un punto di minimo per Cm"); fine; altrimenti esegui; stampa("z non è un punto di minimo per Cm"); Fine; b=valutafunz(Cm,z1); stampa(b); P=punto(z1,b); Cma=derivatafunz(C); stampafunz(Cma); colorepenna(0,128,0); spessorepenna(1); graficofunz(Cma); costomarginale=punto(7,17); c=valutafunz(Cma,z1);
stampa(c); se valoreass(b-c)<0.1 allora esegui; stampa("il punto di minimo costo medio coincide l'intersezione tra Cm e Cma"); fine; altrimenti esegui; stampa("il punto di minimo costo medio non coincide con l'intersezione tra Cm e Cma"); fine;
L’uso del MatCos nella didattica ha consentito la costruzione di nuovi percorsi cognitivi per gli studenti; evidenziando il legame tra matematica e realtà, ha promosso negli studenti una maggiore coscienza verso lo studio della disciplina.
LLiicceeoo CCllaassssiiccoo OOrriioolloo ((CCSS))
sseezz.. ssttaaccccaattaa ddeell LLiicceeoo SScciieennttiiffiiccoo ““GGaalliilleeoo GGaalliilleeii”” TTrreebbiissaaccccee ((CCSS))
DDiirriiggeennttee SSccoollaassttiiccoo: Tullio Masneri
DDoocceennttee ssppeerriimmeennttaattoorree: Rosa Abate AAlluunnnnaa: Valentina De Marco CCllaassssee IIII AA
PPrrooggrraammmmaa:: “I colori della Fisica”
Il programma nasce dall’idea di creare un legame tra la geometria, la fisica ed in particolare la natura. I concetti matematici utilizzati sono: il piano cartesiano, la direzione, il punto, il poligono, il prisma. Per l’implementazione dell’algoritmo in MatCos sono state utilizzate le seguenti strutture di programma: assegnazione, punto, segmento, poligono.
Colorepenna(218,245,177); Rifcart; ColoreSfondo(218,245,177); a=punto(0,0); b=punto(-2,-1); c=punto(2,-1); d=punto(4,0); StilePenna(5); ColorePenna(0,0,160); spessorepenna(2); s=segmento(a,b); s1=segmento(c,d); poligono(a,b,c,d);
StilePenna(1); e=punto(0,3); poligono(b,c,e); f=punto(2,4); StilePenna(1); s2=segmento(f,d); s3=segmento(e,f); StilePenna(5); s4=segmento(a,f); StilePenna(1); g=punto(-1,1); h=punto(5/4,1/2); i=punto(13/4,3/2); l=punto(1,2); poligono(g,h,i,l); ColorePenna(0,0,255); SpessorePenna(1); prisma=punto(-1,-1); m=punto(-7,1); n=punto(-5,2); o=punto(-15/2,-2); p=punto(-9/2,0); q=punto(-15/2,3); r=punto(-9/2,5); ColoreRiempimento (255,255,128); poligono(o,p,r,q); s5=segmento(m,n); s6=segmento(m,g);
s7=segmento(n,l); MotivoRiempimento(2); schermo=punto(-15/2,-5/2); s8=segmento(m,n); t=punto(-8,-2); u=punto(-23/2,-2); s9=segmento(t,u); v=punto(-8,-1); z=punto(-23/2,-1); s10=segmento(v,z); a1=punto(-8,0); a2=punto(-23/2,0); s11=segmento(a1,a2); a3=punto(-8,1); a4=punto(-23/2,1); s12=segmento(a3,a4); a5=punto(-8,2);
a6=punto(-23/2,2); s13=segmento(a5,a6); a7=punto(-8,3); a8=punto(-23/2,3); s14=segmento(a7,a8); a9=punto(-7,4); a10=punto(-23/2,4); s15=segmento(a9,a10); a11=punto(-11/2,5); a12=punto(-23/2,5); s16=segmento(a11,a12); a13=punto(-23/2,-1/2);
a14=punto(-9,-1/2); s17=segmento(a13,a14); b1=punto(-9,-1/4); b2=punto(-9,-3/4); b3=punto(-17/2,-1/2); ColoreRiempimento (255,255,0); poligono(b1,b2,b3); MotivoRiempimento(2); a15=punto(-23/2,3/2); a16=punto(-9,3/2); s18=segmento(a15,a16); b4=punto(-9,7/4); b5=punto(-9,5/4); b6=punto(-17/2,3/2); ColoreRiempimento (255,255,0); poligono(b4,b5,b6); motivoriempimento(2); a17=punto(-23/2,7/2); a18=punto(-9,7/2); s19=segmento(a17,a18); b7=punto(-9,13/4); b8=punto(-9,15/4); b9=punto(-17/2,7/2); ColoreRiempimento (255,255,0);
poligono(b7,b8,b9); motivoriempimento(2); lucesolare=punto (-23/2,-5/2); c1=punto(19/2,-5); c2=punto(19/2,-9/2); c3=punto(19/2,-4); c4=punto(19/2,-7/2); c5=punto(19/2,-3); c6=punto(19/2,-5/2); c7=punto(19/2,-2); c8=punto(19/2,-3/2); c9=punto(23/2,-1/2); s20=segmento(g,c1); s21=segmento(g,c2); s22=segmento(g,c3); s23=segmento(g,c4); s25=segmento(g,c5);
s26=segmento(g,c6); s27=segmento(g,c7); s28=segmento(g,c8); s29=segmento(i,c9); s30=segmento(c1,c8); c10=punto(23/2,-1); c11=punto(23/2,-3/2); c12=punto(23/2,-2); c13=punto(23/2,-5/2); c14=punto(23/2,-3); c15=punto(23/2,-7/2); c16=punto(23/2,-4);
s31=segmento(c8,c9); s32=segmento(c9,c16); s33=segmento(c7,c10); s34=segmento(c6,c11); s35=segmento(c5,c12); s36=segmento(c4,c13); s37=segmento(c3,c14); s38=segmento(c2,c15); s39=segmento(c1,c16); spettro=punto(19/2,-11/2); lucerifratta=punto(7,1); coloreriempimento (255,0,0); poligono(g,c7,c8); poligono(c8,c7,c10,c9); coloreriempimento (255,128,0); poligono(g,c7,c6); poligono(c7,c10,c11,c6); coloreriempimento (255,255,0); poligono(g,c6,c5); poligono(c6,c11,c12,c5); coloreriempimento (128,255,128); poligono(g,c5,c4); poligono(c5,c4,c13,c12); coloreriempimento
(0,128,255); poligono(g,c4,c3); poligono(c4,c3,c14,c13); coloreriempimento (0,128,192); poligono(g,c3,c2); poligono(c3,c2,c15,c14); coloreriempimento (128,128,255); poligono(g,c2,c1); poligono(c2,c1,c16,c15); cancella(a,b,c,d,e,f,g,h,i,l,m,n,o,p,q,r,t,u,v,z,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,b1,b2,b3,b4,b5,b6,b7,b8,b9,c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13,c14,c15,c16);
L’utilizzo del MatCos mi ha permesso di costruire i seguenti percorsi didattici: la geometria razionale e la geometria analitica. E’ un ambiente di programmazione dove, soltanto con un piccolo aiuto del docente, lo studente opera in modo naturale e più spedito. Pertanto, l’utilizzo di MatCos consente un insegnamento più fruibile ed esauriente, semplificando quel rigore logico che è caratteristico della disciplina; con l’uso di questo software la geometria diventa ricca di significato e quindi favorisce un apprendimento istantaneo e consapevole, fatto di entusiasmi e soddisfazioni (“Sono stato capace di farlo da solo!”).
LLiicceeoo SScciieennttiiffiiccoo SSttaattaallee ““GGaalliilleeoo GGaalliilleeii”” TTrreebbiissaaccccee ((CCSS))
DDiirriiggeennttee SSccoollaassttiiccoo: Tullio Masneri
DDoocceennttee ssppeerriimmeennttaattoorree: Elisabetta De Leo
AAlluunnnnaa: Carmela Giacobini CCllaassssee IIVV BB
PPrrooggrraammmmaa:: “Determinazione della forza di galleggiamento”
Il programma nasce dall’idea di voler rappresentare il principio di Archimede verificandone la veridicità. I concetti matematici utilizzati sono: riferimento cartesiano, punti e segmenti. Per l’implementazione dell’algoritmo è stata utilizzata la struttura di programma “assegnazione”.
Stampa("questo programma rappresenta la determinazione della forza di galleggiamento con l'uso del riferimento cartesiano"); colorepenna(255,255,255);
rifcart; colorepenna(0,0,255); P1=punto(9,8);P2=punto(87/10,77/10); P3=punto(86/10,75/10);segmento(p2,p3); P4=punto(852/100,7);segmento(P3,P4); P5=punto(853/100,38/10); segmento(P4,P5); P6=punto(855/100,31/10); segmento(P5,P6);P7=punto(84/10,28/10); segmento(P6,P7);
P8=punto(821/100,27/10); segmento(P7,P8);P9=punto(8,265/100); segmento(P8,P9);P10=punto(75/10,25/10); segmento(P9,P10); P11=punto(65/10,24/10);
segmento(P10,P11); P12=punto(55/10,25/10); segmento(P11,P12);P13=punto(5,264/100); segmento(P12,P13); P14=punto(475/100,27/10); segmento(P13,P14); P15=punto(46/10,28/10); segmento(P15,P14); P16=punto(445/100,31/10);
segmento(P15,P16); P17=punto(447/100,38/10); segmento(P16,P17); P18=punto(446/100,7);segmento(P17,P18); P19=punto(435/100,75/10); segmento(P18,P19); P20=punto(42/10,775/100); segmento(P19,P20);P21=punto(395/100,8); Z=punto(41/10,78/10);segmento(p21,z); Z1=punto(41/10,83/10);segmento(P21,Z1); Z2=punto(51/10,77/10);segmento(Z,Z2); Z3=punto(6,76/10);segmento(Z3,Z2);
Z4=punto(7,76/10);segmento(Z4,Z3); Z5=punto(8,77/10);segmento(Z4,Z5); Z6=punto(89/10,78/10);segmento(Z5,Z6); segmento(Z6,P1); Z7=punto(877/100,83/10); segmento(P1,Z7);Z8=punto(8,85/10); segmento(Z8,Z7);Z9=punto(7,86/10); segmento(Z9,Z8);Z10=punto(6,86/10); segmento(Z9,Z10);Z11=punto(5,85/10); segmento(Z10,Z11); segmento(Z11,Z1); colorepenna(0,255,255); A2=punto(45/10,7); A3=punto(54/10,68/10); segmento(A3,A2);A4=punto(76/10,68/10); segmento(A4,A3);A5=punto(85/10,7); segmento(A4,A5); coloreriempimento(102,179,255); poligono(A2,A3,A4,A5,P5,P6,P7,P8, P9,P10,P11,P12,P13,P14,P15,P16,P17); colorepenna(0,255,255); A6=punto(45/10,71/10); segmento(A2,A6);A7=punto(54/10,72/10); segmento(A6,A7);A8=punto(76/10,72/10); segmento(A8,A7);A9=punto(85/10,71/10); segmento(A9,A8);segmento(A5,A9); coloreriempimento(53,188,253); poligono(A2,A3,A4,A5,A9,A8,A7,A6);
colorepenna(0,0,255); coloreriempimento(255,255,255); B=punto(42/10,8); B1=punto(51/10,79/10); segmento(B,B1);B2=punto(61/10,78/10); segmento(B2,B1);B3=punto(69/10,78/10); segmento(B2,B3);B4=punto(79/10,79/10); segmento(B3,B4);B5=punto(872/100,8); segmento(B4,B5); B6=punto(86/10,815/100); segmento(B5,B6);B7=punto(79/10,83/10); segmento(B7,B6);B8=punto(69/10,84/10); segmento(B8,B7);B9=punto(58/10,84/10); segmento(B9,B8); B10=punto(48/10,83/10); segmento(B9,B10); B11=punto(43/10,815/100); segmento(B10,B11);segmento(B,B11); D=punto(88/10,8); D1=punto(88/10,77/10); D2=punto(87/10,75/10);segmento(D1,D2);
D3=punto(862/100,7);segmento(D2,D3); D4=punto(863/100,38/10); segmento(D3,D4); D5=punto(865/100,31/10); segmento(D4,D5);D6=punto(85/10,27/10); segmento(D5,D6);D7=punto(82/10,26/10); segmento(D6,D7); D8=punto(79/10,255/100); segmento(D7,D8);D9=punto(75/10,24/10); segmento(D8,D9); D10=punto(65/10,23/10); segmento(D9,D10);
D11=punto(55/10,24/10); segmento(D10,D11); D12=punto(5,254/102); segmento(D11,D12); D13=punto(477/100,26/10); segmento(D12,D13); D14=punto(45/10,27/10); segmento(D13,D14); D15=punto(435/100,3); segmento(D14,D15); D16=punto(437/100,38/10); segmento(D15,D16); D17=punto(436/100,7); segmento(D16,D17); D18=punto(427/100,75/10); segmento(D17,D18); D19=punto(41/10,775/100); segmento(D18,D19);D20=punto(385/10,8); cancella(P1,P2,P3,P4,P5,P6,P7, P8,P9,P10,P11,P12,P13,P14,P15,P16, P17,P18,P19,P20,P21,Z,Z1,Z2,Z3,Z4,Z5, Z6,Z7,Z8,Z9,Z10,Z11,A2,A3,A4,A5,A6,A7, A8,A9); cancella(B,B1,B2,B3,B4,B5,B6,B7,B8,B9, B10,B11,D); cancella(D1,D2,D3,D4,D5,D6,D7,D8,D9, D10,D11,D12,D13,D14,D15,D16,D17,D18,
D19,D20); colorepenna(255,0,0);S=punto(6,6); S1=punto(6,44/10);segmento(S,S1); S2=punto(625/100,425/100); segmento(S1,S2); S3=punto(675/100,425/100); segmento(S2,S3);S4=punto(7,44/10); segmento(S3,S4);S5=punto(7,6); segmento(S4,S5); S6=punto(675/100,595/100); segmento(S5,S6); S7=punto(625/100,595/100); segmento(S6,S7);segmento(S7,S); coloreriempimento(255,0,0); poligono(S,S1,S2,S3,S4,S5,S6,S7); S8=punto(68/10,615/100); segmento(S5,S8); S9=punto(62/10,615/100); segmento(S9,S8);segmento(S9,S); coloreriempimento(223,60,75); poligono(S,S7,S6,S5,S8,S9);
cancella(S,S1,S2,S3,S4,S5,S6,S7,S8,S9); colorepenna(0,0,0);spessorepenna(3); W=punto(65/10,41/10); W1=punto(625/100,39/10); segmento(W,W1); W2=punto(675/100,39/10); segmento(W,W2);segmento(W1,W2); W3=punto(65/10,34/10); segmento(W,W3); coloreriempimento(0,0,0); poligono(W,W1,W2);cancella(W,W1,W2,W3); coloreriempimento(102,179,255);
spessorepenna(1); colorepenna(102,179,255); F2=punto(68/10,38/10); colorepenna(0,0,0); spessorepenna(3);W4=punto(65/10,63/10);W5=punto(625/100,65/10);segmento(W5,W4);W6=punto(675/100,65/10); segmento(W5,W6);segmento(W4,W6); W7=punto(65/10,7);segmento(W4,W7); coloreriempimento(0,0,0); poligono(W4,W5,W6); coloreriempimento(102,179,255); spessorepenna(1); colorepenna(102,179,255); F1=punto(68/10,67/10); cancella(W4;W5,W6,W7);
colorepenna(0,0,0); coloreriempimento(102,179,255); U=punto(52/10,43/10); U1=punto(58/10,43/10); segmento(U,U1);U2=punto(55/10,43/10); U3=punto(55/10,7);segmento(U2,U3); U4=punto(52/10,7);U5=punto(59/10,7); segmento(U4,U5);U6=punto(57/10,6); U7=punto(57/10,7);segmento(U6,U7); U8=punto(56/10,6);u9=punto(58/10,6); segmento(U8,U9); cancella(U,U1,U2,U3,U4,U5,U6,U7,U8,U9);
colorepenna(53,188,253);H2=punto(5,5); colorepenna(0,0,0); H1=punto(55/10,67/10); Y=punto(72/10,43/10); Y1=punto(77/10,43/10); segmento(Y,Y1);Y2=punto(75/10,43/10); Y3=punto(75/10,6); segmento(Y2,Y3);Y4=punto(72/10,6); Y5=punto(77/10,6);segmento(Y4,Y5); cancella(Y,Y1,Y2,Y3,Y4,Y5); colorepenna(53,188,253); H=punto(76/10,55/10);ColorePenna(0,0,0); ColoreRiempimento(255,255,255); A=punto(76/10,71/10);A1=punto(66/10,6); segmento(A,A1);cancella(A1);
AAlluunnnnaa: Cecilia Nicoletti CCllaassssee IIVV BB
PPrrooggrraammmmaa:: “Paese”
Il programma nasce dall’idea di rappresentare un paese, simile per la vivacità dei colori, a Burano. I concetti matematici utilizzati sono: Riferimento Cartesiano, punto, segmento, circonferenza e poligono. Per l’implementazione dell’algoritmo in MatCos è stata utilizzata la struttura di programma “assegnazione”.
Stampa("Questo programma disegna un piccolo paese con l'uso del riferimento cartesiano"); ColorePenna(221,255,255);
coloresfondo(221,255,255); Rifcart;ColorePenna(0,0,0); A=punto(-14,5);B=punto(-10,5); segmento(A,B);
C=punto(-12.8,7.5); D=punto(-11.3,7.5); segmento(C,D); A1=punto(-12.8,8.5); B1=punto(-11.3,8.5); segmento(A1,B1); segmento(A1,C); segmento(B1,D); A2=punto(-13,8.5); B2=punto(-11.1,8.5); A3=punto(-13.5,9); B3=punto(-10.6,9); segmento(A2,A3); segmento(B2,B3); A4=punto(-13,7.5); B4=punto(-11.1,7.5); A5=punto(-13.5,7); B5=punto(-10.6,7); segmento(A3,A5); segmento(A2,A4); segmento(A4,A5); segmento(B4,B5);
segmento(B3,B5); segmento(B2,B3); segmento(B2,B4); C1=punto(-10,9.5); C2=punto(-14,9.5); C3=punto(-12.1,11.5); C4=punto(-14.5,9.5); C5=punto(-9.5,9.5); ColoreRiempimento(255,213,213); poligono(A,B,C1,C2); ColoreRiempimento(255,0,0); poligono(C3,C4,C5); poligono (A3,A2,A4,A5); poligono (B2,B3,B5,B4); ColoreRiempimento(187,244,255); poligono (A1,B1,D,C); segmento(C2,A); segmento(C1,B); D1=punto(-7.5,5.3); D2=punto(-7.5,11); segmento(D1,D2); D3=punto(-8,11); segmento(D2,D3); D4=punto(-6.5,12); D5=punto(-5,11); MotivoRiempimento(1); ColoreRiempimento(0,64,0); poligono(D3,D5,D4); D6=punto(-5.5,11); D7=punto(-5.5,10.4); segmento(D6,D7); segmento(D6,D5); segmento(D3,D5); E=punto(-6,10.4); E1=punto(-6,10); segmento(E,E1); E2=punto(-6.5,10); segmento(E1,E2); E3=punto(-6.5,9.8); segmento(E2,E3); E4=punto(-6,9.8); segmento(E3,E4); E5=punto(-6,5); segmento(E4,E5); E6=punto(-4,4.6);
E7=punto(-4,8.5); segmento(E6,E7); E8= punto (-4,8.8); E9= punto O(-4,9.8); ColoreRiempimento(225,255,225); poligono(D1,E5,E4,E3,E2,E1,E,D7, D6,D2); segmento (E8,E9); F= punto (-3.5,9.8); segmento (E9,F); segmento (E3,F); F1= punto (-3.5,10); segmento (E2,F1); segmento (F,F1); F2= punto (-4,10); segmento (F1,F2); F3= punto (-4,10.4); ColoreRiempimento(130,192,255); poligono(e,E1,F2,F3); poligono(E2,E3,F,F1); segmento (F3,F2); segmento (F3,E); G= punto (-6.8,10.6); G1= punto (-6.4,10.6); segmento (G,G1); G2= punto (-6.4,10); segmento (G1,G2); G3= punto (-6.4,9.8); G4= punto (-6.4,9.3); segmento (G3,G4); G5= punto (-6.8,9.3); ColoreRiempimento(187,244,255);
poligono(G,G1,G2,E2,E3,G3,G4,G5); segmento (G4,G5); segmento (G,G5); G6= punto (-6.8,9); G7= punto (-6.4,9); G8= punto (-6.4,8.2); G9= punto (-6.8,8.2); poligono(G6,G7,G8,G9); H= punto (-5.4,9); H1= punto (-4.6,9); H2= punto (-5.4,7.8); H3= punto (-4.6,7.8); ColoreRiempimento(187,244,255); poligono(H,H1,H3,H2);
H4= punto (-4.25,9.3); H5= punto(-5.8,9.3); segmento (H,H5); segmento (H1,H4); H6= punto (-4.25,7.5); segmento (H4,H6); segmento (H6,H3); H7= punto (-5.8,7.5); segmento (H2,H7); segmento (H5,H7); ColoreRiempimento(130,192,255); poligono (H5,H,H2,H7); poligono(H1,H4,H6,H3); I= punto (-0.5,4.6); segmento (E6,I); I2= punto (-0.5,8.5); segmento(I,I2); segmento (E7,I2); I3= punto (0,8.5); ColoreRiempimento(255,217,236); poligono(E7,E6,I,I2); segmento (I2,I3); I4= punto (-4.5,8.5); segmento (I4,E7); I5= punto (-2.2,10); segmento (I3,I5); segmento (I5,I4); I6= punto (-1,9.2); ColoreRiempimento(255, 0,128); poligono(I3,I4,I5); I7= punto (-1,12.2); Segmento (I6,I7); I8= punto (-3,12.2); segmento (I7,I8); I9= punto (-3,9.5); Segmento (I8,I9); ColoreRiempimento(255,215,174); Poligono(I8,I9,I5,I6,I7); L=punto(-2,13.5); ColoreRiempimento(255,255,128); L1= punto (-2,11.5); Circ (L1,0.5);
L2=Punto (-0.5,12.2); ColoreRiempimento(255,128,0); segmento(L2,I7);L3= punto (-3.5,12.2); poligono(L3,L2,L); segmento (L,L3); segmento (I8,L3); L4= punto (-4.7,10.4); L5= punto (-4.7,12.5); segmento (L4,L5); L6= punto (-5,12.5); segmento (L5,L6); L7= punto (-3.2,12.5); segmento (L5,L7); L8= punto (-3,12.6); L9= punto (-3.9,13.5); ColoreRiempimento(255,255,215); poligono(L5,L7,L3,I8,I9,E8,E9,F,F1, F2,F3,L4); ColoreRiempimento(0,0,255); poligono(L6,L7,L8,L9); M= punto (-4.25,12); M1= punto (-3.5,12); segmento (M,M1); M2= punto (-3.5,11); segmento (M1,M2); M3= punto (-4.25,11); segmento (M2,M3); segmento (M,M3); W=punto(-3.85,11.5);
M4= punto (-3.85,12); M5= punto (-3.85,11); segmento (M4,M5); M6= punto (-4.25,11.5); M7= punto (-3.5,11.5); ColoreRiempimento(187,244,255); poligono(M,M4,W,M6); poligono(M6,W,M5,M3); poligono(M4,M1,M7,W); poligono(W,M7,M2,M5); segmento (M6,M7); N= punto (-1,5.8); N1= punto (-3.5,5.8);
segmento (N,N1); N2= punto (-1,6.5); segmento (N,N2); N3= punto (-3.5,6.5); segmento (N2,N3); segmento (N3,N1); ColoreRiempimento(0,0,0); MotivoRiempimento(4); poligono (N,N1,N3,N2); N4= punto (-3.5,8.4); segmento (N3,N4); N5= punto (-3,8); segmento (N4,N5); N6= punto (-3,6.5); segmento (N5,N6); N7= punto (-2.9,8); N8= punto (-2.9,6.5); segmento (N7,N8); O= punto (-2.25,8); O1= punto (-2.25,6.5); segmento (O,O1); O2= punto (-1.65,8); O3= punto (-1.65,6.5); segmento (O2,O3); segmento (O2,N7); O4= punto (-1.5,8); O5= punto (-1.5,6.5); segmento (O4,O5); O6= punto (-1,8.4); segmento (O6,N2); segmento (O4,O6); MotivoRiempimento(1); ColoreRiempimento(255,0,128); poligono(N3,N4,N5,N6); poligono(O4,O5,N2,O6); ColoreRiempimento(187,244,255); poligono(N7,O,O1,N8); poligono(O,O2,O3,O1);
P=punto(-0.8,11.2); P1=punto(2.8,8); segmento(P,P1); P2=punto(-1,11); segmento(P,P2); P3=punto(-0.5,8); segmento(P1,P3); ColoreRiempimento(128,255,128); poligono(P2,P,P1,P3,I2,I3,I6); P4=punto(2,8); P5=punto(2,4); segmento(P4,P5); P6=punto(0.2,7.5); P7=punto(1.2,7.5); P8=punto(1.2,6.5); P9=punto(0.2,6.5); W1=punto(-0.5,4.3); segmento(P5,W1); segmento(P3,W1); MotivoRiempimento(2); poligono(P6,P7,P8,P9); Q=punto(0.7,7.5); Q1=punto(0.7,6.5); segmento(Q,Q1); Q2=punto(1.2,7); Q3=Punto(0.2,7); J6=Punto(0.7,7); ColoreRiempimento(187,244,255); poligono(P6,Q,J6,Q3); poligono(Q,P7,Q2,J6); poligono(Q2,P8,Q1,J6); poligono(Q3,J6,Q1,P9);
segmento(Q2,Q3); Q4=punto(2,7.5); Q5=punto(5,7.5); Q6=punto(6,6.5); Q7=punto(2,6.5); ColoreRiempimento(255,164,209); poligono(Q4,Q5,Q6,Q7); Q8=punto(2,5.5); Q9=punto(6,5.5); ColoreRiempimento(223,223,223); poligono(Q6,Q7,Q8,Q9); R=punto(12,5.5); R1=punto(12,4); MotivoRiempimento(1); ColoreRiempimento(174,94,94); poligono(Q8,R,R1,P5);
ColoreRiempimento(0,0,0); MotivoRiempimento(7); poligono(Q8,R,R1,P5); R2=punto(6,10.5); MotivoRiempimento(2); R3=punto(6.5,10.5); R4=punto(8.5,10.5); R5=punto(9,10.5); R6=punto(7.5,12); ColoreRiempimento(255,0,255); poligono(R2,R5,R6); R7=punto(6.5,5.5); segmento(R7,R3); R8=punto(8.5,7.5); segmento(R4,R8); S=punto(7,6); S1=punto(10,6); poligono(R8,S1,S); S2=punto(9.5,6); S3=punto(7.5,6); S4=punto(9.5,5.5);S5=punto(7.5,5.5); ColoreRiempimento(255,221,255); poligono(R3,R4,R8,S,S3,S5,R7); segmento(S2,S4); segmento(S3,S5); S6=punto(8.5,9.5); S7=punto(10.5,8.5); S8=punto(8.5,8.5); poligono(S3,S2,S4,S5); ColoreRiempimento(128,0,255); poligono(S6,S7,S8); S9=punto(10,8.5); ColoreRiempimento(233,210,255); poligono(S8,R8,S1,S9); segmento(S1,S9); T=punto(10,7.5); T1=punto(11,7.5); T2=punto(11.5,6.7); T3=punto(10,6.7); ColoreRiempimento(0,128,0); poligono(T,T1,T2,T3); T4=punto(11.5,6);
ColoreRiempimento(215,255,215); Poligono(T3,T2,T4,S1); T5=punto(12,3.5); T6=punto(8.5,3.5); T7=punto(8.5,2.5); T8=punto(12,2.5); poligono(T5,T6,T7,T8); RENTO=punto(9,3.5);U=punto(9,2.5); U1=punto(9,0.5);U2=punto(8.8,2.5); U3=punto(8.8,0.5); segmento(U2,U3); segmento(U,U1); U4=punto(11.4,2.5); U5=punto(11.6,2.5); U6=punto(11.4,0.5); U7=punto(11.6,0.5); segmento(U4,U6); segmento(U5,U7); V=punto(9,15); ColoreRiempimento(255,255,0); ColorePenna(255,128,0); circ(V,1.2);MotivoRiempimento(2); ColorePenna(0,0,0); V1=punto(7,9); V2=punto(8,9); segmento(V1,V2); V3= punto (8,9.8); V4=punto(7,9.8); V5=punto(7.8,10); V6=punto(7.2,10); segmento(V3,V2); segmento (V1,V4); segmento(V3,V5); segmento (V6,V4);
segmento(V6,V5); Z=punto(7,7.5); Z1=punto(8,7.5); Z2=punto(8,8.2); Z3=punto(7.8,8.5); Z4=punto(7.2,8.5); Z5=punto(7,8.2); poligono(Z,Z1,Z2,Z3,Z4,Z5); ColoreRiempimento(187,244,255); poligono(V4,V6,V5,V3,V2,V1); poligono(Z,Z1,Z2,Z3,Z4,Z5); Y=punto(-10,5.8); segmento(Y,D1); segmento(D1,E5); segmento(E5,E6); Y1=punto(-7.5,4.2);K=punto(-12,5); segmento(K,Y1); Y2=punto(-6,3.9);
segmento(Y1,Y2); Y3=punto(-4,3.6); segmento(Y2,Y3); Y4=punto(2,2.7); segmento(Y3,Y4); Y5=punto(8.8,1.9); segmento(Y4,Y5); Y6=punto(2,3.8); segmento(E6,Y6); Y7=punto(8.5,3); segmento(Y6,Y7); ColoreRiempimento(201,201,201); poligono(K,Y1,Y2,Y3,Y4,Y5,U2,T7,Y7,Y6,E6,E5,D1,Y,B); ColorePenna(255,128,0); K1=punto(10.5,15); K2=punto(7.5,15); K3=punto(9,16.5); K4=punto(9,13.5); K5=punto(11.5,15); segmento(K1,K5); K6=punto(6.5,15); segmento(K2,K6); K7=punto(9,17.5); segmento(K3,K7); K8=punto(9,12.5); segmento(K4,K8); K9=punto(10,16); K10=punto(10,14); X=punto(7.9,14); X1=punto(7.9,16); X2=punto(10.5,16.5);segmento(K9,X2); X3=punto(10.5,13.5); segmento(K10,X3); X4=punto(7.4,16.5); segmento(X1,X4); X5=punto(7.4,13.5); segmento(X,X5); ColorePenna(0,0,0); W3=punto(-16,6);
W4=punto(16,5.5); W5=punto(-14,6); W6=Punto(-16,0); W7=punto(16,0); ColoreRiempimento(0,159,80); poligono(W6,W3,W5,A,K,Y1,Y2,Y3,Y4,Y5,U3,U1,U,U4,U6,U7,U5,T8,T5,T6,Y7,Y6,E6,I,W1,P5,R1,R,W4,W7); W8=punto(-7.5,5.8); poligono(Y,D1,W8); J=punto(9,1.9); J1=punto(11.4,1.7); segmento(J,J1); J2=punto(12,2.7); J3=punto(11.6,1.7); J4=punto(16,1.3); segmento(J3,J4); J5=punto(16,2.5); segmento(J2,J5);
ColoreRiempimento(201,201,201); poligono(J,U,U4,J1); poligono(J3,U5,T8,J2,J5,J4); Cancella (A,B,C,D,A1,B1,A2,B2,A3,B3,A4,B4, A5,B5,C1,C2,C3,C4,C5,D1,D2,D3,D4, D5,D6,D7,E,E1,E2,E3,E4,E5,E6,E7,E8, E9,F,F1,F2,F3, G,G1,G2, G3,G4,G5, G6,G7,G8,G9,H, H1,H2,H3,H4,H5, H6,H7,I,I2, I3,I4,I5,I6,I7,I8,I9,L,L1, L2,L3,L4,L5,L6,L7,L8,L9,M,M1,M2, M3,M4,M5,M6,M7,N,N1,N2,N3,N4,N5,N6, N7,N8,O,O1,O2,O3,O4,O5,O6,P,P1,P2,P3,P4,P5,P6,P7,P8,P9,Q,Q1,Q2,Q3,Q4,Q5,Q6,Q7,Q8,Q9,R,R1,R2,R3,R4,R5,R6,R7,R8,S,S1,S2,S3,S4,S5,S6,S7,S8,S9,T,T1,T2,T3,T4,T5,T6,T7,T8,U,U1,U2,U3,U4,U5,U6,U7,V,V1,V2, V3,V4,V5,V6,Z,Z1,Z2,Z3,Z4,Z5,Y,Y1,Y2,Y3,Y4,Y5,Y6,Y7,K,K1,K2,K3,k4,K5,K6,K7,K8,k9,K10,X,X1,X2,X3,X4,X5,W,W1,W3,W4,W5,W6,W7,W8,J,J1,J2, J3,J4,J5,J6);
L’utilizzo del MatCos mi ha permesso di costruire percorsi didattici attinenti allo studio della geometria analitica in modo semplice e chiaro. E’ un ambiente di programmazione dove lo studente opera in modo naturale, con entusiasmo e soddisfazione, poiché di facile comprensione. Pertanto l’utilizzo di MatCos consente un insegnamento più fruibile, esauriente e completo, quindi un apprendimento diretto e consapevole dei contenuti trattati.
LLiicceeoo CCllaassssiiccoo SSttaattaallee ““GG.. ddaa FFiioorree”” RReennddee ((CCSS))
DDiirriiggeennttee SSccoollaassttiiccoo: Vincenzo Ferraro
DDoocceennttee ssppeerriimmeennttaattoorree: Lucia Garritano AAlluunnnnii: Elisabetta Benevento, Anna Carbone, Silvia Catalano,
Martina De Giacomo, Maria Grazia Macchione
CCllaassssee VV AA
PPrrooggrraammmmaa:: “Omotetie”
Il programma nasce dall’idea di voler coniugare le conoscenze matematiche con le competenze informatiche. I concetti matematici utilizzati nell’ambito della costruzione di figure geometriche sono: perpendicolarità, omotetia. Per l’implementazione dell’algoritmo in MatCos è stata utilizzata, come struttura di controllo, quella di ciclo iterativo, all’interno del quale, il rapporto di omotetia viene fornito dalla stessa variabile di controllo. Il colore di riempimento della figura è inserito, anch’esso, all’interno di un ciclo.
ColoreSfondo (255,247,187); t = Punto; r = 100; c1 = circ(t,r); a = punto_su(c1); r1 = retta(a,t); c = intersezione(c1,r1); r2 = perpendicolare(r1,t); B = intersezione(c1,r2); d = intersezione(c1,r2); p = poligono(a,b,c,d); Stampa (“ Costruzione quadrato inscritto” );
l1 = distanza(a,b); l2 = distanza(b,c); stampa(“ Lato AB = “ , l1); stampa(“ Lato BC = “ , l2); cancella(r1,r2); o = punto; Cancella(a,b,c,d, t); per (n da 1 a 5) esegui; p1=omotetia(c1,o,1/n); pausa (300); FINE; per (n da 1 a 5) esegui; ColoreRiempimento(147,250,255); p2 = omotetia (p,o,1/n); pausa (300); FINE;
L’utilizzo del MatCos mi ha permesso di costruire percorsi didattici ed innovazioni didattiche, atte a potenziare nello studente lo sviluppo dell’intuizione, della creatività e della scoperta. Si perviene alla soluzione di una data questione con la costruzione di un algoritmo, processo che favorisce il ragionamento logico. L’insegnamento non è finalizzato alla sola conoscenza strumentale, all’apprendimento meccanico di teoremi e applicazioni, bensì alla conoscenza relazionale. Nella trattazione delle trasformazioni geometriche, ad esempio, l’uso di MatCos, fa sì che queste possano configurarsi non come obiettivo contenutistico da raggiungere, bensì come stimolo per attivare il registro figurativo-dimostrativo,
comprendere i processi e collegare le informazioni. MatCos si configura, dunque, per l’allievo, come una palestra di studio creativo e consapevole.
II..PP..SS..SS..AA..RR.. LLooccrrii ((RRCC))
DDiirriiggeennttee SSccoollaassttiiccoo: Maria Macrì
DDoocceennttee ssppeerriimmeennttaattoorree: Carla Maria Pelaggi
AAlluunnnnii: Antonio Caridi, Giacomo Cuscunà CCllaassssee VV°°CC//TTSSRR
PPrrooggrraammmmaa:: “Formula di struttura del D-Glucosio”
Il programma nasce da un’idea, a carattere interdisciplinare, che faccia da collegamento tra la matematica e le discipline di settore. Trattandosi di una corso per tecnici della ristorazione, si è pensato di far riferimento alle scienze dell’alimentazione, con particolare riguardo agli approfondimenti di questa disciplina, quale è appunto la chimica. I concetti matematici utilizzati sono il riferimento cartesiano nello spazio, il punto ed il segmento. Per l’implementazione dell’algoritmo in MatCos sono state utilizzate le seguenti strutture di programma: commento, assegnazione, stampa.
ColorePenna (255,255,255); ColoreSfondo(0,0,0); RifCart3D; /*colore rosso: indica l'elemento carbonio che forma la catena carboniosa*/ ColorePenna(255,0,0); A=PUNTO3D(1,0,0); B=PUNTO3D(2,0,0); C=PUNTO3D(3,0,0); D=PUNTO3D(4,0,0); E=PUNTO3D(5,0,0); F=PUNTO3D(6,0,0); O=PUNTO3D(0,0,1); P=PUNTO3D(0,0,2);
Q=PUNTO3D(0,0,3); R=PUNTO3D(0,0,4); S=PUNTO3D(0,0,5); T=PUNTO3D(0,0,6); A1=PUNTO3D(-1,0,0); B1=PUNTO3D(-2,0,0); C1=PUNTO3D(-3,0,0); D1=PUNTO3D(-4,0,0); E1=PUNTO3D(-5,0,0); F1=PUNTO3D(-6,0,0); O1=PUNTO3D(0,0,-1); P1=PUNTO3D(0,0,-2); Q1=PUNTO3D(0,0,-3); R1=PUNTO3D(0,0,-4); S1=PUNTO3D(0,0,-5); T1=PUNTO3D(0,0,-6); Segmento3D(T,A); Segmento3D(S,B); Segmento3D(R,C); Segmento3D(Q,D); Segmento3D(P,E); Segmento3D(O,F);
Segmento3D(T,A1); Segmento3D(S,B1); Segmento3D(R,C1); Segmento3D(Q,D1); Segmento3D(P,E1); Segmento3D(O,F1); Segmento3D(T1,A); Segmento3D(S1,B); Segmento3D(R1,C); Segmento3D(Q1,D); Segmento3D(P1,E); Segmento3D(O1,F); Segmento3D(T1,A1); Segmento3D(S1,B1); Segmento3D(R1,C1); Segmento3D(Q1,D1); Segmento3D(P1,E1);
Segmento3D(O1,F1); Segmento3D(F,F1); Segmento3D(T,T1); A=PUNTO3D(1,0,12); B=PUNTO3D(2,0,12); C=PUNTO3D(3,0,12); D=PUNTO3D(4,0,12); E=PUNTO3D(5,0,12); F=PUNTO3D(6,0,12); O=PUNTO3D(0,0,6); P=PUNTO3D(0,0,7); Q=PUNTO3D(0,0,8); R=PUNTO3D(0,0,9); S=PUNTO3D(0,0,10); T=PUNTO3D(0,0,11); A1=PUNTO3D(-1,0,12); B1=PUNTO3D(-2,0,12); C1=PUNTO3D(-3,0,12); D1=PUNTO3D(-4,0,12); E1=PUNTO3D(-5,0,12); F1=PUNTO3D(-6,0,12); O1=PUNTO3D(0,0,13);
P1=PUNTO3D(0,0,14); Q1=PUNTO3D(0,0,15); R1=PUNTO3D(0,0,16); S1=PUNTO3D(0,0,17); T1=PUNTO3D(0,0,18); Segmento3D(T,f); Segmento3D(S,e); Segmento3D(R,d); Segmento3D(Q,c); Segmento3D(P,b); Segmento3D(O,a); Segmento3D(T,f1); Segmento3D(S,e1); Segmento3D(R,d1); Segmento3D(Q,c1); Segmento3D(P,b1); Segmento3D(O,a1);
Segmento3D(T1,A); Segmento3D(S1,B); Segmento3D(R1,C); Segmento3D(Q1,D); Segmento3D(P1,E); Segmento3D(O1,F); Segmento3D(T1,A1); Segmento3D(S1,B1); Segmento3D(R1,C1); Segmento3D(Q1,D1); Segmento3D(P1,E1); Segmento3D(O1,F1); Segmento3D(F,F1); Segmento3D(o,T1); A=PUNTO3D(1,0,24); B=PUNTO3D(2,0,24); C=PUNTO3D(3,0,24); D=PUNTO3D(4,0,24); E=PUNTO3D(5,0,24); F=PUNTO3D(6,0,24); O=PUNTO3D(0,0,18); P=PUNTO3D(0,0,19);
Q=PUNTO3D(0,0,20); R=PUNTO3D(0,0,21); S=PUNTO3D(0,0,22); T=PUNTO3D(0,0,23); A1=PUNTO3D(-1,0,24); B1=PUNTO3D(-2,0,24); C1=PUNTO3D(-3,0,24); D1=PUNTO3D(-4,0,24); E1=PUNTO3D(-5,0,24); F1=PUNTO3D(-6,0,24); O1=PUNTO3D(0,0,25); P1=PUNTO3D(0,0,26);
Q1=PUNTO3D(0,0,27); R1=PUNTO3D(0,0,28); S1=PUNTO3D(0,0,29); T1=PUNTO3D(0,0,30); Segmento3D(T,f); Segmento3D(S,e); Segmento3D(R,d); Segmento3D(Q,c); Segmento3D(P,b); Segmento3D(O,a); Segmento3D(T,f1); Segmento3D(S,e1); Segmento3D(R,d1); Segmento3D(Q,c1); Segmento3D(P,b1); Segmento3D(O,a1); Segmento3D(T1,A); Segmento3D(S1,B); Segmento3D(R1,C); Segmento3D(Q1,D); Segmento3D(P1,E); Segmento3D(O1,F); Segmento3D(T1,A1); Segmento3D(S1,B1); Segmento3D(R1,C1); Segmento3D(Q1,D1); Segmento3D(P1,E1);
Segmento3D(O1,F1); Segmento3D(F,F1); Segmento3D(o,T1); A=PUNTO3D(1,0,-12); B=PUNTO3D(2,0,-12); C=PUNTO3D(3,0,-12); D=PUNTO3D(4,0,-12); E=PUNTO3D(5,0,-12); F=PUNTO3D(6,0,-12); O=PUNTO3D(0,0,-6); P=PUNTO3D(0,0,-7); Q=PUNTO3D(0,0,-8); R=PUNTO3D(0,0,-9); S=PUNTO3D(0,0,-10); T=PUNTO3D(0,0,-11); A1=PUNTO3D(-1,0,-12); B1=PUNTO3D(-2,0,-12); C1=PUNTO3D(-3,0,-12); D1=PUNTO3D(-4,0,-12); E1=PUNTO3D(-5,0,-12); F1=PUNTO3D(-6,0,-12);
O1=PUNTO3D(0,0,-13); P1=PUNTO3D(0,0,-14); Q1=PUNTO3D(0,0,-15); R1=PUNTO3D(0,0,-16); S1=PUNTO3D(0,0,-17); T1=PUNTO3D(0,0,-18); Segmento3D(T,f); Segmento3D(S,e); Segmento3D(R,d); Segmento3D(Q,c); Segmento3D(P,b); Segmento3D(O,a);
Segmento3D(T,f1); Segmento3D(S,e1); Segmento3D(R,d1); Segmento3D(Q,c1); Segmento3D(P,b1); Segmento3D(O,a1); Segmento3D(T1,A); Segmento3D(S1,B); Segmento3D(R1,C); Segmento3D(Q1,D); Segmento3D(P1,E); Segmento3D(O1,F); Segmento3D(T1,A1); Segmento3D(S1,B1); Segmento3D(R1,C1); Segmento3D(Q1,D1); Segmento3D(P1,E1); Segmento3D(O1,F1); Segmento3D(F,F1); Segmento3D(o,T1); A=PUNTO3D(1,0,-24); B=PUNTO3D(2,0,-24); C=PUNTO3D(3,0,-24); D=PUNTO3D(4,0,-24); E=PUNTO3D(5,0,-24); F=PUNTO3D(6,0,-24); O=PUNTO3D(0,0,-18);
P=PUNTO3D(0,0,-19); Q=PUNTO3D(0,0,-20); R=PUNTO3D(0,0,-21); S=PUNTO3D(0,0,-22); T=PUNTO3D(0,0,-23); A1=PUNTO3D(-1,0,-24); B1=PUNTO3D(-2,0,-24); C1=PUNTO3D(-3,0,-24); D1=PUNTO3D(-4,0,-24); E1=PUNTO3D(-5,0,-24); F1=PUNTO3D(-6,0,-24); O1=PUNTO3D(0,0,-25); P1=PUNTO3D(0,0,-26); Q1=PUNTO3D(0,0,-27); R1=PUNTO3D(0,0,-28); S1=PUNTO3D(0,0,-29); T1=PUNTO3D(0,0,-30); Segmento3D(T,f); Segmento3D(S,e); Segmento3D(R,d); Segmento3D(Q,c);
Segmento3D(P,b); Segmento3D(O,a); Segmento3D(T,f1); Segmento3D(S,e1); Segmento3D(R,d1); Segmento3D(Q,c1); Segmento3D(P,b1); Segmento3D(O,a1); Segmento3D(T1,A); Segmento3D(S1,B); Segmento3D(R1,C); Segmento3D(Q1,D);
Segmento3D(P1,E); Segmento3D(O1,F); Segmento3D(T1,A1); Segmento3D(S1,B1); Segmento3D(R1,C1); Segmento3D(Q1,D1); Segmento3D(P1,E1); Segmento3D(O1,F1); Segmento3D(F,F1); Segmento3D(o,T1); A=PUNTO3D(1,0,-36); B=PUNTO3D(2,0,-36); C=PUNTO3D(3,0,-36); D=PUNTO3D(4,0,-36); E=PUNTO3D(5,0,-36); F=PUNTO3D(6,0,-36); O=PUNTO3D(0,0,-30); P=PUNTO3D(0,0,-31); Q=PUNTO3D(0,0,-32); R=PUNTO3D(0,0,-33); S=PUNTO3D(0,0,-34); T=PUNTO3D(0,0,-35); A1=PUNTO3D(-1,0,-36); B1=PUNTO3D(-2,0,-36); C1=PUNTO3D(-3,0,-36); D1=PUNTO3D(-4,0,-36); E1=PUNTO3D(-5,0,-36);
F1=PUNTO3D(-6,0,-36); O1=PUNTO3D(0,0,-37); P1=PUNTO3D(0,0,-38); Q1=PUNTO3D(0,0,-39); R1=PUNTO3D(0,0,-40); S1=PUNTO3D(0,0,-41); T1=PUNTO3D(0,0,-42); Segmento3D(T,f); Segmento3D(S,e); Segmento3D(R,d); Segmento3D(Q,c); Segmento3D(P,b); Segmento3D(O,a); Segmento3D(T,f1); Segmento3D(S,e1); Segmento3D(R,d1); Segmento3D(Q,c1); Segmento3D(P,b1); Segmento3D(O,a1); Segmento3D(T1,A); Segmento3D(S1,B);
Segmento3D(R1,C); Segmento3D(Q1,D); Segmento3D(P1,E); Segmento3D(O1,F); Segmento3D(T1,A1); Segmento3D(S1,B1); Segmento3D(R1,C1); Segmento3D(Q1,D1); Segmento3D(P1,E1); Segmento3D(O1,F1); Segmento3D(F,F1); Segmento3D(o,T1);
/*colore blu: indica l'elemento idrogeno legato alla catena carboniosa*/ ColorePenna(0,0,255); A=PUNTO3D(6,0,0); B=PUNTO3D(7,0,0); C=PUNTO3D(8,0,0); D=PUNTO3D(9,0,0); E=PUNTO3D(10,0,0); F=PUNTO3D(11,0,0); O=PUNTO3D(12,0,1); P=PUNTO3D(12,0,2); Q=PUNTO3D(12,0,3); R=PUNTO3D(12,0,4); S=PUNTO3D(12,0,5); T=PUNTO3D(12,0,6); A1=PUNTO3D(13,0,0); B1=PUNTO3D(14,0,0); C1=PUNTO3D(15,0,0); D1=PUNTO3D(16,0,0); E1=PUNTO3D(17,0,0); F1=PUNTO3D(18,0,0); O1=PUNTO3D(12,0,-1); P1=PUNTO3D(12,0,-2); Q1=PUNTO3D(12,0,-3); R1=PUNTO3D(12,0,-4); S1=PUNTO3D(12,0,-5);
T1=PUNTO3D(12,0,-6); Segmento3D(T,f); Segmento3D(S,e); Segmento3D(R,d); Segmento3D(Q,c); Segmento3D(P,b); Segmento3D(O,a); Segmento3D(T,A1); Segmento3D(S,B1); Segmento3D(R,C1); Segmento3D(Q,D1); Segmento3D(P,E1); Segmento3D(O,F1); Segmento3D(T1,f); Segmento3D(S1,e); Segmento3D(R1,d); Segmento3D(Q1,c); Segmento3D(P1,b); Segmento3D(O1,a); Segmento3D(T1,A1); Segmento3D(S1,B1);
Segmento3D(R1,C1); Segmento3D(Q1,D1); Segmento3D(P1,E1); Segmento3D(O1,F1); Segmento3D(a,F1); Segmento3D(T,T1); /*colore giallo: indica il gruppo ossidrile legato sia alla catena carboniosa che all’elemento idrogeno*/ ColorePenna(255,255,0); A=PUNTO3D(-6,0,0);
B=PUNTO3D(-7,0,0); C=PUNTO3D(-8,0,0); D=PUNTO3D(-9,0,0); E=PUNTO3D(-10,0,0); F=PUNTO3D(-11,0,0); O=PUNTO3D(-12,0,1); P=PUNTO3D(-12,0,2); Q=PUNTO3D(-12,0,3); R=PUNTO3D(-12,0,4); S=PUNTO3D(-12,0,5); T=PUNTO3D(-12,0,6); A1=PUNTO3D(-13,0,0); B1=PUNTO3D(-14,0,0); C1=PUNTO3D(-15,0,0); D1=PUNTO3D(-16,0,0); E1=PUNTO3D(-17,0,0); F1=PUNTO3D(-18,0,0); O1=PUNTO3D(-12,0,-1); P1=PUNTO3D(-12,0,-2); Q1=PUNTO3D(-12,0,-3); R1=PUNTO3D(-12,0,-4); S1=PUNTO3D(-12,0,-5); T1=PUNTO3D(-12,0,-6); Segmento3D(T,f); Segmento3D(S,e); Segmento3D(R,d); Segmento3D(Q,c);
Segmento3D(P,b); Segmento3D(O,a); Segmento3D(T,A1); Segmento3D(S,B1); Segmento3D(R,C1); Segmento3D(Q,D1); Segmento3D(P,E1); Segmento3D(O,F1); Segmento3D(T1,f); Segmento3D(S1,e); Segmento3D(R1,d); Segmento3D(Q1,c); Segmento3D(P1,b); Segmento3D(O1,a); Segmento3D(T1,A1); Segmento3D(S1,B1); Segmento3D(R1,C1); Segmento3D(Q1,D1); Segmento3D(P1,E1); Segmento3D(O1,F1); Segmento3D(a,F1);
Segmento3D(T,T1); ColorePenna(0,0,255); A=PUNTO3D(-6,0,12); B=PUNTO3D(-7,0,12); C=PUNTO3D(-8,0,12); D=PUNTO3D(-9,0,12); E=PUNTO3D(-10,0,12); F=PUNTO3D(-11,0,12); O=PUNTO3D(-12,0,6); P=PUNTO3D(-12,0,7); Q=PUNTO3D(-12,0,8); R=PUNTO3D(-12,0,9);
S=PUNTO3D(-12,0,10); T=PUNTO3D(-12,0,11); A1=PUNTO3D(-18,0,12); B1=PUNTO3D(-17,0,12); C1=PUNTO3D(-16,0,12); D1=PUNTO3D(-15,0,12); E1=PUNTO3D(-14,0,12); F1=PUNTO3D(-13,0,12); O1=PUNTO3D(-12,0,13); P1=PUNTO3D(-12,0,14); Q1=PUNTO3D(-12,0,15); R1=PUNTO3D(-12,0,16); S1=PUNTO3D(-12,0,17); T1=PUNTO3D(-12,0,18); Segmento3D(T,a); Segmento3D(S,b); Segmento3D(R,c); Segmento3D(Q,d); Segmento3D(P,e); Segmento3D(O,f); Segmento3D(T,A1); Segmento3D(S,B1); Segmento3D(R,C1); Segmento3D(Q,D1); Segmento3D(P,E1); Segmento3D(O,F1); Segmento3D(T1,f);
Segmento3D(S1,e); Segmento3D(R1,d); Segmento3D(Q1,c); Segmento3D(P1,b); Segmento3D(O1,a); Segmento3D(T1,f1); Segmento3D(S1,e1); Segmento3D(R1,d1); Segmento3D(Q1,c1); Segmento3D(P1,b1); Segmento3D(O1,a1); Segmento3D(a,a1); Segmento3D(o,T1); ColorePenna(255,255,0); A=PUNTO3D(6,0,12); B=PUNTO3D(7,0,12); C=PUNTO3D(8,0,12); D=PUNTO3D(9,0,12); E=PUNTO3D(10,0,12); F=PUNTO3D(11,0,12); O=PUNTO3D(12,0,6);
P=PUNTO3D(12,0,7); Q=PUNTO3D(12,0,8); R=PUNTO3D(12,0,9); S=PUNTO3D(12,0,10); T=PUNTO3D(12,0,11); A1=PUNTO3D(18,0,12); B1=PUNTO3D(17,0,12); C1=PUNTO3D(16,0,12); D1=PUNTO3D(15,0,12); E1=PUNTO3D(14,0,12); F1=PUNTO3D(13,0,12); O1=PUNTO3D(12,0,13);
P1=PUNTO3D(12,0,14); Q1=PUNTO3D(12,0,15); R1=PUNTO3D(12,0,16); S1=PUNTO3D(12,0,17); T1=PUNTO3D(12,0,18); Segmento3D(T,a); Segmento3D(S,b); Segmento3D(R,c); Segmento3D(Q,d); Segmento3D(P,e); Segmento3D(O,f); Segmento3D(T,A1); Segmento3D(S,B1); Segmento3D(R,C1); Segmento3D(Q,D1); Segmento3D(P,E1); Segmento3D(O,F1); Segmento3D(T1,f); Segmento3D(S1,e); Segmento3D(R1,d); Segmento3D(Q1,c); Segmento3D(P1,b); Segmento3D(O1,a); Segmento3D(T1,f1); Segmento3D(S1,e1); Segmento3D(R1,d1); Segmento3D(Q1,c1);
Segmento3D(P1,b1); Segmento3D(O1,a1); Segmento3D(a,a1); Segmento3D(o,T1); A=PUNTO3D(6,0,-12); B=PUNTO3D(7,0,-12); C=PUNTO3D(8,0,-12); D=PUNTO3D(9,0,-12); E=PUNTO3D(10,0,-12); F=PUNTO3D(11,0,-12); O=PUNTO3D(12,0,-18); P=PUNTO3D(12,0,-17); Q=PUNTO3D(12,0,-16); R=PUNTO3D(12,0,-15); S=PUNTO3D(12,0,-14); T=PUNTO3D(12,0,-13); A1=PUNTO3D(13,0,-12); B1=PUNTO3D(14,0,-12); C1=PUNTO3D(15,0,-12); D1=PUNTO3D(16,0,-12); E1=PUNTO3D(17,0,-12);
F1=PUNTO3D(18,0,-12); O1=PUNTO3D(12,0,-11); P1=PUNTO3D(12,0,-10); Q1=PUNTO3D(12,0,-9); R1=PUNTO3D(12,0,-8); S1=PUNTO3D(12,0,-7); T1=PUNTO3D(12,0,-6); Segmento3D(T,a); Segmento3D(S,b); Segmento3D(R,c); Segmento3D(Q,d); Segmento3D(P,e);
Segmento3D(O,f); Segmento3D(T1,A1); Segmento3D(S1,B1); Segmento3D(R1,C1); Segmento3D(Q1,D1); Segmento3D(P1,E1); Segmento3D(O1,F1); Segmento3D(T1,f); Segmento3D(S1,e); Segmento3D(R1,d); Segmento3D(Q1,c); Segmento3D(P1,b); Segmento3D(O1,a); Segmento3D(T,f1); Segmento3D(S,e1); Segmento3D(R,d1); Segmento3D(Q,c1); Segmento3D(P,b1); Segmento3D(O,a1); Segmento3D(f1,a); Segmento3D(o,T1); ColorePenna(0,0,255); A=PUNTO3D(-6,0,-12); B=PUNTO3D(-7,0,-12); C=PUNTO3D(-8,0,-12); D=PUNTO3D(-9,0,-12); E=PUNTO3D(-10,0,-12);
F=PUNTO3D(-11,0,-12); O=PUNTO3D(-12,0,-18); P=PUNTO3D(-12,0,-17); Q=PUNTO3D(-12,0,-16); R=PUNTO3D(-12,0,-15); S=PUNTO3D(-12,0,-14); T=PUNTO3D(-12,0,-13); A1=PUNTO3D(-13,0,-12); B1=PUNTO3D(-14,0,-12); C1=PUNTO3D(-15,0,-12); D1=PUNTO3D(-16,0,-12); E1=PUNTO3D(-17,0,-12); F1=PUNTO3D(-18,0,-12); O1=PUNTO3D(-12,0,-11); P1=PUNTO3D(-12,0,-10); Q1=PUNTO3D(-12,0,-9); R1=PUNTO3D(-12,0,-8); S1=PUNTO3D(-12,0,-7); T1=PUNTO3D(-12,0,-6); Segmento3D(T,a); Segmento3D(S,b);
Segmento3D(R,c); Segmento3D(Q,d); Segmento3D(P,e); Segmento3D(O,f); Segmento3D(T1,A1); Segmento3D(S1,B1); Segmento3D(R1,C1); Segmento3D(Q1,D1); Segmento3D(P1,E1); Segmento3D(O1,F1); Segmento3D(T1,f); Segmento3D(S1,e);
Segmento3D(R1,d); Segmento3D(Q1,c); Segmento3D(P1,b); Segmento3D(O1,a); Segmento3D(T,f1); Segmento3D(S,e1); Segmento3D(R,d1); Segmento3D(Q,c1); Segmento3D(P,b1); Segmento3D(O,a1); Segmento3D(f1,a); Segmento3D(o,T1); ColorePenna(255,255,0); A=PUNTO3D(6,0,-24); B=PUNTO3D(7,0,-24); C=PUNTO3D(8,0,-24); D=PUNTO3D(9,0,-24); E=PUNTO3D(10,0,-24); F=PUNTO3D(11,0,-24); O=PUNTO3D(12,0,-23); P=PUNTO3D(12,0,-22); Q=PUNTO3D(12,0,-21); R=PUNTO3D(12,0,-20); S=PUNTO3D(12,0,-19); T=PUNTO3D(12,0,-18); A1=PUNTO3D(13,0,-24); B1=PUNTO3D(14,0,-24);
C1=PUNTO3D(15,0,-24); D1=PUNTO3D(16,0,-24); E1=PUNTO3D(17,0,-24); F1=PUNTO3D(18,0,-24); O1=PUNTO3D(12,0,-25); P1=PUNTO3D(12,0,-26); Q1=PUNTO3D(12,0,-27); R1=PUNTO3D(12,0,-28); S1=PUNTO3D(12,0,-29); T1=PUNTO3D(12,0,-30); Segmento3D(T,f); Segmento3D(S,e); Segmento3D(R,d); Segmento3D(Q,c); Segmento3D(P,b); Segmento3D(O,a); Segmento3D(T,A1); Segmento3D(S,B1); Segmento3D(R,C1); Segmento3D(Q,D1); Segmento3D(P,E1);
Segmento3D(O,F1); Segmento3D(T1,a1); Segmento3D(S1,b1); Segmento3D(R1,c1); Segmento3D(Q1,d1); Segmento3D(P1,e1); Segmento3D(O1,f1); Segmento3D(T1,f); Segmento3D(S1,e); Segmento3D(R1,d); Segmento3D(Q1,c); Segmento3D(P1,b);
Segmento3D(O1,a); Segmento3D(f1,a); Segmento3D(o,T1); ColorePenna(0,0,255); A=PUNTO3D(-6,0,-24); B=PUNTO3D(-7,0,-24); C=PUNTO3D(-8,0,-24); D=PUNTO3D(-9,0,-24); E=PUNTO3D(-10,0,-24); F=PUNTO3D(-11,0,-24); O=PUNTO3D(-12,0,-23); P=PUNTO3D(-12,0,-22); Q=PUNTO3D(-12,0,-21); R=PUNTO3D(-12,0,-20); S=PUNTO3D(-12,0,-19); T=PUNTO3D(-12,0,-18); A1=PUNTO3D(-13,0,-24); B1=PUNTO3D(-14,0,-24); C1=PUNTO3D(-15,0,-24); D1=PUNTO3D(-16,0,-24); E1=PUNTO3D(-17,0,-24); F1=PUNTO3D(-18,0,-24); O1=PUNTO3D(-12,0,-25); P1=PUNTO3D(-12,0,-26); Q1=PUNTO3D(-12,0,-27); R1=PUNTO3D(-12,0,-28); S1=PUNTO3D(-12,0,-29);
T1=PUNTO3D(-12,0,-30); Segmento3D(T,f); Segmento3D(S,e); Segmento3D(R,d); Segmento3D(Q,c); Segmento3D(P,b); Segmento3D(O,a); Segmento3D(T,A1); Segmento3D(S,B1); Segmento3D(R,C1); Segmento3D(Q,D1); Segmento3D(P,E1); Segmento3D(O,F1); Segmento3D(T1,a1); Segmento3D(S1,b1); Segmento3D(R1,c1); Segmento3D(Q1,d1); Segmento3D(P1,e1); Segmento3D(O1,f1); Segmento3D(T1,f); Segmento3D(S1,e);
Segmento3D(R1,d); Segmento3D(Q1,c); Segmento3D(P1,b); Segmento3D(O1,a); Segmento3D(f1,a); Segmento3D(o,T1); A=PUNTO3D(6,0,-36); B=PUNTO3D(7,0,-36); C=PUNTO3D(8,0,-36); D=PUNTO3D(9,0,-36); E=PUNTO3D(10,0,-36); F=PUNTO3D(11,0,-36);
O=PUNTO3D(12,0,-35); P=PUNTO3D(12,0,-34); Q=PUNTO3D(12,0,-33); R=PUNTO3D(12,0,-32); S=PUNTO3D(12,0,-31); T=PUNTO3D(12,0,-30); A1=PUNTO3D(13,0,-36); B1=PUNTO3D(14,0,-36); C1=PUNTO3D(15,0,-36); D1=PUNTO3D(16,0,-36); E1=PUNTO3D(17,0,-36); F1=PUNTO3D(18,0,-36); O1=PUNTO3D(12,0,-42); P1=PUNTO3D(12,0,-41); Q1=PUNTO3D(12,0,-40); R1=PUNTO3D(12,0,-39); S1=PUNTO3D(12,0,-38); T1=PUNTO3D(12,0,-37); Segmento3D(T,f); Segmento3D(S,e); Segmento3D(R,d); Segmento3D(Q,c); Segmento3D(P,b); Segmento3D(O,a); Segmento3D(T,A1); Segmento3D(S,B1); Segmento3D(R,C1);
Segmento3D(Q,D1); Segmento3D(P,E1); Segmento3D(O,F1); Segmento3D(T1,a); Segmento3D(S1,b); Segmento3D(R1,c); Segmento3D(Q1,d1); Segmento3D(P1,e); Segmento3D(O1,f); Segmento3D(T1,f1); Segmento3D(S1,e1); Segmento3D(R1,d1); Segmento3D(Q1,c1); Segmento3D(P1,b1); Segmento3D(O1,a1); Segmento3D(f1,a); Segmento3D(o1,T1); A=PUNTO3D(18,0,-36); B=PUNTO3D(19,0,-36); C=PUNTO3D(20,0,-36); D=PUNTO3D(21,0,-36);
E=PUNTO3D(22,0,-36); F=PUNTO3D(23,0,-36); O=PUNTO3D(24,0,-35); P=PUNTO3D(24,0,-34); Q=PUNTO3D(24,0,-33); R=PUNTO3D(24,0,-32); S=PUNTO3D(24,0,-31); T=PUNTO3D(24,0,-30); A1=PUNTO3D(25,0,-36); B1=PUNTO3D(26,0,-36); C1=PUNTO3D(27,0,-36); D1=PUNTO3D(28,0,-36);
E1=PUNTO3D(29,0,-36); F1=PUNTO3D(30,0,-36); O1=PUNTO3D(24,0,-42); P1=PUNTO3D(24,0,-41); Q1=PUNTO3D(24,0,-40); R1=PUNTO3D(24,0,-39); S1=PUNTO3D(24,0,-38); T1=PUNTO3D(24,0,-37); Segmento3D(T,f); Segmento3D(S,e); Segmento3D(R,d); Segmento3D(Q,c); Segmento3D(P,b); Segmento3D(O,a); Segmento3D(T,A1); Segmento3D(S,B1); Segmento3D(R,C1); Segmento3D(Q,D1); Segmento3D(P,E1); Segmento3D(O,F1); Segmento3D(T1,a); Segmento3D(S1,b); Segmento3D(R1,c); Segmento3D(Q1,d1); Segmento3D(P1,e); Segmento3D(O1,f); Segmento3D(T1,f1);
Segmento3D(S1,e1); Segmento3D(R1,d1); Segmento3D(Q1,c1); Segmento3D(P1,b1); Segmento3D(O1,a1); Segmento3D(f1,a); Segmento3D(o,T1); ColorePenna(255,255,0); A=PUNTO3D(30,0,-36); B=PUNTO3D(31,0,-36); C=PUNTO3D(32,0,-36); D=PUNTO3D(33,0,-36); E=PUNTO3D(34,0,-36); F=PUNTO3D(35,0,-36); O=PUNTO3D(36,0,-35); P=PUNTO3D(36,0,-34); Q=PUNTO3D(36,0,-33); R=PUNTO3D(36,0,-32); S=PUNTO3D(36,0,-31); T=PUNTO3D(36,0,-30); A1=PUNTO3D(37,0,-36);
B1=PUNTO3D(38,0,-36); C1=PUNTO3D(39,0,-36); D1=PUNTO3D(40,0,-36); E1=PUNTO3D(41,0,-36); F1=PUNTO3D(42,0,-36); O1=PUNTO3D(36,0,-42); P1=PUNTO3D(36,0,-41); Q1=PUNTO3D(36,0,-40); R1=PUNTO3D(36,0,-39); S1=PUNTO3D(36,0,-38); T1=PUNTO3D(36,0,-37); Segmento3D(T,f);
Segmento3D(S,e); Segmento3D(R,d); Segmento3D(Q,c); Segmento3D(P,b); Segmento3D(O,a); Segmento3D(T,A1); Segmento3D(S,B1); Segmento3D(R,C1); Segmento3D(Q,D1); Segmento3D(P,E1); Segmento3D(O,F1); Segmento3D(T1,a); Segmento3D(S1,b); Segmento3D(R1,c); Segmento3D(Q1,d1); Segmento3D(P1,e); Segmento3D(O1,f); Segmento3D(T1,f1); Segmento3D(S1,e1); Segmento3D(R1,d1); Segmento3D(Q1,c1); Segmento3D(P1,b1); Segmento3D(O1,a1); Segmento3D(f1,a); Segmento3D(o1,T); /*colore verde: indica l'elemento ossigeno legato
alla catena carboniosa*/ ColorePenna(0,255,0); A=PUNTO3D(6,0,30); B=PUNTO3D(7,0,30); C=PUNTO3D(8,0,30); D=PUNTO3D(9,0,30); E=PUNTO3D(10,0,30); F=PUNTO3D(11,0,30); O=PUNTO3D(6,0,36); P=PUNTO3D(6,0,35); Q=PUNTO3D(6,0,34); R=PUNTO3D(6,0,33); S=PUNTO3D(6,0,32); T=PUNTO3D(6,0,31); A1=PUNTO3D(0,0,30); B1=PUNTO3D(1,0,30); C1=PUNTO3D(2,0,30); D1=PUNTO3D(3,0,30); E1=PUNTO3D(4,0,30); F1=PUNTO3D(5,0,30); O1=PUNTO3D(6,0,29);
P1=PUNTO3D(6,0,28); Q1=PUNTO3D(6,0,27); R1=PUNTO3D(6,0,26); S1=PUNTO3D(6,0,25); T1=PUNTO3D(6,0,24); Segmento3D(T,f); Segmento3D(S,e); Segmento3D(R,d); Segmento3D(Q,c); Segmento3D(P,b); Segmento3D(O,a); Segmento3D(T,A1);
Segmento3D(S,B1); Segmento3D(R,C1); Segmento3D(Q,D1); Segmento3D(P,E1); Segmento3D(O,F1); Segmento3D(T1,a); Segmento3D(S1,b); Segmento3D(R1,c); Segmento3D(Q1,d1); Segmento3D(P1,e); Segmento3D(O1,f); Segmento3D(T1,f1); Segmento3D(S1,e1); Segmento3D(R1,d1); Segmento3D(Q1,c1); Segmento3D(P1,b1); Segmento3D(O1,a1); Segmento3D(f,a1); Segmento3D(o,T1); ColorePenna(255,255,0); A=PUNTO3D(30,0,-36); B=PUNTO3D(31,0,-36); C=PUNTO3D(32,0,-36); D=PUNTO3D(33,0,-36); E=PUNTO3D(34,0,-36); F=PUNTO3D(35,0,-36); O=PUNTO3D(36,0,-35);
P=PUNTO3D(36,0,-34); Q=PUNTO3D(36,0,-33); R=PUNTO3D(36,0,-32); S=PUNTO3D(36,0,-31); T=PUNTO3D(36,0,-30); A1=PUNTO3D(37,0,-36); B1=PUNTO3D(38,0,-36); C1=PUNTO3D(39,0,-36); D1=PUNTO3D(40,0,-36); E1=PUNTO3D(41,0,-36); F1=PUNTO3D(42,0,-36); O1=PUNTO3D(36,0,-42); P1=PUNTO3D(36,0,-41); Q1=PUNTO3D(36,0,-40); R1=PUNTO3D(36,0,-39); S1=PUNTO3D(36,0,-38); T1=PUNTO3D(36,0,-37); Segmento3D(T,f); Segmento3D(S,e); Segmento3D(R,d); Segmento3D(Q,c);
Segmento3D(P,b); Segmento3D(O,a); Segmento3D(T,A1); Segmento3D(S,B1); Segmento3D(R,C1); Segmento3D(Q,D1); Segmento3D(P,E1); Segmento3D(O,F1); Segmento3D(T1,a); Segmento3D(S1,b); Segmento3D(R1,c); Segmento3D(Q1,d1);
Segmento3D(P1,e); Segmento3D(O1,f); Segmento3D(T1,f1); Segmento3D(S1,e1); Segmento3D(R1,d1); Segmento3D(Q1,c1); Segmento3D(P1,b1); Segmento3D(O1,a1); Segmento3D(f1,a); Segmento3D(o1,T); ColorePenna(0,0,255); A=PUNTO3D(-6,0,24); B=PUNTO3D(-7,0,24); C=PUNTO3D(-8,0,24); D=PUNTO3D(-9,0,24); E=PUNTO3D(-10,0,24); F=PUNTO3D(-11,0,24); O=PUNTO3D(-12,0,18); P=PUNTO3D(-12,0,19); Q=PUNTO3D(-12,0,20); R=PUNTO3D(-12,0,21); S=PUNTO3D(-12,0,22); T=PUNTO3D(-12,0,23); A1=PUNTO3D(-13,0,24); B1=PUNTO3D(-14,0,24); C1=PUNTO3D(-15,0,24); D1=PUNTO3D(-16,0,24);
E1=PUNTO3D(-17,0,24); F1=PUNTO3D(-18,0,24); O1=PUNTO3D(-12,0,25); P1=PUNTO3D(-12,0,26); Q1=PUNTO3D(-12,0,27); R1=PUNTO3D(-12,0,28); S1=PUNTO3D(-12,0,29); T1=PUNTO3D(-12,0,30); Segmento3D(T,a); Segmento3D(S,b); Segmento3D(R,c); Segmento3D(Q,d); Segmento3D(P,e); Segmento3D(O,f); Segmento3D(o,A1); Segmento3D(p,B1); Segmento3D(q,C1); Segmento3D(r,D1); Segmento3D(s,E1); Segmento3D(t,F1); Segmento3D(T1,f);
Segmento3D(S1,e); Segmento3D(R1,d); Segmento3D(Q1,c); Segmento3D(P1,b); Segmento3D(O1,a); Segmento3D(T1,a1);
Segmento3D(S1,b1); Segmento3D(R1,c1); Segmento3D(Q1,d1); Segmento3D(P1,e1); Segmento3D(O1,f1); Segmento3D(f1,a);
Segmento3D(o,T1); Stampa ("verde: elemento ossigeno; rosso: elemento carbonio; blu: elemento idrogeno; giallo: gruppo ossidrilico") ;
La domanda che mi viene posta, frequentemente, dagli studenti è la seguente: “Professoressa, ma a cosa serve la Matematica, a noi che studiamo per lavorare, un giorno, come chef o come direttori d’albergo?” Insegnando in un Istituto Professionale, quale l’Istituto Alberghiero, nasce pertanto l’esigenza di tenere conto del ruolo che la Matematica riveste nell’ambito delle materie di indirizzo che vengono apprese dagli studenti nel corso di studi prescelto. Il programma si inserisce quindi in un’ottica di interdisciplinarietà che faccia comprendere come lo studio della Matematica non debba essere sempre finalizzato a se stesso, ma possa essere finalizzato alle molteplici applicazioni che della Matematica se ne possono fare. A questo riguardo riporto di seguito il commento di un’alunna (Annarita Castaldo) che utilizza il MatCos ormai da quattro anni: “Per noi studiare con il MatCos è risultata essere una cosa molto utile, non solo perché mi dà la possibilità di lavorare con il computer (il cui utilizzo è oggi indispensabile, soprattutto nel nostro settore), ma anche perché dà modo di vedere la matematica sotto un’altra luce, rendendola concreta e non più una cosa astratta, la rende alla portata di tutti trasformandola in un gioco e non più una materia noiosa e amata da pochi”.
II..TT..CC.. ““GG.. GGaalliilleeii”” VViibboo VVaalleennttiiaa
DDiirriiggeennttee SSccoollaassttiiccoo: Domenico D’Agostino
DDoocceennttee ssppeerriimmeennttaattoorree: Lorenzina Grillo
AAlluunnnnaa: Mariana Iannello CCllaassssee IIVV CC
PPrrooggrraammmmaa:: “Ginestra in fiore”
Il programma nasce dall’idea di simulare un oggetto reale mediante un modello matematico: “rappresentare una ginestra in fiore”. I concetti matematici utilizzati sono: il Punto, il Segmento, la Circonferenza. Per l’implementazione dell’algoritmo sono state utilizzate le seguenti strutture di programma : Ciclo, Assegnazione.
ColoreSfondo(0,0,0); a=punto; ColorePenna(0,128,0); SpessorePenna(2); segmento(a,punto_a_caso);
per(k da 1 a 200)esegui; pausa(100); ColorePenna(0,128,0); SpessorePenna(2); segmento(a,punto_a_caso); ColorePenna(0,128,0); SpessorePenna(2);
segmento(a,punto_a_caso); fine; ColoreRiempimento(255,255,0); c=circ(punto,8);
per(k da 1 a 500)esegui; ColoreRiempimento(255,255,0); c1=circ(punto,8.2); fine;
AAlluunnnnaa: Romina Corso CCllaassssee IIVV CC
PPrrooggrraammmmaa:: “Campo magnetico”
Il programma nasce dall’idea di rappresentare le linee di forza di un campo magnetico. I concetti matematici utilizzati sono : Riferimento Cartesiano, la Circonferenza e Fascio. Per l’implementazione dell’algoritmo sono state utilizzate le seguenti strutture di programma: l’Assegnazione e il Ciclo.
stampa("fascio di circonferenze : x^2+y^2-2*b*x+c=0, linee di forza di un campo magnetico"); c=-10; n=legginum; b=-n; rifcart;
esegui finquando(b<=n); colore(a); circ(0,-2*b,c); b=b+1; fine;
AAlluunnnnaa: Francesca Celli CCllaassssee IIVV CC
PPrrooggrraammmmaa:: “Matrice lavoro”
Il programma nasce dall’idea di trattare in modo pluridisciplinare il concetto di matrice. I dati della matrice-lavoro dopo la laurea , sono stati desunti dal libro di testo di geografia economica e visualizzati mediante rappresentazioni grafiche. I concetti matematici utilizzati sono: la Matrice, il Diagramma circolare, l’Istogramma. Per l’implementazione dell’algoritmo in MatCos sono state utilizzate le seguenti strutture di programma : Assegnazione.
Stampa("Matrice di chi lavora e chi no, a tre anni dalla laurea"); m=matrice(2,2); m(1,1)=9.2/100; stampa("lavorano prima della laurea"); m(1,2)=21.3/100; stampa("in cerca di occupazione"); m(2,1)=33.9/100; stampa("lavorano stabilmente");
m(2,2)=35.6/100; stampa("hanno un lavoro precario"); stampamatr(m); stampa("matrice chi lavora e chi no a 3 anni della laurea"); diagcirc(m(1,1),m(1,2),m(2,1),m(2,2)); istogramma(m(1,1),m(1,2),m(2,1),m(2,2));
AAlluunnnnaa: Miriam Grillo CCllaassssee IIVV CC
PPrrooggrraammmmaa:: “Successione di quadrati”
L’idea nasce dallo studio dei diversi tipi di comportamento delle successioni con la realizzazione di un modello geometrico di facile costruzione. L’approccio intuitivo al concetto di limite è stato immediato. I concetti matematici utilizzati sono: Riferimento Cartesiano, Punto, Poligono, Segmento, Punto medio, l’Area, Vettore, Successione, la Somma di n1 termini. Per l’implementazione dell’algoritmo sono state utilizzate le seguenti strutture di programma : assegnazione e ciclo.
Stampa("Questo programma determina la succ. delle aree dei quadrati,calcola Sn1 e rappresenta un approccio intuitivo al concetto di limite"); Rifcart(punto,30,30); n=legginum("lato del quadrato"); ColoreRiempimento(128,0,128); A=punto(0,0); B=punto(10,0); C=punto(0,10); D=punto(10,10); po=poligono(a,b,d,c,a); segmento(A,B); segmento(B,D); segmento(D,C); segmento(C,A);
M=punto(n/2,0); M1=punto(0,n/2); M2=punto(10,n/2); M3=punto(n/2,10); coloreRiempimento(255,255,0); p=poligono(M,m2,m3,m1); s=segmento(m,m2); s2=segmento(m2,m3); s3=segmento(m3,m1); s4=segmento(m1,m); ma=punto_medio(s);
mb=punto_medio(s2); mc=punto_medio(s3); md=punto_medio(s4); ColoreRiempimento(255,0,255); p1=poligono(ma,mb,mc,md); s11=segmento(ma,mb); m11=punto_medio(s11); s22=segmento(mb,mc); m22=punto_medio(s22); s33=segmento(mc,md); m33=punto_medio(s33); s44=segmento(md,ma);
m44=punto_medio(s44); ColoreRiempimento(0,255,0); p2=poligono(m11,m22,m33,m44); area1=n^2;
stampa(area1); area2=1/2*n^2; stampa(area2); area3=(1/4)*n^2; stampa(area3); n1=legginum("numero dei termini della successione") ; punto(k,a(k)); fine; stampavett(a); Sn1=K^2/0.5; stampa(Sn1);
stampa("al crescere di n la somma sn1 è",2*n^2);
a=vettore(n1); per (k da 1 A n1)esegui;
a(k)=k^2*0.5; ColorePenna(0,255,255); SpessorePenna(4);
L’utilizzo del MatCos mi ha permesso di costruire percorsi didattici personalizzati. Le conoscenze e le abilità matematiche si imparano lavorando attivamente in situazione significative, discorrendo di quello che si fa, calandosi in contesti specifici, passando da un contesto all’altro e producendo infine concetti e modelli. MatCos si è rivelato una eccellente occasione per rendere gli studenti più responsabili del proprio apprendimento e più consapevoli dei relativi comportamenti e atteggiamenti cognitivi. D’altra parte il possesso di queste competenze, oltre ad avere un effetto favorevole sull’apprendimento delle specifiche conoscenze disciplinari, è un obiettivo fondamentale dell’educazione.
