source("http://macosa.dima.unige.it/r.R") o → qui
Altro contenuto in ↑
I colori possono essere indicati con numeri naturali (solo 8 colori) o
indicandone il nome. Esempi: white yellow yellow3 yellow4
green green4 violet magenta magenta4 purple pink coral red red3
orange chocolate brown cyan cyan4 blue blue4 grey grey50 black
Alcune funzioni già definite:
2+5; 2-5; 2*5; 2/5; 2^5; abs(3); abs(-2); sqrt(2.25)
# 7 -3 10 0.4 32 3 2 1.5
round(2.6); trunc(2.6); sign(37); sign(-2.3); sign(0)
# 3 2 1 -1 0
factorial(4); choose(10,3) # fattoriale, coeff. binomiale
# 24 (<- 4*3*2*1) 120 (<- 10/3*9/2*8/1)
print(20/3, 2); print(20/3, 15) # arrot. a 2 e a 15 cifre; vedi, sotto, "piu"
# 6.7 6.66666666666667
signif(20/3, 2); signif(20/3, 7) # <- ovvero (cifre significative, al più 7)
# 6.7 6.666667
round(20/3, 2) # arrotondo a 2 cifre frazionarie
# 6.67
Per altre funzioni meno elementari batti:
?Math
Qualche esempio d'uso sulle funzioni circolari e sulle misure degli angoli
180*gradi; 180*gradi/pi; sin(30*gradi); cos(30*gradi); tan(45*gradi)
# 3.141593 1 0.5 0.8660254 1
cos(30*gradi); frazio(cos(30*gradi)/sqrt(3))
# 0.8660254 1/2 (capisco che cos(30°) = √3/2)
Ma potrei usare anche WolframAlpha introducendo 0.8660254 e ottenendo √3/2
o introducendo cos(30°) ottenendo √3/2
( "gradi" è caricato con source("…"); se no posso porre: gradi <- pi/180 )
E' utile anche il comando ifelse. Esempio:
x <- 7; ifelse(x > 1, 3, 5); ifelse(x < 1, 3, 5)
# 3 5
Ricordiamo che si può rilavorare su un'immagine in un secondo tempo.
Costruito un grafico o una figura in una finestra grafica, se batto
Nome <- recordPlot() (Nome è un nome qualunque) l'immagine viene memorizzata.
Se poi, dopo altre attività, apro una finestra e aziono replayPlot(Nome)
viene visualizzata l'immagine iniziale, su cui posso continuare a lavorare.
Le scritte posso essere ruotate. Basta aggiungere srt nel comando text:
piu(11/13) visualizza più cifre (15) del valore tra parentesi, ultimo()
ha il valore dell'ultimo calcolo. Esempi:
(5/13+1/7)/17; frazio(ultimo()); piu((5/13+1/7)/17)
# 0.0310278 48/1547 0.0310277957336781
rad2(x) rad3(x) rad4(x) rad5(x) sono le radici 2^,3^,4^,5^ di x
rad3(8); rad3(-8)
# 2 -2
Area del rettangolo con lati A e B tra 30.5 e 31.5 e tra 1.3 e 1.4 centimetri
approssima( c(30.5,31.5), c(1.3,1.4), "*")
# [1] min [2] max
# 39.650 44.100
approssima2( c(30.5,31.5), c(1.3,1.4), "*")
# [1] centro [2] raggio
# 41.875 2.225
Sta nell'intervallo [39.65 cm², 44.10 cm²], o: 41.9 ± 2.3 cm²
Stesse cose per +, -, /, ^.
Se uno dei due fattori è esatto posso metterlo direttamente:
x = 2.1 ± 0.1, y = 2.9 ± 0.1, 1/z = 1/x + 1/y. Quanto vale z?
x <- c(2.0,2.2); y <- c(2.8,3.0)
rx <- approssima(1,x, "/") # reciproco di x
ry <- approssima(1,y, "/")
rz <- approssima(rx,ry, "+")
z <- approssima(1,rz, "/"); z
# [1] min [2] max
# 1.166667 1.269231
o:
approssima2(1,rz, "/")
# [1] centro [2] raggio
# 1.21794872 0.05128205 ovvero: 1.22±0.06
suassex(...) e suassey(...) etichettano gli assi.
Aggiungendo una S a box, boxm, bo0, box0, Box, ... non è stampato il box;
accade anche mettendo prima noBox=1 (anche davanti a graficoB e grafB).
Esempi:
anni <- c(1880,1890,1900,1910,1920,1930,1940,1950,1960,1970,1980)
frutta <- c(19,21,23,28,31,27,23,37,65,88,79)
box(1880,1980, 0,90)
spezzata(anni,frutta, "red"); suassex("anni"); suassey("frutta (kg)")
#
noBox=1; box(1880,1980, 0,90)
spezzata(anni,frutta, "red"); suassex("anni"); suassey("frutta (kg)")
# Se metto boxS (o usando BoxS) ottengo una diversa etichettatura
boxS(1880,1980, 0,90)
boxM, boX, BoX, grafB, graficoB operano come boxm, box, Box, grafb, graficob
ma scrivono le coordinate sugli assi più piccole.
Nel tracciare il grafico di una funzione, se questa è discontinua il programma,
in genere, non congiunge i vari tratti.
Esempio (il grafico della funzione arrotondamento):
HF=2; BF=4; f <- function(x) round(x)
boxS(-3,4,-3,4); grafico(f,-4,5, "red")
boxN e BoxN aprono una finestra come box e Box, senza niente, né griglia né griglia coordinate.
Possono essere utili anche per figure animate, Esempio: (vedi qui per "attendi")
HF=3; BF=3
boxN(0,100, 0,100)
for (k in 0:10) { BoxN(0,100, 0,100)
cerchio(50,82, 7, "brown"); text(50,95,"aspetta")
spezzata( c(55,50,50),c(0,0,75), "blue" ); attendi(0.5)
BoxN(0,100, 0,100)
cerchio(50,82, 7, "brown"); text(50,95,"aspetta")
spezzata( c(35,30,50,70,75,70,50,50,35,50,65),c(1.5,2,40,2,2.5,2,40,75,45,75,45), "blue" );
attendi(0.5) }
spezzata(c(53.5,55.85),c(79,79), "brown"); text(71,80,"CIAO")
Se poi voglio vedere griglia e assi basta che batta BOX(), che sovrappone
griglia ed assi all'immagine che compare nell'ultima finestra grafica.
Analogamente, se voglio fissare una scala monometrica, posso usare boxmN e BoxmN
(operano come box0S e Box0S ma non mettono né box né coordinate).
Qui puoi vedere un esempio:
 |
