SCIENZE E TECNOLOGIE INFORMATICHE

[:it]

jacek Yerka

Si è visto come chiamare ed usare le funzioni.

Adesso si affrontano alcuni approfondimenti in particolare:

• una funzione non ne può richiamare un’altra se questa non è stata ancora definita

La dichiarazione della funzione, che si intente utilizzare nel programma, di norma, va posta in testa la programma stesso, immediatamente dopo la sezione dedicata alle direttive e alla dichiarazione delle variabili globali.

Tramite la dichiarazione, il programmatore si limita a comunicare al compilatore la sua intenzione di utilizzare una funzione che restituisca un dato di un certo tipo e che utilizza determinati parametri, riservandosi di specificarne il codice in seguito, nella fase di definizione.

Questa dichiarazione si chiama prototipo.

In pratica:

all’inizio del programma le funzioni vengono soltanto dichiarate, specificandone per ciascuna il tipo restituito e il nome dei parametri richiesti.

In questo modo si ottiene una semplice elencazione dei prototipi che facilita la comprensione del programma e realizza, in pratica la metodologia top-down.

Ad esempio il seguente programma dichiara la funzione che solo successivamente viene definita nei dettagli:

//
// Autore: Francesco Bragadin
// Oggetto: uso dei prototipi come funzioni
//

#include <iostream>

using namespace std;

// semplice definizione della fuznione
int maggiore(int a, int b);

int main()
{
int c,d;
cout<<“primo numero: “<<endl;
cin>>c;
cout<<“secondo numero: “<<endl;
cin>>d;
cout<<“il numero maggiore risulta: “<<maggiore(c,d);
return 0;
}

//dettagli della funzione
int maggiore(int a, int b)
{
int c;
if (a>b)
return a;
if (a<b)
return b;
}

 [:]

[:it]

Jacek Yerka

Il linguaggio C++ offre la possibilità di definire due funzioni con lo stesso nome che differiscono tra loro solamente per l’elenco dei parametri.

Tale diversità può riguardare sia il numero di parametri passati, sia il loro tipo.

In base al tipo e al numero di parametri passati alla funzione, il compilatore riconosce la funzione che deve essere richiamata.

Questo meccanismo di ridefinizione delle funzioni si chiama function overloading.

Ad esempio questo programma utilizza la stessa funzione che si chiama area per due cose diverse ed il compilatore interpreta e decide quale chiamare:

//
// Autore: Francesco Bragadin
// Oggetto: function overloading
//

#include<iostream>
using namespace std;

// dichiarazione prima funzione per il calcolo dell’area di un quadrato
double area(double a)
{
return a*a;
}

// dichiarazione della stessa funzione area per il calcolo del triangolo
double area(double a, double b)
{
return a*b;
}

int main()
{
int i;
double l,b,h;
cout<<“Di quale figura vuoi calcolare la superficie?”<<endl;
cout<<” 1- Quadrato”<<endl;
cout<<” 2- Triangolo”<<endl;
cin>>i;
if (i==1)
{
cout<<“Inserisci il lato del quadrato: “<<endl;
cin>>l;
cout<<“La superficie del quadrato risulta: “<<area(l);
}
if (i==2)
{
cout<<“inserisci la base del triangolo: “<<endl;
cin>>b;
cout<<“inserisci altezza del triangolo: “<<endl;
cin>>h;
cout<<“La superficie del triangolo risulta: “<<area(b,h);
}

return 0;
}[:]

[:it]

Vincent Van Gogh

La caratterizzazione dell’utilizzo della firma digitale è quella di essere:

• autentica
• integra
• non ripudio

Autentica

Si deve riconoscere l’identità del mittente

Integra

Nessuna modifica sul documento originario

Non ripudio

Il documento firmato con la firma elettronica ha valore legale e colui che la utilizza non può negare di averla sottoscritta.

Si utilizza la crittografia a chiave asimmetrica:

• si firma il documento con la chiave privata
• per verificare l’integrità e l’autenticità usano la chiave pubblica

La firma digitale che cosa è?

