SCIENZE E TECNOLOGIE INFORMATICHE

[:it]

David Hettinger

La lettura di dati (input) è rappresentata dall’operatore >>.

La scrittura dei dati (output) è rappresentata dall’operatore >>.

La sintassi di un’istruzione di input è:

unità_input>>variabile;

La sintassi di un’istruzione di output è:

unità_putput<<variabile;

L’unità di input standard è la tastiera e si indica con la parola cin (console input):

cin>>raggio;

L’unità di output standard è il video e si indica con la parola cout (console output):

cout<<area;

Le definizioni della tastiera (cin) e del video (cout) sono memorizzate nel file iostream delle librerie di I/O del linguaggio. Questo significa che per poter utilizzare gli operatori di I/O sulle periferiche standard è necessario includere tale file all’inizio del programma:

#include <iostream>

Se si vogliono mostrare a video delle stringhe si usa il comando:

cout<<“Sono una stringa”;

se voglio andare a capo dopo aver mostrato una stringa si possono usare indifferentemente questi due comandi:

cout<<“Vado a capo”<<endl;

oppure

cout<<“Vado a capo \n”;

endl sta per end line

mentre \c viene detta sequenza di escape.[:]

[:it]

David Hettinger

Per casting si intende un’operazione volta a trasformare un valore di un certo tipo in un valore di un altro tipo.

Ad esempio il seguente programma fa sì che una variabile di tipo float venga salvata in una variabile di tipo int.

#include<iostream>
using namespace std;
int main()
{
int a=5;
float b=3.56;
a=b;
cout<<a;
return 0;
}

Il casting è l’azione che consente di trasformare la rappresentazione di un dato dal suo tipo originale a un altro.

La sintassi per il cambio di tipo è la seguente:

(tipo) espressione;

ad esempio

b = (int) a;

oppure in alcune versioni più recenti:

b= static_cast <int> (a);

eccone l’applicazione:

#include<iostream>
using namespace std;
int main()
{
/*****************************************/
/* conversione implicita */
/*****************************************/
int a=5;
int d,e;
float b=3.56;
a=b;
cout<<a<<endl;
/******************************************/
/* primo esempio di conversione esplicita */
/******************************************/
cout<<“Altro esempio”<<endl;
d=(int)b;
cout<<d<<endl;
/*******************************************/
/* secondo esempio di conversione esplicita */
/******************************************/
cout<<“altro esempio con la funzione static_cast”<<endl;
e=static_cast<int>(b);
cout<<e;
return 0;
}

Tale conversione comincia a diventare molto importante quando si eseguono delle divisioni tra interi e bisogna tener conto se la divisione fornisce ancora un intero o un numero decimale di cui poi tenere conto nel proseguo del programma stesso.

Ad esempio in questo programma che differenza intercorre tra la prima parte del programma e la seconda?

#include<iostream>
using namespace std;
int main()
{
int a,b;
float c;
cout<<“Inserisci il primo numero intero\n”;
cin>>a;
cout<<“Inserisci il secondo numero intero\n”;
cin>>b;
cout<<“Nessun casting: “<<a/b<<endl;
c=(float)a/b;
cout<<“Casting: “<<c;
return 0;
}[:]

[:it] 

David Hettinger

Il codice di Hamming permette di correggere gli errori nella trasmissione inserendo della ridondanza nel codice trasmesso.

Nel caso specifico il codice di Hamming(7,4) inserisce in un codice di 4 bit, 3 bit in più appunto di ridondanza necessari per verificare e correggere il codice trasmesso.

In questo codice l’errore che si corregge è 1 di un bit e si parla quindi di distanza di Hamming di valore 1.

Al codice trasmesso si aggiungono dei bit di parità alla posizione 1, 2, 4, ricapitolando alla posizione:

Il bit 1 controlla la parità dei bit 1, 3, 5, 7

Il bit 2 controlla la parità dei bit 2, 3, 6, 7

Il bit 4 controlla la parità dei bit 4, 5,6, 7

Schematicamente ho quindi:

Si nota che:

• il bit di parità 1 (p1) copre i bit 1 – 3- 5- 7
• il bit di parità 2 (p2) copre i bit 2 – 3- 6- 7
• il bit di parità 3 (p3) copre i bit 4 – 5 – 6- 7

Per leggere la tabella si deve andare a vedere la riga del Bit#

Il Bit 1 è controllato da p1

Il Bit 2 è controllato da p2

Il Bit 3 è controllato da p1 e p2

Il Bit 4 è controllato da p3

Il Bit 5 è controllato da p1 e p3

Il Bit 6 da p2 e p3

il Bit 7 da p1, p2 e p3.

In termini operativi si controllano p1, p2 e p3

messaggio corretto

vedo che solo p1 è errato allora correggo il bit1

p1 e p3 sono sbagliati.

ALGORITMO

Cerco la colonna con il segno di spunta verde su p1 e p3–> colonna 5 ossia relativa al Bit 4

Ossia partendo dalla riga con la spunta in verde si vede il relativo bit errato

Esempio:

Devo trasmetter 0101

il messaggio trasmesso sarà:

in quanto il P1 controlla la posizione 1357

P2 controlla la posizione 2367

P3controlla la posizione 4567

Mi arriva il seguente messaggio

P1 è errato!

P2 è errato!

P3 è corretto.

Siccome P1 e P2 sono errati dalla tabella vedo che è errato il bit 3 e lo correggo da 1 a 0! Ed ho il messaggio di partenza corretto senza richiedere la ritrasmissione.

Il codice di Hamming(7,4) corregge solo 1 bit e si chiama appunto distanza 1. Non corregge gli errori doppi.[:]

[:it]

Lars Meyer

[WpProQuiz 50][:]

[:it]

Claude Monet

Per compilare un programma non è obbligatorio avere un IDE particolare come Geany o BlueFish o chi più ne ha ne metta ma è sufficiente avere un editor standard come può essere notepad su windows.

Ad esempio su Linux si usa gedit

Esso si può usare o cercando dal Dash o aperto il terminale digitando gedid.

A questo punto si può digitare il programma e salvarlo con un opportuno nome.

Attenzione che il concetto di estensione, tanto caro al mondo windows, non è necessario nel mondo Unix che, purtroppo, alla fine lo sta copiando perdendo in parte la sua grande flessibilità ma forse anche complessità.

L’estensione di un file è quella parte del nome a destra del punto ad esempio:

pippo.cpp è un file con estensione cpp

pippo.phy è un file con estensione phy

Al termine si salva il file.

Per compilarlo si deve aprire un terminale e posizionarsi all’interno della directory in cui ho salvato il file.

Per fare questo si può seguire il post ABC di unix

Adesso per compilare il file si deve usare il seguente comando:

g++ -Wall -o nomeinuscita -g nomecpp

nomeuscita è il nome del file in output

nomecpp è il nome del file che ho salvato con il sorgente

se la compilazione è terminata correttamente lo si deve eseguire con il comando:

./nomeinuscita

FONDAMENTALE

Sotto Unix la lettera maiuscola e minuscola sono differenti per cui bisogna stare attenti a come si scrive.[:]

[:it]

Claude Monet

Tale post non nasce con la presunzione  di fornire un manuale completo sul mondo Linux ma solo quello di dare alcuni comandi utili per poter lavorare con quei PC che ne hanno uno installato.

Per operare sul mondo Linux vi sono varie distribuzioni ma tutte hanno  i comune alcuni comandi che qui elenco.

Per usare i comandi nativi è necessario aprire una schermata su cui poter cominciare a scrivere i comandi veri e propri del sistema operativo.

CTRL + ALT + T oppure dalla Dash digitare terminale e selezionare la relativa icona.

comparirà una schermata con un led lampeggiante intermittente.

Si pensi alla struttura interna della memoria come ed un albero e si deve cercare di capire dove si è posti all’interno di tale albero.

Per capirlo di digita il comando

ls

a questo punto se voglio entrare in una particolare directory si usa il comando