boxA e BoxA (e boxmA e BoxmA) aprono una fine-
stra con solo assi e coordinate su essi.
Possono essere utili anche nel caso in cui si
vogliano poi usare griglie più o meno fitte o
diversamente colorate.
boxA(0,6,0,6)
abline(h=seq(0.5,6,0.5),v=seq(1/3,6,1/3),
lty=3,col="grey")
abline(h=seq(1,6,1),v=seq(1,6,1),lty=3,
col="black") |
 |
NF() predispone una nuova finestra delle stesse dimensioni dell'ultima usata.
PPP() memorizza come xP e yP le coord. del punto cliccato
punto(x,y,colore), se in x e y metto ascisse e ordinate di più punti,
tratteggia il collegamento tra i punti; se sono più di 100 puntino e
punticino non lo fanno.
punti(x,y,colore), così come puntini e punticini, non li collegano.
puntiB, puntiniB, punticiniB, palliniB scelgono automaticamente il box,
puntiBm, puntiniBm, punticiniBm, palliniBm lo scelgono monometrico.
Spezzata e Spezza a differenza di spezzata e spezza non connettono le "y".
spezzat opera come spezza ma tratteggia i segmenti.
BF <- 2; HF <- 2; x <- c(0,2,3,6); y <- c(1,2,4,5)
box(0,6,0,6); puntino(x,y, "blue"); box(0,6,0,6); puntini(x,y, "blue")
box(0,6,0,6); spezzata(x,y, "blue"); box(0,6,0,6); Spezzata(x,y, "blue")
box(0,6,0,6); spezzat(x,y, "red")
puntiB(x,y, "red"); puntiBm(x,y, "red")
Ecco come è possibile tracciare altri tipi di punti ("D" come "Delta"):
boxS(0,6,0,6); puntoO(1,1,"blue"); puntoV(3,3,"red"); puntoD(4,2,"black")
puntiO/V/D(x,y,col) se sono messi in x,y più punti, non li collegano
spezzaC opera come spezza ma, fatto il contorno nero, Colora la parte interna.
Linea e LInea a differenza di linea tratteggiano i segmenti (tratto corto/lungo)
BF <- 2; HF <- 2; x <- c(1,5,5,1); y <- c(1,1,4,4)
box(0,6,0,6); spezzaC(x,y,"green"); punti(x,y,"red"); LInea(1,1, 5,4, "blue")
Dopo l'uso dei comandi spezzata, spezzat, spezza, spezzaC per costruire un poligono
in areaP e centroP sono presenti la sua area e il suo centroide (o baricentro)
areaP; centroP; punto(centroP[1],centroP[2], "blue")
# 12 3.0 2.5
Con areaPol(x,y) e centroPol(x,y) ho direttamente area e centroide del poligono "x,y".
 |
spezzaL, spezza2L operano come spezzaC evidenziando il poligono con
linee (± fitte) con inclinazione data in input invece che con un colore
noBox=1; boxM(-1,5, -1,5)
x <- c(-1,1,5,2); y <- c(0,-1,2,4)
spezzaL(x,y, 45, "red")
x1 <- c(0,3,5); y1 <- c(5,-1,1)
spezza2L(x1,y1, -45, "brown") |
 |