Si parte dal documento originale e si crea una sequenza binaria (128 o 160 bit) chiamata impronta (fingerprint) che è proprio un riassunto  del documento (digest).

Questa fingerprint utilizza la funzione hash (sminuzzare, spezzettare) che ha alcune proprietà molto importanti:

• deve identificare univocamente il messaggio, non è possibile che due messaggi differenti, pur essendo simili, abbiano lo stesso valore di hash;
• deve essere deterministico, in modo che lo stesso messaggio si traduca sempre nello stesso hash;
• deve essere semplice e veloce calcolare un valore hash da un qualunque tipo di dato;
• deve essere molto difficile o quasi impossibile generare un messaggio dal suo valore hash se non provando tutti i messaggi possibili.

Operazioni del destinatario

• Il destinatario riproduce l’impronta usando al chiave pubblica del firmatario
• avendo ricevuto il messaggio in chiaro, crea la stessa funzione di hash per creare il digest e la confronta con quella del firmatario verifica che il documento non è stato modificato

FONDAMENTALE

ogni documento ha una forma digitale diversa

Utilizzo pratico

• ci si deve rivolgere alla camera di commercio che verifica l’identità del richiedente e fornisce una chiave usb al cui interno vi è software che usa la chiave provata per firmare il documento
• si crea un documento con estensione p7m
• per poter verificare un documento si usa un software di nome dike fornito da infocert

Protocolli per la crittografia

PGP e GPG

SSH

SSL e TLS

HTTPS[:]

[:it]

 [:]

[:it]

Vincent Van Gogh

Questo programma elaborato dallo studente Daniel Amadori che segue il corso di informatica e telecomunicazioni presso IISS Galileo Galilei di Bolzano, evidenzia come si può usare la definizione tradizionale di un vettore ed applicarlo al cifrario di Cesare:

import java.io.*;

class Vigenere{
char cifrario[];

int position(char x){
int i= 0;
while( i < 26){
if(x == cifrario[i])
break;
i++;
}
return i;
}

char shifter(char x,int p){
p += position(x);
if(p < 26)
return cifrario[p];
else
return cifrario[p-26];
}

String cifratore(String x, String password){
String tmp =””;
for(int i= 0,j= 0; i < x.length(); i++,j++){
if(j >= password.length())
j= 0;
tmp += shifter(x.charAt(i), position( password.charAt(j) ) );
}
return tmp;
}
String decifratore(String x, String password){
String tmp =””;
for(int i= 0,j= 0; i < x.length(); i++,j++){
if(j >= password.length())
j= 0;
tmp += shifter(x.charAt(i), 26-position( password.charAt(j) ) );
}
return tmp;
}
Vigenere(){
cifrario = new char[26];
cifrario[0] = ‘a’;
for(int i = 1; i < 26; i++){
cifrario[i] += cifrario[i-1]+1;
}
}

}

public class crittazione {

public static void main (String args[]) {
BufferedReader input = new BufferedReader(new InputStreamReader( System.in ) );
Vigenère a = new Vigenère();

String data =””, key =””, output =””;

System.out.print(“Scegliere se cifrare o decifrare\n 1. Cifrare\n 2.Decifrare\n Cosa scegli: “);
int chose =0;
try {
chose = Integer.parseInt(input.readLine());
} catch (IOException e) {
e.printStackTrace();
}
System.out.println(“Inserire il testo:”);
try {
data = input.readLine();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println(“Inserire la chiave:”);
try {
key = input.readLine();
} catch (IOException e) {
e.printStackTrace();
}

if( chose == 1)
output = a.cifratore(data, key);
else if( chose == 2)
output = a.decifratore(data, key);
else
System.out.println(“Scelta non valida”);

System.out.println(output);
}
}