cd pippo

con pippo il nome della directory su cui voglio operare o entrarci

cd –

torno alla precedente directory[:]

[:it]

Claude Monet

Per calcolare il doppio di un numero si deve

• chiedere in input un numero
• farne il doppio
• salvare il risultato in una nuova variabile
• mostrare il risultato

Come implementare in linee di codice questa richiesta

Ecco il listato completo del programma

#include<iostream>
using namespace std;
int main()
{
int a,b;
cout<<“Inserisci un numero intero: “;
cin>>a;
b=2*a;
cout<<“Ecco il doppio del numero immesso: “<<b<<“\n”;
return 0;
}[:]

[:it]

1. 

   eupalinos ugajin

   Calcolare il doppio di un numero fornito da tastiera

2. Dato il lato, trovare il perimetro e l’area di un quadrato
3. Dato il raggio, calcolare la circonferenza e l’area del cerchio
4. Scrivere il programma per scambiare il contenuto di due variabili )occorre usare una terza variabile temporanea)
5. Calcolare la misura dell’ipotenusa di un triangolo rettangolo, noti i cateti
6. date le età di tre persone, calcolare l’età media delle persone
7. scrivere un programma che richieda in input le coordinate di due punti e scriva le coordinate del punto medio del segmento che unisce i due punti
8. scrivere un programma che richieda in input le coordinate di due punti e che scriva l’equazione della retta passante per essi ( va escluso, a priori, che la retta risulti verticale).
9. dato il prezzo di un prodotto e la percentuale di sconto, calcolare il prezzo scontato
10. dato in input il valore di un deposito bancario e il tasso di interesse annuo, calcolare gli interessi maturati dopo 25 giorni
11. scrivere un programma che, ricevute in input le misure delle diagonali di un rombo, calcoli il perimetro e l’area

[:]

[:it]

Eupalinos Ugajin

Assegnare un valore ad una variabile significa riempire la variabile con un qualcosa; questo qualcosa può essere un numero (intero positivo o negativo, reale).

Ad esempio l’istruzione:

a = a+1

incrementa di 1 il valore di a

b = x + y

la somma tra x ed y viene inserita in b.

Gli operatori più conosciuti sono:

somma +

differenza –

prodotto *

divisione /

elevamento a potenza **

altre funzione sono presenti nel seguente link

funzioni matematiche

Per utilizzare le funzioni matematiche bisogna aggiungere all’inizio del programma:

import math

e poi per accedere alla singola funzione, ad esempio radice quadrata si deve scrivere

math.sqrt(x)

I commenti sono preceduti dal carattere #[:]

[:it]

Eupalinos Ugajin

Assegnare un valore a delle variabili significa riempire la variabile scritta a sinistra con quello che si scrive a sinistra.

variabile = valore;

esempi:

area = raggio * raggio *3,14;

si noti che gli operatori aritmetici sono quelli tradizionali associati alle quattro operazioni

somma +

sottrazione –

moltiplicazione *

divisione :

Si possono usare espressioni anche di questo tipo

i = i +1 ;

dove si aggiunge alla i di sinistra il valore della i precedente.

Ad esempio:

i=10;
i= i +1;
cout<<i;

mostrerà a video 11.

in C++ si può anche scrivere

i++;

si incrementa sempre di 1 la variabile ossia

scrivere

i=i+1;

è equivalente a scrivere

i++;

quest’ultima scrittura è quella usata più comunemente;

Ecco le equivalenze tra i vari operatori di assegnamento:

Si devono conoscere anche le seguenti funzioni matematiche che sono presenti nella libreria cmath che deve essere inclusa nel programma:

#include <cmath>

• pow(x,y) per indicare x con esponente y (da notare che x e y devono essere di tipo double come pure il risultato) Ad esempio pow(x,2.0) come si vede essendo di tipo double bisogna mettere il 2.0
• sqrt(x) calcolo della radice quadrata
• ceil(x) indica il valore di un numero arrotondato all’intero superiore
• floor(x) si ottiene un numero senza parte decimale

[:]