boxmN(-2.7,2.7, -2.7,2.7) # posso aggiungere provviso-
x <- c(-1,1,1,-1); y <- c(-1,-1,1,1) # riamente BOX() per
spezzaL(x-1/4,y-1/4, -45, "blue") # vedere la griglia
spezzaL(x+1/4,y+1/4, 45, "brown")
text(0.25,1.5,"popolazione residente",col="brown")
text(-0.25,-1.5,"popolazione presente",col="blue")
frec(1,0,2,0,"brown"); frec2(2,-0.4,"brown")
text(2.1,-0.75,"emigrati\ntemporanei",col="brown")
frec(-1,0,-2,0,"blue"); frec2(-2,0.4,"blue")
text(-2.1,0.75,"immigrati\ntemporanei",col="blue") |
cerchio3p(x,y, col) traccia il cerchio passante per i punti (almeno 3)
con ascisse in x e ordinate in y; centro3p e raggio3p ne contengono
centro e raggio; cerch3p lo traccia sottile.
cerchioC(xC,yC,r,col) traccia un cerchio pieno colorato.
boxm(-4,3, -3,4)
x <- c(0,2,-1); y <- c(-2,1,3)
punti(x,y,"red"); cerchio3p(x,y,"red")
centro3p; raggio3p
# -0.5 0.5 2.54951
punto(centro3p[1],centro3p[2],"blue")
cerchioC(2,3, 1/2, "green") |  |
cartamm consente di realizzare carta millimetrata
Volendo posso tracciarvi grafici o (usando rect,
con le coordinate di vertici opposti - in col
metto il colore interno, in border potrei mettere
quello del bordo) istogrammi:
cartamm(40,25)
rect(5,0, 10,17, col=2); rect(10,0, 15,22, col=3)
rect(15,0, 20,9, col=4); rect(20,0, 25,15, col=5)
rect(25,0, 30,19,col=6); rect(30,0, 35,12, col=7)
Vedi qui per altro sull'uso di carta mm e distanze
|  |
Mentre torta e Torta fanno dei diagrammi a torta scegliendo automaticamente i
colori, con tortaC e TortaC puoi aggiungere i colori, indicandoli con i numeri
o con i nomi.
Esempi (1/1, 2/2, ... sono un trucco per contare i numeri scritti):
Torta( c(1/1,2/2,3/3,4/4,5/5,6/6,7/7,8/8) )
# giallo,celeste,... % 12.5 12.5 12.5 12.5 12.5 12.5 12.5 12.5
TortaC( c(1/1,2/2,3/3,4/4,5/5,6/6,7/7,8/8), c(1,2,3,4,5,6,7,8) )
# % 12.5 12.5 12.5 12.5 12.5 12.5 12.5 12.5
tortaC( c(1,2,3), c("white", "orange", "pink") )
# % 16.66667 33.33333 50
L'ultimo aregogramma è pensato per le stampe in tono di grigio:
tortaC( c(1,2,3), c("grey50", "grey75", "grey95") )
Con TortaM posso fare dei diagrammi a mezza torta. Tortam sceglie automaticam. i colori
TortaM( c(1,2,3), c("white", "orange", "pink") ) # o: Tortam( c(1,2,3) )
# % 16.66667 33.33333 50
Posso colorare anche le "strisce". Ecco cosa ottengo con i comandi seguenti:
# 47.5 27.5 25
da<- c(237.5,137.5,125); co<- c("red","yellow","blue"); StrisciaC(da,co); BarreC(da,co)
#
Con Colori() ho nomi (↓) e rappresentazione grafica (↑) di alcuni colori.
Colori()
# white cyan skyblue blue pink violet magenta red brown orange gold yellow
# green green2 green3 grey90 grey black
Per realizzare istogrammi di dati già classificati, non facili da tracciare con i
comandi standard, si può ricorrere al comando istoclas. Un esempio:
in Italia nel 1951 negli intervalli d'età [0,5),[5,10),[10,20),[20,30),[30,40),[40,50),
[50,60),[60,75),[75,100) sono morte 729,35,77,132,134,285,457,1401,1569 mila persone
(se gli estremi degli intervalli sono N le frequenze sono N-1)
#
interv <- c(0,5,10,20,30,40,50,60,75,100)
freq <- c(729,35,77,132,134,285,457,1401,1569)
istoclas(interv,freq)
# la media (pallino marrone) è circa 58.32019
# Per altre statistiche usa il comando altrestat()
altrestat()
# Min. 1st Qu. Median Mean 3rd Qu. Max.
# 0.00 43.43 66.00 58.32 80.80 100.00
# I pallini sono il 5° e il 95° percentile
Sono state stimate, oltre alla media, alcuni percentili (il 25°, il 50° e il 75°,
o primo quartile, mediana e terzo quartile) ed è stato tracciato il box-plot.
[ per fare ciò si è generato un grande file di dati singoli distribuiti come
l'istogramma; il file è daticlas; volendo memorizzarlo per altri usi lo puoi
copiare in un file con altro nome; non devi visualizzarlo: sono 100 mila dati!
se vuoi avere un'idea di esso puoi battere str(daticlas) ]
Per l'impiego di R in statistica (e probabilità) rimandiamo, oltre che al
documento introduttivo e al link in fondo ad esso (anche per il comando statisti-
che, analogo ad altrestat), a "usi di base" e "usi statistici avanzati" qui.
frec e frec2 operano come freccia e freccia2 ma con tratto sottile (freccina
e freccina2 fanno anche le frecce più piccole). Esempio:
boxm(-1,5, -1,5)
frec(0,0, 5,3, 1); frec2(2,5, 1); freccia(0,0, 2,5, "red")
Per il calcolo polinomiale più complesso conviene ricorrere a Wolframalpha (vedi):
basta che metta:
quotient and remainder of (x^5 + x^3 - 1) / (x^2 + x - 5)
per ottenere: quotient: x^3 - x^2 + 7*x - 12 remainder: 47*x - 61
o (x^5 + x^3 - 1) * (x^2 + x - 5) per avere
x^7 + x^6 - 4*x^5 + x^4 - 5*x^3 - x^2 - x + 5
o simplify (x^2 + 1) / (x^5 - x) per avere 1/(x^3 - x)
#
Puoi comunque sommare e moltiplicare polinomi con sommap e prodp. Per
operare su P = x^5 + x^3 - 1 e Q = x^2 + x - 5 e trovarne somma e prodotto
dai come input i coefficienti e fai:
P <- c(1,0,1,0,0,-1); Q <- c(1,1,-5); sommap(P,Q); prodp(P,Q)
# 1 0 1 1 1 -6
# 1 1 -4 1 -5 -1 -1 5
Hai x^5+x^3+x^2+x-6 e x^7+x^6-4x^5+x^4-5x^3-x^2-x+5
Per trovare (x+1)^7 moltiplica 7 volte 1 per x+1:
A <- 1; B <- c(1,1); for(i in 1:7) A <- prodp(A,B); A
# 1 7 21 35 35 21 7 1
Ovvero: 1 + 7x + 21x^2 + 35x^3 + 35x^4 + 21x^5 + 7x^6 + x^7
#
Puoi inoltre risolvere le equazioni polinomiali in cui l'unica
variabile che compare è l'incognita:
soluzione di -78 + 73*x - 57*x^2 + 73*x^3 + 21*x^5 = 0
q <- c(-78,73,-57,73,21); solpol(q)
# 0.857142857142857
# -4.33333333333333
frazio(0.857142857142857); frazio(-4.33333333333333)
# 6/7 -13/3
controllo grafico:
f <- function(x) -78+73*x-57*x^2+73*x^3+21*x^4
noBox=1; graficoB(f,-5,2, "blue")
|  |
Altro esempio:
soluzione di -2/9 - 2/9*x + x^3 + x^4 = 0
# non c'è il termine di grado 2: metto 0 al suo posto
u <- c(-2/9,-2/9,0,1,1); solpol(u)
# 0.60570686427738
# -1
f <- function(x) -2/9 - 2/9*x + x^3 + x^4
noBox=1; graficob(f,-1.5,1, "blue") |  |
___________________________________________________________________________
NOTE:
• curva(h,...) per fare il grafico di h(x,y)=0 cerca dove h cambia
segno; se ovunque h(x,y)≥0 o h(x,y)≤0 il grafico non viene tracciato.
Prova allora a fare quello di abs(h(x,y))-eps = 0 con eps piccolo.
Un esempio facile, per capire:
box(-4,4, -4,4)
g <- function(x,y) x^2+4*y^2-4*x*y; curva(g,"green")
# non ottengo nulla ( anche se in questo caso so che la curva
# è x-2*y = 0 in quanto x^2+4*y^2-4*x*y = (x-2*y)^2 )
eps <- 1e-4; k <- function(x,y) abs(g(x,y))-eps; curva(k,"blue")
• I messaggi di avviso sono inibiti: se batto 5/sqrt(-1)
ottengo solo NaN (non è un numero)
Per riattivarli devo introdurre options(warn=-1). In tal caso ottengo anche:
Warning message: In sqrt(-1) : Si è prodotto un NaN
Per disattivarli nuovamente basta introdurre options(warn=0)
• Se vuoi cancellare tutte le variabili definite in usi precedenti aziona
rm(list=ls()) e poi riaziona source("http://macosa.dima.unige.it/r.R")
Ore(), Minuti(), Secondi() forniscono informazioni sull'ora.
Sec() n. di sec. trascorsi da avvio del programma (utile per animazioni).
attendi(x) fa trascorrere x secondi (utile per animazioni).
orologio() visualizza un orologio attuale per 10 secondi e stampa l'ora.
orologio2(h,m,s) visualizza un orologio con l'ora indicata
Puoi tracciare curve in forma parametrica battendo:
param(X,Y, a,b, col) se hai già definito 2 funz. X e Y di un parametro
che varia tra a e b, o in forma polare con:
polar(R, a,b, col) se hai def. R funz. dell'angolo tra a e b.
Es. param(f,g,0,2*pi,'red') con f <- function(t) 2*cos(t),
g <- function(t) sin(t) è un'ellisse;
polar(r,0,20,'blue') con r <- function(a) sqrt(a) è una spirale.
Con para() par1() pola() pol1() si ha uno spessore minore
paramb, polarb, …, pol1b scelgono anche il box, monometrico
Per rototraslare la curva K(x,y)=0 di un angolo di A° attorno all'origine e
un vettore (h,k) e dilatarla orizzontalm. e vert. dei fattori mx e my usa:
rottramol(K, A, h,k, mx,my, col)
rottramo(..) rottram(..) come rotramol di spessore minore
rottra(K, A, h,k, col) si limita a rototraslarla.
Per dilatarla e traslarla e, infine, ruotarla:
moltrarot(K, mx,my, h,k, A, col) moltraro(..) moltrar(..)
Esempi - 1
Se metti ad es. in x e y due interi ≥ 0 comunque grandi con som(x,y) e
pro(x,y) ne hai somma e prodotto. Se z è un altro intero ottieni ad es.
(x*y)*(x+z) con pro( pro(x,y), som(x,z) )
dif(x,y) calcola la differenza non negativa: x-y se x>=y, 0 altrimenti,
app(x) trasforma la stringa di numeri in un numero approssimato
[se un numero ha più di 17 cifre devi metterlo tra "]
Esempi - 2
Puoi tracciare curve introducendo punti che ne guidino l'andamento
(metodo di Bezier). Messe le coordinate in X e Y, scelta una scala, usa
bezier(X,Y,N) dove N è 0 o un codice colore. Prova con
bezier(a,b,1) bezier(a,b,0) bezier(a,b,8) dopo aver introdotto:
a <- c(-3,2,2,-1); b <- c(2,2,-2,1); box(-3,3, -3,3)
Esempi - 3
diseq(F,G, h,k, colore) punteggia lo spazio tra i grafici di F e di
G [F(x) < G(x)] e le rette verticali di ascisse h e k nel colore scelto.
Ripeti eventualmente il comando per avere più punti.
diseq1(F, k, colore) punteggia dove la f. di 2 variabili F
è minore di k
diseq2(F, k, colore) punteggia dove la f. di 2 variabili F
è maggiore di k
Posso risolvere anche sistemi di disequazioni
Esempi - 4
Risoluzione di sistemi lineari
sist(x) risolve il sistema lineare x
soluz(n) è la soluzione n-esima
Esempi - 5
Grafici di funzioni e curve al variare di parametri:
In (a,b)×(c,d), al variare di u,v,w
fun3p(f, a,b,c,d) polar3p(R, t1,t2, a,b,c,d)
In (a,b)×(c,d), al variare di u,v,w,k
curva4p(F, a,b,c,d)
Vedi gli esempi
Esempi - 6
Definisci una funz. f (o g, h1, …). Dando il comando seguente hai il
grafico di f per input tra a e b, output tra c e d, con evidenziato
(x0,f(x0)). Se clicchi in un punto hai il grafico della retta che passa
per i punti del grafico di ascissa x0 e di quella cliccata. Se clicchi
l'ascissa x0 hai la retta tangente. Premi in alto a sinistra per finire.
Comando: pend(f, a,b, c,d, x0)
Prova con: h <- function(x) x^2; pend(h, -1,1.5, 0,3, 1)
Esempi - 7
Calcolo vettoriale, differenziale e integrale (e num. complessi)
prodv(x,y), prods(x,y), modulo(x), versore(x)
derivata(f,NomeVariabile), derivata2,…,derivata6, integrale(f,a,b)
grafici: gintegrale(f,a,b,col), gintegra, più sottile.
Per operare con i numeri complessi rinviamo alla guida per l'uso di R, qui.
Esempi - 8
Regressione lineare, quadratica e cubica: la funzione lineare con grafico
per un punto dato e le generiche funzioni lineare, quadratica e cubica che
"meglio" approssimano alcuni dati sperimentali. Comandi:
regressione(x,y,p,q), regressione1(x,y), regressione2(x,y), regressione3(x,y)
Se i punti sono 2, 3 o 4 regressione1, regressione2 e regressione3 trovano
esattamente la curva. Negli es. è richiamato anche il calcolo delle spline.
Esempi - 9
Retta approssimante che passa esattamente per (A,B) e passa per i punti di
ascisse x e ordinate y con le precisioni ex ed ey. Comando:
puntiapp(A,B, x,y, ex,ey)
Esempi - 10
C'è la possibilità di avere più grafici in un'unica finestra,
se via via i box sono introdotti con Bo…, usando i comandi:
rigcol(m,n) o colrig(n,m)
Esempi - 11
Per caricare immagini di cui siano memorizzate le coordinate posso ricorrere
ai comandi xTab(D) e yTab(D) se in D c'è la collezione delle coordinate
x1,y1, x2,y2, ..., xN,yN. Ci sono anche appositi comandi per le tabelle.
Esempi - 12
Soluzione di equazioni differenziali del 1° ordine e tracciamento del campo
direzionale coi comandi soledif(x0,y0, xf, N, col) e diredif(a,b,c,d, m,n)
Esempi - 13
Esempi di visioni in prospettiva (vedi la guida ad R per approfondimenti).
Comandi: casa() GRAF3D() BOH() seba(0) seba(1)
( premi INVIO per far partire i programmi, dopo averli caricati )
Esempi - 14
Tassellazioni di Escher: escher()
Esempi - 16
Visalizzazione della struttura dei termini
Esempi - 17
Grafi ad albero
Esempi - 18
Altre immagini (grafi, diagrammi,...)
Esempi - 19
Oltre alle immagini animate come quelle viste in esempi-1 ed esempi-8, si
possono costruire file html animati come questo nel modo spiegato qui. Per
scaricare la cartella contenente l'esempio e le spiegazioni clicca qui.
------------------------------------------------------------------
Esempi - 1 (vedi)
orologio()
orologio2(21,15,32)
#
boxm(-60,60, -60,60)
ro1 <- function(a) a^1.5
polar(ro1,0,5*pi, "red")
ro2 <- function(a) 30/(2+sin(a)-cos(a))
polar(ro2,0,5*pi, "green")
asc1 <- function(t) 2*t^2-3*t
ord1 <- function(t) t^3-t+1
param(asc1, ord1, -10,10, "blue")
asc2 <- function(t) -30+20*cos(t)
ord2 <- function(t) 10+30*sin(t)
param(asc2, ord2, 0,2*pi, "magenta")
H <- function(x,y) x*y-100
curva(H, "grey")
rottramo(H, 45, 0,0, 1.5,1, "black")
#
noBox=1; boxM(-8,12, -5,9)
F <- function(x,y) x^2+y^2-1; curva(F,"brown")
moltrarot(F, 8,4, 0,0, 0, "blue")
punto(4,3, "red"); moltrarot(F, 8,4, 4,3, -30, "blue")
( in "polar" è inteso che l'ang. è in radianti; per fare il grafico di ro(a) con
a in gradi tra h e k fai quello di ro1(x) = ro(x/gradi) tra h/gradi e k/gradi )
# Come costruire un'immagine animata:
# La costruzione di un asteroide (la figura tracciata da un punto
# di un cerchio che ruota su un cerchio maggiore)
boxm(-4,4, -4,4)
f <- function(t) 4*cos(t)^3; g <- function(t) 4*sin(t)^3
cerchio(0,0, 4, "grey"); param(f,g, 0,2*pi, "grey")
i <- 0; x <- 4; y <- 0; dt <- 0.6
while(i < 90) {puntino(x,y,"brown"); attendi(dt);
i <- i+1; Boxm(-4,4,-4,4); cerchio(0,0, 4, "grey"); param(f,g, 0,2*pi, "grey");
t <- 2*pi/90*i; cerchio(3*cos(t),3*sin(t), 1, "red");
freccia(3*cos(t),3*sin(t), 4*cos(t)^3, 4*sin(t)^3, "blue");
x <- c(x,4*cos(t)^3); y <- c(y,4*sin(t)^3) }
param(f,g, 0,2*pi, "brown")
# Per una versione senza "griglia" clicca qui.
Esempi - 2 (vedi)
## Il calcolo di x*(10+x)+5*x^3 per x=123456789012345
x <- "123456789012345"
som( pro(x, som(10,x)), pro(5, pro(x, pro(x,x))))
# "9408381861768148891412848380186556157340600"
## Verifica. Batto il numero e ottengo la rappr. esponenziale:
9408381861768148891412848380186556157340600
# 9.408382e+42
## Cosa otterremmo direttamente:
x <- 123456789012345; x*(10+x)+5*x^3; piu(ultimo())
# 9.408382e+42 9.40838186176815e+42
#
## 40!
n <- 40; y <- 0;z <- 1;j <- 1; while(j<=n){y<- som(y,1); z<- pro(z,y); j<-j+1}; z
# "815915283247897734345611269596115894272000000000"
## 171!
n <- 171; y <- 0;z <- 1;j <- 1; while(j<=n){y<- som(y,1); z<- pro(z,y); j<-j+1}; z
# "1241018070217667823424840524103103992616605577501693185388951803
6119960752216917529927519781204875855764649595016703870528098898
5869071076733124203221848436431047357788996854827829075454156196
4852153468318044293239598173696899657235903947616152278558180061
176365108428800000000000000000000000000000000000000000"
## Un trucco per stampare una stringa lunga su più righe:
str <- z; col <- 80; for(n in 0:(nchar(str)/col)) print(substr(str,n*col+1,(n+1)*col))
# "12410180702176678234248405241031039926166055775016931853889518036119960752216917"
# "52992751978120487585576464959501670387052809889858690710767331242032218484364310"
# "47357788996854827829075454156196485215346831804429323959817369689965723590394761"
# "6152278558180061176365108428800000000000000000000000000000000000000000"
#
## 2^1024, non calcolabile direttamente
2^1023; 2^1024
# 8.988466e+307 Inf
## Col programma per 2^1024 ottengo:
y <- 1; for(i in 1:1024) y <- pro(y,2)
str <- y; col <- 80; for(n in 0:(nchar(str)/col)) print(substr(str,n*col+1,(n+1)*col))
# "17976931348623159077293051907890247336179769789423065727343008115773267580550096"
"31327084773224075360211201138798713933576587897688144166224928474306394741243777"
"67893424865485276302219601246094119453082952085005768838150682342462881473913110"
"7237163350510684586298239947245938479716304835356329624224137216"
## nchar(y) -> 309 Sono 309 cifre (quelle di 2^1023 erano 308)
#
## Approssimazione in notazione scientifica
x <- "12345678901234567890"; app(x)
# 1.234568e+19
#
## 1000^20-999^20
y <- 1; for(i in 1:20) y <- pro(y,999)
z <- 1; for(i in 1:20) z <- pro(z,1000)
dif(z,y)
# "19811135170465317394197775411834107481255499156139810019999"
app(z); app(y); app(dif(z,y))
# 1e+60 9.801889e+59 1.981114e+58
Esempi - 3 (vedi)
xx <- c(-1,-1,0,0,1,1)
yy <- c(0,1,1,-1,-1,0)
boxm(-1,1,-1,1)
bezier(xx,yy,0); bezier(xx,-yy,0)
boxm(-1,1,-1,1)
bezier(xx,yy,"red"); bezier(xx,-yy,"black")
# altri esempi qui
Esempi - 4 (vedi)
F <- function(x) x*(x-2); G <- function(x) x/2
graficob(F,-1,3, "blue")
grafico(G,-1,3, "red")
diseq(F,G,-1,3,"black")
diseq(F,G,-1,3,"black")
diseq(G,F,-1,3,"orange")
diseq(G,F,-1,3,"orange")
k <- function(x,y) abs(x)+abs(y)-1
curva(k,"blue"); diseq1(k,0,"red")
#
h <- function(x,y) (x-1)^2+0.5*(y+3)^2
# dove h < 2 e dove h > 3
boxm(-3,3, -6,0)
diseq1(h,2, "blue"); diseq1(h,2, "blue")
diseq2(h,3, "red"); diseq2(h,3, "red")
#
P <- function(x,y) x >= y & x-y <=1 & 0 <= x & x <= 1
# dove P è vera (val. 1) e dove è falsa (val. 0)
box(-2,2,-2,2)
diseq1(P,1,"blue"); diseq1(P,1,"blue") # falsa
diseq2(P,0, "red"); diseq2(P,0, "red") # vera
for(i in 1:10) diseq1(P,1,"blue"); for(i in 1:10) diseq2(P,0,"red")
# Attenzione: il software non basta
# Vediamo la risoluzione di 3/(4*x – 5) > 4. Se metto:
box(-5,5, -5,5)
f <- function(x) 3/(4*x-5); g <- function(x) 4
# non è tracciato il grafico di g: in g(x) non c'è x; lo faccio comparire:
f <- function(x) 3/(4*x-5); g <- function(x) 4-x+x
box(-5,5, -5,5)
grafico(f,-5,5, 1); grafico(g,-5,5, 2)
# Capisco che le soluzioni sono in un intervallino tra 0 e 2, ma
# per rappresentare la diseq. devo avere un intervallo in cui i due
# grafici non abbiano salti. Dove è il salto? Risolvo l'equazione
# 4*x-5 = 0. È facile, ma vediamo come farlo col computer:
h <- function(x) 4*x-5; soluz(h,0, 0,2)
# 1.25
box(0,2,-1,8); grafico(f,0,2, 1); grafico(g,0,2, 2)
diseq(g,f, 1.25,2, "brown"); diseq(g,f, 1.25,2, "brown")
# Conferma grafica: la soluz. è (1.25,q). Per trovare q:
soluz2(f,g, 1.25, 1.5)
# 1.4375
# Per avere l'intervallo in forma frazionaria:
frazio(1.25); frazio(1.4375)
# 5/4 23/16
puntino(5/4,0,"blue"); puntino(23/16,0,"red")
Esempi - 5 (vedi)
## Risolviamo il sistema
# 8x + 7y + 6z = 7.4
# 7x +10y +12z = 8.65
# x + 2y + 4z = 1.75 (vedi qui)
S <- c(8,7,6,7.4, 7,10,12,8.65, 1,2,4,1.75); sistema(S)
# 0.55 0.30 0.15
soluz[2] # per avere solo la seconda soluzione (y)
# 0.3
# Se il sistema non ha soluzioni o ne ha infinite compare "sistema singolare"
Esempi - 6 (vedi)
# Devo usare u,v,w come parametri e U,V,W come passi
# Cliccando puoi variare i parametri.
# In grigio viene tracciata la curva precedente.
# Cliccando il bottone blu vedi il grafico più spesso.
# Una parabola in (-5,5)×(-10,10) al variare dei coefficienti
h <- function(x) u*x^2+v*x+w
u <- 1; U <- 0.1; v <- 1; V <- 0.1; w <- 0; W <- 0.1
fun3p(h,-5,5, -10,10)
# I grafici polari sono in scala monometrica.
# Nell'esempio che segue uso solo 2 parametri
# Il grafico al variare di t tra 0 e 2π in (-3,9)×(-6,6)
ro <- function(t) u+v*cos(t)
u <- 2; U <- 0.1; v <- 2; V <- 0.1; w <- 0; W <- 0
polar3p(ro, 0,2*pi, -3,9, -6,6)
# Per una funz. di 2 var. posso usare anche k e K.
# Una funz. polinomiale di 2 grado:
u <- 2; U <- 1; v <- 2; V <- 1; w <- 2; W <- 1; k <- 2; K <- 1
G <- function(x,y) x^2*u+y^2*v+w*x - k
curva4p(G, -3,3, -3,3)
Esempi - 7 (vedi)
f <- function(x) cos(x)
pend(f, -3.2,0, -1.6,1.6, -pi/2)
Esempi - 8 (vedi)
# prodotto scalare e vettoriale
v1 <- c(1,-2,2); v2 <- c(-4,0,2); prods(v1,v2); prodv(v1,v2)
# 0 -4 -10 -8
v1 <- c(1,-2,2); v2 <- c(-4,1,2); prods(v1,v2); prodv(v1,v2)
# -2 -6 -10 -7
v1 <- c(0,0,1); v2 <- c(1,0,0); prods(v1,v2); prodv(v1,v2)
# 0 0 1 0
# la somma di vettori si fa col "+":
v1 <- c(2,3); v2 <- c(-4,1)
noBox=1; boxM(-4,2, -1,5)
freccia(0,0,v1[1],v1[2], "red")
freccia(0,0,v2[1],v2[2], "blue")
freccia(0,0,(v1+v2)[1],(v1+v2)[2], "violet")
frec(v1[1],v1[2], (v1+v2)[1],(v1+v2)[2], 1)
frec(v2[1],v2[2], (v1+v2)[1],(v1+v2)[2], 1)
# derivate
G <- function(a) sin(a); derivata(G,"a")
# cos(a)
f <- function(x) 3*x^3-5*x^2+x+3
noBox=1; graficoB(f, -2,4, "blue")
derivata(f,"x")
# 3 * (3 * x^2) - 5 * (2 * x) + 1
df <- function(x) eval(derivata(f,"x")); grafico(df,-3,5, "red")
# potevo anche def. df scrivendo 3*(3*x^2)-5*(2*x)+1
derivata2(f,"x")
# 3 * (3 * (2 * x)) - 5 * 2
d2f <- function(x) eval(derivata2(f,"x")); grafico(d2f,-3,5, "violet")
derivata3(f,"x")
# 3 * (3 * 2)
d3f <- function(x) eval(derivata3(f,"x"))+x-x # metto la "x" con un trucco
grafico(d3f,-3,5, "green")
# integrali
g <- function(x) sin(x)
integrale(sin, 0,pi/2); integrale(sin, 0,pi); integrale(sin, 0,2*pi)
# 1 2 2.032977e-16 ("praticamente" 0)
noBox=1; boX(-pi,2*pi, -1,1); grafic(cos, -pi,2*pi, "blue")
gintegra(cos, 0,2*pi, "red"); gintegra(cos, 0,-pi, "violet")
punto(0,0, "red")
Esempi - 9 (vedi)
x <- c(-0.2, 1.3, 1.7, 3.2, 4.1, 4.6)
y <- c(9.1, 17.5, 20.7, 25.4, 35.7, 51.2)
box(-1,6,-10,70); punti(x,y,1)
regressione(x,y, 0,0); punto(0,0,"blue")
# 9.829 * x
f <- function(x) 9.829 * x; grafico(f,-1,6, "red")
regressione1(x,y)
# 7.628 * x + 7.911
g <- function(x) 7.628 * x + 7.911; grafico(g,-1,6, "blue")
regressione2(x,y)
# 1.37 * x^2 + 1.38 * x + 11.2
h <- function(x) 1.37 * x^2 + 1.38 * x + 11.2; grafico(h,-1,6, "violet")
regressione3(x,y)
# 1.21 * x^3 + -6.3 * x^2 + 11.9 * x + 11.6
k <- function(x) 1.21 * x^3 + -6.3 * x^2 + 11.9 * x + 11.6; grafico(k,-1,6, "green")
punti(x,y,1)
# A destra è rappresenta invece la spline cubica che interpola i punti (vedi):
lines(spline(x,y,n=1000),col="red")
# La curva che passa esattamente per (-1,-10),(0,-1),(1,-2),(2,5)
box(-2,3,-20,20)
punto(-1,-10, 1); punto(0,-1, 2); punto(1,-2,3); punto(2,5, 4)
regressione3( c(-1,0,1,2), c(-10,-1,-2,5) )
# 3 * x^3 + -5 * x^2 + 1 * x + -1
f <- function(x) 3 * x^3 + -5 * x^2 + 1 * x + -1
grafico(f,-2,3, 6)
Esempi - 10 (vedi)
# Che cosa posso dire della funzione lineare F tale che F(5) = 10
# il cui grafico passa per i punti dotati di precisione
# x: 12±1 17±1 24±1 33±1.5
# y: 18±2 27±2 31±2.5 45±3
box(0,35,0,50)
x <- c(12, 17, 24, 33); ex <- c(1, 1, 1, 1.5)
y <- c(18, 27, 31, 45); ey <- c(2, 2, 2.5, 3)
puntiapp(5,10, x,y, ex,ey)
1.153846 * x + 4.230769 1.153846 * (x - 5 ) + 10
1.305556 * x + 3.472222 1.305556 * (x - 5 ) + 10
Esempi - 11 (vedi)
x <- c(0,2,3,6); y <- c(1,2,4,5)
rigcol(2,3)
Boxm(0,6,0,6); Spezzata(x,y, "blue"); Boxm(0,6,0,6); Spezza(x,y, "blue")
Boxm(0,6,0,6); spezzata(x,y, "blue"); Boxm(0,6,0,6); spezza(x,y, "blue")
Boxm(0,6,0,6); punto(x,y, "blue"); Boxm(0,6,0,6); punti(x,y, "blue")
Esempi - 12 (vedi)
A <- c(1,4, 5,4, 5,0, 1,0, 1,4, 3,5, 5,4); xTab(A); yTab(A)
# 1 5 5 1 1 3 5
# 4 4 0 0 4 5 4
boxm(0,6, 0,6); spezzata(xTab(A), yTab(A), "red")
boxm(0,6, 0,6); spezzaC(xTab(A), yTab(A), "yellow")
# Posso caricare coordinate (separate da ",") presenti in un file esterno.
# Ad es. se copio le coordinate presenti nel file penisola e le incollo
# dopo avere battuto
# I <- c( e infine battendo ) in modo da ottenere:
# I <- c(
# 8,46,
# 7.87,45.9,
# ...
# 8,46
# )
# Ecco che cosa ho come esito con questi altri comandi:
X <- xTab(I); Y <- yTab(I)
box(min(X),max(X), min(Y),max(Y)); spezzata(X,Y, "blue")
noBox=1
box(min(X),max(X), min(Y),max(Y)); spezzaC(X,Y, "green"); spezza(X,Y, "red")
puntino(centroP[1],centroP[2], "red")
# Vedi qui per caricare dati come quelli di "penisola" salvati come tabella
#
# Un pipistrello:
boxmN(-6,6, -6,6)
P <- c(
0, 1.05, 0.1,1.05, 0.35,1, 0.8,1.3, 0.6,0.95,
1.5,0.9, 5,4, 5.55,4, 6,3, 5,1,
1.45,-1.9, 1.8,-2.4, 1.6,-2.5, 1.35,-2, 0,-2.9,
-1.35,-2, -1.6,-2.5, -1.8,-2.4, -1.45,-1.9, -5,1,
-6,3, -5.55,4, -5,4, -1.5,0.9, -0.6,0.95,
-0.8,1.3, -0.35,1, -0.1,1.05, 0,1.05 )
X <- xTab(P); Y <- yTab(P)
spezzaC(X,Y,"grey"); spezzata(X,Y,"black")
Esempi - 13 (vedi)
# Soluzione grafica di eq.diff. del 1° ord. col metodo di Eulero:
# soledif(x0,y0,xf,N,col) traccia la poligonale approssimante con N passi il graf. della
# sol. di y' = f(x,y) (quella passante per (x0,y0), da x0 a xf), con f messa in Dy
# Esempio: y'=x-y tale che (x0,y0)=(-1,3) per -1 <= x <= 5
Dy <- function(x,y) x-y
noBox=1; boX(-1,5, -2,5)
soledif(-1,3, 5, 10, "brown")
soledif(-1,3, 5, 1e3, "blue")
# Capisco che con N = 1000 il grafico si è stabilizzato. In genere N = 1e4
soledif(4,2.5, -1, 1e4, "red")
# è sufficiente; se il grafico ha molte oscillazioni occorre aumentare N
# Se voglio vedere il campo direzionale per 20 righe e 25 colonne faccio
diredif(-1,5, -2,5, 25,20)
# Se voglio vedere solo questo non metto le righe "soledif"
# Altri esempi per la stessa equazione (fig. a destra):
noBox=1; boX(-1,5, -2,5)
soledif(1,0, 5, 1e4, "brown"); soledif(1,0, -1, 1e4, "blue")
soledif(2,1.5, 5, 1e4, "brown"); soledif(2,1.5, -1, 1e4, "blue")
soledif(3,1, 5, 1e4, "brown"); soledif(3,1, -1, 1e4, "blue")
# soledifp(x0,y0,xf,N,col) traccia solo gli N+1 punti senza congiungerli
noBox=1; boX(-1,5, -2,5)
soledifp(-1,3, 5, 10, "black")
noBox=1; boX(-1,5, -2,5)
soledif(-1,3, 5, 10, "red")
soledifp(-1,3, 5, 10, "black")
Esempi - 14 (vedi)
casa()
( poi premi INVIO per far partire il programma )
# teta, fi e ind.dist indicano la posizione dell'occhio: la direzione
# dello sguardo proiettata sul piano orizzontale, la sua inclinazione
# rispetto a tale piano e la distanza dell'occhio dal centro del box.
GRAF3DIM()
Se batti GRAF3D(10,5,1) vedi il grafico della funzione che dentro
al cerchio di centro (0,0) e raggio 1 vale sqrt(x^2+y^2) e al
di fuori vale 0, vista dalla direzione teta=10°, fi=5° e da una
particolare distanza. Con GRAF3D(10,5,3) allontani l'occhio.
Prova con GRAF3D(0,30,1/2) GRAF3D(10,30,2) GRAF3D(10,-30,2)
BOH()
Se batti INCL(5,10) vedi una figura da una inclinazione di 5°, con
scala tale che le porzioni di assi x,y,z (colorati nero, verde e
rosso) siano lunghe 10. La stiamo guardando un po' a sinistra del
piano yz. La figura è una parabola. E' possibile? Prova con
INCL(10,10), INCL(15,10), INCL(40,10), INCL(40,200), INCL(40,2000)
INCL(5,10)
# Un'immagine simile al S.Sebastiano di Antonello da Messina
# (alto 1.80 cm visto dal pittore dall'altezza di 0.30 m)
# Prova a cambiare il punto di vista (direzione e distanza).
seba(0) seba(1)
( poi premi INVIO per far paratire il programma )
 |  |
Esempi - 15 (vedi)
Con Dado(1) e DadoB(1) viene visualizzata l'uscita di un dado. Con Dado(N) e DadoB(N) con
N > 2 ne vengono generate N e ne viene visualizzato l'istogramma di distribuzione.
Uno dei due dadi è realizzato in legno, l'altro col cartoncino, nel modo illustrato sotto.
Quali sono gli istogrammi di distribuzione dei due dadi?
Fai delle prove, con N ≤ 20000, e valuta la probabilità con cui l'uscita è minore o eguale
a 3 in un caso e nell'altro.
Quale tra Dado(1) e DadoB(1) useresti per realizzare un gioco non truccato?
Esempi - 16 (vedi)
# Batti ripetutamente escher() Otterrai successive tassellazioni casuali.
escher();
escher();
...
Vedi qui per approfondimenti.
Esempi - 17 (vedi)
struttura(1*2+3) # la somma (+) del prodotto (*) di 1 per 2 e di 3
# `+`
# `*`
# [1] 1
# [1] 2
# [1] 3
struttura(1+2*3) # la "+" di 1 e del "*" di 2 per 3
# `+`
# [1] 1
# `*`
# [1] 2
# [1] 3
struttura(1+2*3+4) # la "+" della ("+" di 1 e del "*" di 2 per 3) e di 4
# `+`
# `+`
# [1] 1
# `*`
# [1] 2
# [1] 3
# [1] 4
struttura( 1*(2+3) ) # il "*" di 1 per la "+" di 2 e 3
# `*`
# [1] 1
# `(`
# `+`
# [1] 2
# [1] 3
# La parentesi "(" compare solo per specificare che il 2º termine di * non è un singolo
# termine [questo è il motivo per cui non compare ")"]
struttura( -sqrt(1+2)*3 ) # il "*" della "negaz" della ("√" della "+" di 1 e 2) per 3
# `*`
# `-`
# sqrt
# `+`
# [1] 1
# [1] 2
# [1] 3
struttura( -1-2*3^-4 ) # la "-" tra la "negaz" di 1 e il "*" di 2 per (3 alla "negaz" di 4)
# `-`
# `-`
# [1] 1
# `*`
# [1] 2
# `^`
# [1] 3
# `-`
# [1] 4
Esempi - 18 (vedi)
Per la realizzazione di grafi ad albero con opportuni comandi vedi qui.
Esempi - 19 (vedi)
Vai qui
# Controlliamo la struttura dell'ultimo grafo:
struttura( (1^2)*-3/(4-5)+6*7 )
# `+`
# `/`
# `*`
# `(`
# `^`
# [1] 1
# [1] 2
# `-`
# [1] 3
# `(`
# `-`
# [1] 4
# [1] 5
# `*`
# [1] 6
# [1] 7
# Un esercizio:
# dalle uscite relative a un termine incognito risalire ad esso e al grafo.
`+`
`/`
`*`
A
`-`
`(`
`+`
A
B
`(`
`-`
A
`(`
`+`
C
D
E
+
_______________/ \_______________
/ E
_______/ \_______
* -
__/ \__ __/ \__
A - A +
| / \
+ C D
/ \
A B
+
_______________/ \_______________
/ E
_______/ \_______
* -
__/ \__ __/ \__
A - A +
| / \
+ C D
/ \
A B
+
_______________/ \_______________
/ E
_______/ \_______
* -
__/ \__ __/ \__
A - A +
| / \
+ C D
/ \
A B
+
_______________/ \_______________
/ E
_______/ \_______
* -
__/ \__ __/ \__
A - A +
| / \
+ C D
/ \
A B
+
_______________/ \_______________
/ E
_______/ \_______
* -
__/ \__ __/ \__
A - A +
| / \
+ C D
/ \
A B
# Quindi: A*-(A+B)/(A-(C+D)) + E
# Verifica:
struttura( A*-(A+B)/(A-(C+D)) + E )
...
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#
# Da "Esempi - 12".
# Il file penisola utilizzato sopra lo abbiamo copiato e poi incollato in R. Vediamo
# come si sarebbe potuto procedere se avessimo caricato direttamente i dati da un
# file di testo con questo contenuto:
# penisola italiana
8,46
7.87,45.9
7.6,45.95
...
8,46
# Vediamo come si può esaminare il contenuto di un file. Con
readLines("http://macosa.dima.unige.it/R/penisola.txt",n=4)
# comando la visualizzazione delle prime 4 righe del file "penisola.txt". Ottengo:
# "# penisola italiana" "8,46" "7.87,45.9" "7.6,45.95"
# Capisco che il file è una tabella di coppie di dati preceduta da un commento;
# solo il primo e il secondo elemento di ogni coppia sono separati da ",".
# Metto la tabella in un file (chiamiamolo "T") col seguente comando, in cui
# specifico che devo saltare (skip) una riga (il commento) e che i dati
# sono separati da ",":
T <- read.table("http://macosa.dima.unige.it//R/penisola.txt",skip=1,sep=",")
# Non stampo la tabella per non occupare spazio; la visualizzo con:
data.entry(T) # Compare la finestra seguente che poi chiudo:
# Le due colonne di dati sono chiamate V1 e V2. Le metto in X e Y con:
X <- T$V1; Y <- T$V2 # Volendo guardo i dati con data.entry(X) e ...(Y)
# Procedo come sopra:
HF=4; BF=4
noBox=1; boX(min(X),max(X), min(Y),max(Y)); spezza(X,Y, "blue")
punto(centroP[1],centroP[2], "black")