 [:]

[:it]

Vincent van Gogh

Questo programma è stato sviluppato dallo studente Simone Tagliapietra che segue il corso informatica e telecomunicazioni presso IISS Galileo Galilei di Bolzano.

Utilizza in maniera molto chiara la definizione dei metodi, il concetto di costruttore e come poter inserire i dati e poter mostrare il risultato a video

import java.io.*;

public class Rettangolo {

private int base;
private int altezza;

public void setBase() {

System.out.println(“Inserire la base: “);
BufferedReader input = new BufferedReader(new InputStreamReader(System.in)); //immissione valori letti da tastiera su buffer
try {
base = Integer.parseInt(input.readLine()); //conversione dati del buffer in int
}
catch (IOException e) {
e.printStackTrace();
}

}

public void setAltezza() {

System.out.println(“Inserire l’altezza: “);
BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
try {
altezza = Integer.parseInt(input.readLine());
}
catch (IOException e) {
e.printStackTrace();
}

}

public Rettangolo() {

base = 0;
altezza = 0;

}

public int areaRettangolo(){

return base*altezza;

}

public static void main(String[] args) {

Rettangolo r = new Rettangolo();

r.setBase();
r.setAltezza();
System.out.println(“L’area vale: “+r.areaRettangolo());

}

}

Osservazioni:

il costruttore segue  in maniera molto lineare un costruttore usato nel linguaggio C++.

Infatti, poi per poterlo usare utilizza questa inizializzazione:

Rettangolo r = new Rettangolo();

Si può inserire anche questo costruttore:

public Rettangolo(int base, int altezza) {
this.base=base;
this.altezza=altezza;
}

in questo caso si può inizializzare nella seguente maniera:

Rettangolo r = new Rettangolo(3,4);

Consiglio quindi di usare sempre i due tipi di costruttore.[:]

[:it]La gaussiana normalizzata ha equazione:

Essa ha simmetria proprio nel valor medio .

Il suo grafico varia al variare della deviazione standard. Questa figura chiarisce il concetto:

Essa è una densità di probabilità ed effettuando la sua integrazione trovo proprio la distribuzione di probabilità che fornisce la probabilità che un evento possa accadere in un intervallo.

In pratica:

Il calcolo di questo integrale non è banale e si preferisce calcolare l’integrale della stessa curva ma traslata nell’origine, standardizzandola ,ponendo:

La gaussiana normalizzata standard avrà equazione:

con media nulla ossia e deviazione standard unitaria

Questo disegno chiarisce la cosa:

In generale:

e per calcolare l’integrale in un opportuno intervallo si usa una tabella standard che lo calcola.

Ad esempio:

osservando la tabella allegata:

CLAMED-tavole-1

si deve trovare la riga corrispondente al valore e si nota che alla colonna 0.00 il valore è 0,8413.

Significa che la probabilità che un evento sia minore di 1 vale esattamente 84,13%.

Se avessi dovuto calcolare

mi sarei posto sempre sulla riga dell’1 ma alla colonna 0,01 e la probabilità sarebbe stata 0,8438 ossia in percentuale 84,38.

Ricapitolando la riga mi fornisce il valore della per un il valore intero seguito da un decimale e la colonna mi fornisce il valore corrispondente a partire dal secondo decimale.

Passaggio dalla gaussiana normalizzata a quella standard attraverso la tabella fornita

Ma se un evento  ha media e deviazione standard come faccio a collegarla alla gaussiana standard?

Devo calcolare la probabilità che il mio evento sia sempre minore di 3.

Allora dalla relazione:

andando a vedere la tabella si vede che vale 0,10 ossia il circa il 10%.[:]

[:it]

Vincent Van Gogh

Questo programma, sviluppato da Alessandro Angelone studente indirizzo informatica e telecomunicazione, implementa il cifrario di Cesare:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

class Crypter {
private static final int matrix = 3;
private String word;
private String cryptedString;

private void cryptString() {
StringBuilder crypted = new StringBuilder(word);
for (int i = 0; i < crypted.length(); i++)
crypted.setCharAt(i, (char) ((int) (word.charAt(i)) + matrix));

cryptedString = crypted.toString();
}

public Crypter() {
word = null;
}

public Crypter(String word) {
this.word = word;
cryptString();
}

public void setWord(String word) {
this.word = word;
cryptString();
}

public String getCryptedString() {
return cryptedString;
}

public static String decryptString(String word) {
StringBuilder decrypted = new StringBuilder(word);
for (int i = 0; i < decrypted.length(); i++)
decrypted.setCharAt(i, (char) ((int) (decrypted.charAt(i)) – matrix));

return decrypted.toString();
}

public String decryptString() {
StringBuilder decrypted = new StringBuilder(cryptedString);
for (int i = 0; i < decrypted.length(); i++)
decrypted.setCharAt(i, (char) ((int) (decrypted.charAt(i)) – matrix));

return decrypted.toString();
}
}

public class cifrario_sostituzione {
public static void main(String[] args) {
Crypter k = new Crypter();// = new a(“Ciao”);

try (BufferedReader input = new BufferedReader(new InputStreamReader(System.in))) {
k.setWord(input.readLine());
} catch (IOException e) {
e.printStackTrace();
}

System.out.println(“Crypted: ” + k.getCryptedString());
System.out.println(“Decrypted: ” + k.decryptString(k.getCryptedString()));
System.out.println(“Static Decrypted: ” + Crypter.decryptString(“fldr”));
}
}

 [:]

[:it]

Filippo Tommaso Marinetti

Questo programma, realizzato da Mirko Rossi, studente del corso di informatica e telecomunicazioni evidenzia come si può gestire la classe vector fornita da java.

import java.util.*;
public class VectorDemo {

public static void main(String args[]) {
// initial size is 3, increment is 2
Vector v = new Vector(3, 2);
System.out.println(“Initial size: ” + v.size());
System.out.println(“Initial capacity: ” + v.capacity());

v.addElement(new Integer(1));
v.addElement(new Integer(2));
v.addElement(new Integer(3));
v.addElement(new Integer(4));
System.out.println(“Capacity after four additions: ” + v.capacity());

v.addElement(new Double(5.45));
System.out.println(“Current capacity: ” + v.capacity());

v.addElement(new Double(6.08));
v.addElement(new Integer(7));
System.out.println(“Current capacity: ” + v.capacity());

v.addElement(new Float(9.4));
v.addElement(new Integer(10));
System.out.println(“Current capacity: ” + v.capacity());

v.addElement(new Integer(11));
v.addElement(new Integer(12));
System.out.println(“First element: ” + (Integer)v.firstElement());
System.out.println(“Last element: ” + (Integer)v.lastElement());

if(v.contains(new Integer(3)))
System.out.println(“Vector contains 3.”);

// enumerate the elements in the vector.
Enumeration vEnum = v.elements();
System.out.println(“\nElements in vector:”);

while(vEnum.hasMoreElements())
System.out.print(vEnum.nextElement() + ” “);
System.out.println();
}
}[:]

[:it]

1. 

   Vincent Van Gogh

   Definire una funzione che ripeta a video in tre righe diverse la stringa acquisita da tastiera.

2. Organizzare una funzione che acquisisca da tastiera il lato di un quadrato e ne calcoli la misura dell’area e del perimetro
3. Data la parabola, se ne calcoli il vertice, il fuoco, l’intersezione con gli assi. Le tre funzioni ricevono come parametri i coefficienti a,b,c e restituiscano il valore calcolato
4. definire una funzione che abbia come parametro un numero intero positivo e che visualizzi la sequenza dei primi 5 numeri successivi al numero dato
5. scrivere una funzione che abbia come parametri il numero dei valori e la loro somma e che calcoli la media aritmetica
6. dati in input le età di tre persone, scrivere i dati acquisiti in ordine decrescente
7. scrivere la funzione che restituisca l’età di una persona, conoscendo il suo anno di nascita (si consideri l’anno attuale come costante)
8. scrivere una funzione che abbia come parametri il prezzo di vendita e la percentuale di sconto e che restituisca il prezzo scontato.
9. scrivere una funzione che restituisca un valore booleano Vero o Falso, controllando se due rette, di cui si conoscono le equazioni, sono perpendicolari.

[:]