Newsgroup: it.comp.software.tex
Titolo: la grafica delle espressioni matematiche

salve,
sono un principiante.
Ho dei problemi.
************************************************************
1� domanda)
Come faccio ad inserire una moltiplicazione in una espressione matematica?
Pu� sembrare strano, ma nessuna guida lo spiega.
Ora espongo alcune maniere che non danno l'esito corretto.
1� MANIERA:
//////////////
\begin{displaymath}
residuo\_max\_1�categoria = n1 (Esub\_max^2)=n1  (2^4)^2=n1 2^8
\end{displaymath}
//////////////////////////////////
Purtroppo in pdf ottengo: n12^8, cio� n1 viene attaccato a 2^8.
Ci� capita qualsiasi sia il n� spazi bianchi che inserisco nel codice fra n1
e 2^8.
Ci� non mi piace.
2� MANIERA:
//////////////////////////////////
\begin{displaymath}
residuo\_max\_1�categoria = n1*(Esub\_max^2)=n1*(2^4)^2=n1*2^8
\end{displaymath}
//////////////////////////////////
Purtroppo in pdf ottengo visualizzati gli asterischi.
Ci� non mi piace.
3� MANIERA:
//////////////////////////////////
\begin{displaymath}
residuo\_max\_1�categoria = n1*(Esub\_max^2)=n1*(2^4)^2=n1\quad 2^8
\end{displaymath}
//////////////////////////////////
Purtroppo in pdf ottengo un eccessivo distacco fra 2^8 ed n1.
Ci� non mi piace.
4� MANIERA:
//////////////////////////////////
\begin{displaymath}
residuo\_max\_1�categoria = n1*(Esub\_max^2)=n1*(2^4)^2=n1\2^8
\end{displaymath}
//////////////////////////////////
Purtroppo in pdf ottengo la scomparsa di 2, e cio� viene visualizzato n1^8.
Perch� avviene ci�?
************************************************************************
2� domanda)
quando devo inserire una epressione matematica fuori corpo, leggendo varie
guide,
ho visto impiegare sia
\begin{displaymath}
...
che
\begin{equation}
....
Che differenza c'� fra queste due maniere?
Per caso, se voglio enumerare l'espressione, allora sono costretto ad
impiegare \begin{equation} ,
mentre se voglio che la espressione rimnga non enumerata, allora devo
ricorrere ad
\begin{displaymath} ?
************************************************************************
3� domanda)
ho osservato che
\begin{equation}
....
pone il numero che designa la relazione matematica sempre un riga sotto, a
sinistra, della
epressione matematica.
Per esempio ci� capita se scrivo:
///////////////////////////////
\begin{equation}
residuo\_max\_2�categoria = n2*(Esub\_max^2)=n2*(2^4)^2=n2*2^8
\end{equation}
//////////////////////////////////
A me piacerebbe invece metterlo a fianco a destra della epressione
matematica.
Come ci riesco?
************************************************************************
4� domanda)
stando alla guida l'ambiente "align" tende da s� ad enumerare le espressioni
che contenga.
E per evitare ci� serve inserire: \notag al termine di ogni espressione.
Ora per� io ho scritto questo codice, proivo di \notag:
///////////////////
\begin{align}
residuo\_max\_1�categoria = n1*(Esub\_max^2)=n1*(2^4)^2=n1*2^8
residuo\_max\_2�categoria = n2*(Esub\_max^2)=n2*(2^4)^2=n2*2^8
residuo\_max\_3�categoria = n3*(2*MSBmax*LSBmax*2^8 + LSBmax*LSBmax)=
=n3*(2*2^4*2^8+2^8*2^8)^2=n3*(2^5*2^8+2^{16})
residuo\_max\_4�categoria = n4*(LSBmax*LSBmax)=n4*2^{16}
\end{align}
///////////////////////////////////////
Ebbene, non viene inserita alcuna enumerazione. Come mai?
************************************************************
5� domanda)
Non ho capito quando bisogna mettere $...$ all'interno di un testo.
Per esempio, io devo scrivere la frase:
"Le espressioni matematiche si ricavano ipotizzando che i byte impiegati
presentino il valore
massimo possibile (tutti i bit=1)"
Ora io chiedo:  in questo esempio, che cosa va messo fra i simboli: $...$
(scegliete fra le
opzioni che seguano) ?
a)niente
b)ci� che voglio, non c'� una regola, ed ognuno fa come vuole.
c)solo il numero 1:  $1$
d)solo =1: $=1$
e) $bit=1$
////////////////////////
Per esempio, io devo scrivere la frase:
"Degli 80 elementi messi a disposizione in memoria, solo 20 saranno
occupati".
I numeri 20 ed 80 li devo lasciare come testo, oppure li devo scrivere come:
$20$ e $80$?
//////////////////////////////
Per esempio, io devo scrivere la frase:
"nel caso dei fattori coincidenti (g1=f1, g2=f2, g3=f3),  basta eseguire
solo i prodotti
intermedi: f1*f1, f1*f2, f1*f3, f2*f2, f2*f3, f3*f3"
che cosa devo mettere fra i simboli: $...$?
E come posso descrivere in maniera pi� elegante dell'asterisco,  i prodotti
f1*f1, ecc?
Per esempio, ho provato a sostituire l'asterisco con il carattere "x", ma
l'effetto grafico
ottenuto non mi piace.
Qualcuno ha qualche idea?
************************************************************************
6� domanda)
devo scrivere: (2^4)^2.
Quale notazione impiego (scegliete fra "a" e "b")?
a){(2^4)}^2
b)(2^4)^2
a me sembrano valide entrambe graficamente (sia pur vengano distinte).
Quale scelgo?
************************************************************************
grazie,
adriano

 Quale scelgo?
La seconda.
Ciao
Enrico

 Le classi standard mettono il numero sulla destra. Quale classe usi?
Uso documentclass.
Ho capito da solo l'errore.
Avevo scritto il codice:
////////////////////////////////////////////////////////
\documentclass[10pt,a4paper]{report}
\usepackage[latin1]{inputenc}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amssymb}
\begin{document}
\begin{equation}
residuo\_max\_2°categoria = n2*(Esub\_max^2)=n2*(2^4)^2=n2*2^8
\end{equation}
\end{document}
////////////////////////////////////////////////////////
Ebbene, è bastato togliere le righe vuote dentro l'ambiente
"equation", per
eliminare il problema.
Dunque le  righe vuote fanno danni sia nell'ambiente "displaymath" che
"equation".
E' così?
adriano


ho delle nuove domande sugli stessi argomenti del mio post iniziale.
1� domanda)
nella programmazione C esiste la possibilit� di commentare:
a)solo un riga  (//)
b)una intera porzione di testo indicando solo dove inizia e dove finisce
questa porzione di testo, senza stare a mettere
un simbolo di commento per ogni riga.(/*...*/)
Ora in latex per commentare solo una riga di testo basta impiegare "%".
Esiste la possibilit� per commentare tante righe di testo tutte assieme,
mettendo un apposito
simbolo all'inizio ed alla fine di questa porzione, come avvenga in C?
Infatti sarebbe un comando molto comodo.
****************************************************************************
*********
2� domanda)
Se scrivo:
///////////////////////
\begin{align}
\textit{residuo\_max\_1�categoria}
\end{align}
//////////////////////
allora nel file pdf � tutto ok.
Invece se scrivo:
/////////////////
\begin{align}
\textit{residuo\_max\_1�categoria}&= n1\cdot(\textit{Esub\_max^2})
\end{align}
//////////////////
allora nel file pdf non viene visualizzato: "Esub\_max^2".
perch�?
****************************************************************************
*********
3� domanda)
Quando nelle epressioni matematiche metto \cdot esso va messo appiccicato
alle variabili a cui si applica.
Ci� mi rende difficile leggere il codice che ho scritto.
Allora io pensavo: posso mettere gli spazi prima e dopo "\cdot"?
Cio� posso trasformare:
residuo\_max\_4�categoria = n4\cdot(2\cdotMSBmax\cdotLSBmax\cdot2^8 +
LSBmax\cdotLSBmax)=n4\cdot(2^{24}+2^{16})
nel neocodice:
residuo\_max\_4�categoria = n4 \cdot (2 \cdot MSBmax \cdot LSBmax \cdot 2^8
+ LSBmax \cdot LSBmax)=n4 \cdot (2^{24}+2^{16})
?
L'effetto grafico � simile, solo che ci sono pi� spazi.
Va bene lo stesso?
****************************************************************************
*********
4� domanda)
ho scritto questo codice:
///////////////////////////////////////////
\begin{equation}
\begin{align}
%residuo\_max\_3�categoria = n3*(Esub_max^2)=n3*(2^4)^2=n3*2^8
\textit{residuo\_max\_3�categoria} &=
n3\cdot(\textit{Esub\_max}^2)=n3\cdot(2^4)^2=
n3\cdot2^8\\
%residuo\_max\_4�categoria = n4*(2*MSBmax*LSBmax*2^8 +
%LSBmax*LSBmax)=n4*(2^{24}+2^{16})
\textit{residuo\_max\_4�categoria} &=
 n_4 \cdot (2 \cdot \textit{MSBmax} \cdot \textit{LSBmax} \cdot 2^8 +
\textit{LSBmax} \cdot \textit{LSBmax})=
n_4 \cdot (2^{24}+2^{16})\\
\end{align}
\end{equation}
///////////////////////////////////////
perch� viene enumerata solo la espressione di residuo_max_4�_categoria ma
non la residuo_max_5�_categoria?
****************************************************************************
*********
5� domanda)
non ho capito quando serva impiegare il comando: "\textit{".
Esso va impiegato solo per indicare le grandezze/variabili simboliche
all'interno delle
espressioni matematiche fuori corpo?
Oppure anche se le espressioni siano in corpo?
Oppure esso va impiegato anche se mi limito a citare il nome di una
variabile in un testo?
Per esempio, se voglio scrivere il testo: "la variabile var � a 32 bit",
allora devo scrivere il
codice (scegliete fra le opzioni "a" o "b"):
a) la variabile \textit{var} � a $32$ bit
b) la variabile "var" � a $32$ bit
****************************************************************************
*********
7� domanda)
devo inserire delle frecce (l'implicazione logica) in un testo (in corpo).
avevo inizialmente scritto:
\begin{itemize}
\item la soglia � gi� stata oltrepassata -> l'esito � 'V'.
\item la soglia non � oltrepassabile, anche se i calcoli residui diano il
contributo massimo loro consentito -> l'esito � 'R'.
\item i calcoli residui sono terminati -> l'esito � 'V' se
d\_varianza\_finale<0, mentre vale 'R' se d\_varianza\_finale > 0.
\end{itemize}
poi l'ho trasformato in:
///////////////////////////////////////
\begin{itemize}
\item la soglia � gi� stata oltrepassata \Rightarrow l'esito � 'V'.
\item la soglia non � oltrepassabile, anche se i calcoli residui diano il
contributo massimo loro consentito \Rightarrow l'esito � 'R'.
\item i calcoli residui sono terminati \Rightarrow  l'esito � 'V' se
d\_varianza\_finale<0, mentre vale 'R' se d\_varianza\_finale>0.
\end{itemize}
///////////////////////////////////////
Perch� nel file pdf le 3 voci non vengono pi� messe su tre righe distinte?
****************************************************************************
*********
grazie,
adriano

 Perch� nel file pdf le 3 voci non vengono pi� messe su tre righe distinte?
Se guardi bene, scopri che la compilazione ha dato errori: il simbolo 
\Rightarrow richiede il modo matematico, come tutte le formule 
successive.
\begin{itemize}
\item la soglia � gi� stata oltrepassata $\Rightarrow$ l'esito � `V'.
\item la soglia non � oltrepassabile, anche se i calcoli residui diano 
il contributo massimo loro consentito $\Rightarrow$ l'esito � `R'.
\item i calcoli residui sono terminati $\Rightarrow$ l'esito � `V' se
$\textit{d\_varianza\_finale}<0$, mentre vale `R' se 
$\textit{d\_varianza\_finale}>0$.
\end{itemize}
Non userei il simbolo, per�; "se la soglia � stata oltrepassata, 
allora l'esito � `V'." Nota la virgoletta aperta.
Ciao
Enrico

grazie ad Enrico per le risposte.
 ho delle nuove domande sugli stessi argomenti del mio post iniziale.
Premessa: il codice completo a cui le domande si riferiscono � posto alla
fine di questo post.
**************************************************************************
1� domanda)
Non capisco perch� il compilatore mi dia questo errore (fra i tanti che
individua, quasi tutti
riferiti all'impiego di displaymath) alla riga 88, dove � presente il
codice:
//////////////////////////////////////
Pertanto, sommando questi contributi, si ricava:
\begin{displaymath}
\textit{residuo\_max_{32}}=n_3 \cdot 2^{24}+(n_3+n_2) \cdot 2^{16}+n_1 \cdot
2^8
\end{displaymath}
//////////////////////////////////////
L'aspetto strano � che se io prelevo la porzione di codice incriminata e la
inserisco in un neofile, non mi d�
alcun errore.
L'errore che mi d� � questo:
//////////////////////////////////////
l.88 \textit{residuo\_max_{32}}
                               =n_3 \cdot 2^{24}+(n_3+n_2) \cdot 2^{16}+n_1
...
I've inserted a begin-math/end-math symbol since I think
you left one out. Proceed, with fingers crossed.
! Extra }, or forgotten $.
\textdef@ ...th {#1}\let \f@size #2\selectfont #3}
                                                  }
l.88 \textit{residuo\_max_{32}}
                               =n_3 \cdot 2^{24}+(n_3+n_2) \cdot 2^{16}+n_1
...
I've deleted a group-closing symbol because it seems to be
spurious, as in `$x}$'. But perhaps the } is legitimate and
you forgot something else, as in `\hbox{$x}'. In such cases
the way to recover is to insert both the forgotten and the
deleted material, e.g., by typing `I$}'.
! Extra }, or forgotten $.
\textdef@ ...h {#1}\let \f@size #2\selectfont #3}}
//////////////////////////////////////////
**************************************************************************
2� domanda)
Non capisco neanche perch� mi dia l'errore alla riga 162, dove � presente il
codice:
//////////////////////////////////////////
AL TERMINE DEL 5� PASSO
Le istruzioni che seguono servono per implementare nella maniera efficiente
il calcolo di \textit{residuo\_max_{32}}.
//////////////////////////////////////////
L'errore che il compilatore mi d� �:
//////////////////////////////////////////
l.162 il calcolo di \textit{residuo\_max_{32}}
                                              .
I've inserted a begin-math/end-math symbol since I think
you left one out. Proceed, with fingers crossed.
! Extra }, or forgotten $.
<recently read> \egroup
l.162 il calcolo di \textit{residuo\_max_{32}}
                                              .
I've deleted a group-closing symbol because it seems to be
spurious, as in `$x}$'. But perhaps the } is legitimate and
you forgot something else, as in `\hbox{$x}'. In such cases
the way to recover is to insert both the forgotten and the
deleted material, e.g., by typing `I$}'.
! Missing $ inserted.
<inserted text>
                $
//////////////////////////////////////////
**************************************************************************
ora allego il codice latex completo a cui si riferiscono gli errori del
compilatore:
**************************************************************************
\documentclass[10pt,a4paper]{report}
\usepackage[latin1]{inputenc}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amssymb}
\begin{document}
IL CALCOLO DI RESIDUOMAX
Come gi� esposto nel pragrafo..., al termine di ogni passo, si verifica se
la disugualianza oggetto del test: $(d\_varianza < 0)$ sia gi� verificata.
Se ``s�" allora si arrestano i calcoli, perch� si conosce gi� l'esito:
``voce".
Invece, se ``no", allora al termine di ogni passo, si calcola il contributo
massimo alla varianza ottenibile nel caso migliore (estremo) degli Esub
residui, in base alla loro ripartizione nelle categorie (e pertanto senza
analizzarne i singoli valori).
Se esso consenta di verificare la disuguglianza oggetto del test, allora si
prosegue con i calcoli, altrimenti ci si arresta, perch� l'esito � gi� noto:
``rumore"
Ora noi esponiamo quanto valga \textit{residuo\_max} al termine di ogni
passo.
Le espressioni matematiche di \textit{residuo\_max}, in funzione del n�
elementi Esub che appartengano ad ogni categoria i-esima,  si ricavano
ipotizzando che i byte degli \textit{Esub} impiegati nei passi consecutivi,
presentino il valore massimo possibile (tutti i bit a~$1$1 $\leftrightarrow
Esub=255$).
In realt�, come indicato nel paragrafo...,\textit{residuo\_max32} viene
calcolato ipotizzando che il loro valore massimo sia $256$, al fine di
semplificare il calcolo di questa espressione matematica, e cio� si calcola
un maggiorante di \textit{residuo\_max}.
Ecco come si calcolno i valori di \textit{residuo\_max}.
AL TERMINE DEL 1� PASSO
\begin{align}
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_1�categoria} &= n_1
\cdot(\textit{Esub\_max}^2)=n_1\cdot {(2^4)}^2=n_1 \cdot 2^8   \notag  \\
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_2�categoria} &= n_2 \cdot (\textit{Esub\_max}^2)=n_2
\cdot(2^4)^2=n_2 \cdot 2^8    \notag  \\
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_3�categoria} &= n3 \cdot (\textit{Esub\_max}^2)=n_3
\cdot(2^4)^2=n_3 \cdot 2^8   \notag  \\
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_4�categoria} &= n_4 \cdot (2 \cdot \textit{MSBmax}
\cdot \textit{LSBmax} \cdot 2^8 + \textit{LSBmax} \cdot \textit{LSBmax})=n_4
\cdot (2^{24}+2^{16})   \notag  \\
\end{align}
(della $4$� categoria � gi� stato considerato il contributo:
$\textit{MSBmax} \cdot \textit{MSBmax}$ in questo $1$�passo).
Pertanto, sommando questi contributi, si ricava:
\begin{displaymath}
\textit{residuo\_max32}=(2 \cdot n_4+n3) \cdot 2^{24}+(n_4+n_2) \cdot
2^{16}+n_1  \cdot 2^8;
\end{displaymath}
AL TERMINE DEL 2� PASSO
\begin{align}
\textit{residuo\_max\_1�categoria} &= n_1 \cdot (\textit{Esub\_max}^2)=n_1
\cdot (2^4)^2=n_1 \cdot 2^8  \notag  \\
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_2�categoria} &= n_2*(\textit{Esub\_max}^2)=n2 \cdot
(2^4)^2=n_2  \cdot 2^{16} \notag \\
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_3�categoria} &= n_3 \cdot (\textit{Esub\_max}^2)=n3
\cdot (2^4)^2=n_3 \cdot 2^{24} \notag  \\
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_4�categoria} &= n_4  \cdot
(\textit{LSBmax}*\textit{LSBmax})=n_4 \cdot 2^{16}  \notag \\
\end{align}
(della $4$� categoria � gi� stato considerato il contributo di
$\textit{MSBmax} \cdot \textit{MSBmax}$ e di $2 \cdot \textit{MSBmax} \cdot
\textit{LSBmax}$ nel $1$� e nel $2$� passo rispettivamente).
Pertanto, sommando questi contributi, si ricava:
\begin{displaymath}
\textit{residuo\_max_{32}}=n_3 \cdot 2^{24}+(n_3+n_2) \cdot 2^{16}+n_1 \cdot
2^8
\end{displaymath}
AL TERMINE DEL 3� PASSO
\begin{align}
\textit{residuo\_max\_1�categoria} &= n_1 \cdot (\textit{Esub\_max}^2)=n_1
\cdot (2^4)^2=n_1 \cdot 2^8
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_2�categoria} &= n_2 \cdot (\textit{Esub\_max}^2)=n_2
\cdot (2^4)^2=n_2 \cdot 2^8
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_3�categoria} &= n_3 \cdot (2 \cdot \textit{MSBmax}
\cdot \textit{LSBmax} \cdot 2^8 + \textit{LSBmax} \cdot \textit{LSBmax})=
=n_3 \cdot (2 \cdot 2^4 \cdot 2^8+2^8 \cdot 2^8)^2=n_3 \cdot (2^5 \cdot
2^8+2^{16})
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_4�categoria} &= n_4 \cdot (\textit{LSBmax} \cdot
\textit{LSBmax})=n_4 \cdot 2^{16}
\end{align}
(della $4$� categoria � gi� stato considerato il contributo: $MSBmax \cdot
MSBmax$ e
$MSBmax \cdot LSBmax$, mentre della $3$� categoria � gi� stato considerato
il contributo: $MSBmax \cdot MSBmax$).
Pertanto, sommando questi contributi, si ricava:
\begin{displaymath}
\textit{residuo\_max_{32}}=(n_2+n_4+n_3) \cdot 2^{16}+(2^5 \cdot n_3+n_1)
\cdot 2^8;
\end{displaymath}
AL TERMINE DEL 4� PASSO
\begin{align}
\textit{residuo\_max\_1�categoria} &= n_1 \cdot (\textit{Esub\_max}^2)= n_1
\cdot (2^4)^2= n_1 \cdot 2^8
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_2�categoria} &= n_2 \cdot (\textit{Esub\_max}^2)= n_2
\cdot (2^4)^2= n_2 \cdot 2^{16}
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_3�categoria} &= n_3 \cdot (\textit{LSBmax} \cdot
\textit{LSBmax})= n_3 \cdot (2^{16})
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_4�categoria} &= n_4 \cdot (\textit{LSBmax} \cdot
\textit{LSBmax})= n_4 \cdot (2^{16})
\end{align}
(sia della $3$� che della $4$� categoria � gi� stato considerato il
contributo:
$MSBmax \cdot MSBmax$ e $MSBmax \cdot LSBmax$).
Pertanto, sommando questi contributi, si ricava:
\begin{displaymath}
\textit{residuo\_max_{32}}=(n_2+n_4+n_3) \cdot 2^{16}+n_1 \cdot 2^8;
\end{displaymath}
AL TERMINE DEL 5� PASSO
Le istruzioni che seguono servono per implementare nella maniera efficiente
il calcolo di \textit{residuo\_max_{32}}.
In questo passo esso vale:
\begin{align}
\textit{residuo\_max\_1�categoria} &= n_1 \cdot (\textit{Esub\_max}^2)= n_1
\cdot (2^4)^2= n_1 \cdot 2^8
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_2�categoria} &= n_2 \cdot (\textit{Esub\_max}^2)= n_2
\cdot (2^8)^2= n_2 \cdot 2^{16}
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_3�categoria} &= n_3 \cdot (\textit{LSBmax} \cdot
\textit{LSBmax})= n_3 \cdot (2^{16})
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_4�categoria} &= n_4 \cdot (\textit{LSBmax} \cdot
\textit{LSBmax})= 0
\end{align}
(della $3$� categoria � gi� stato considerato il contributo:
$MSBmax \cdot MSBmax$ e $MSBmax \cdot LSBmax$ mentre della $4$� � gi� stato
considerato ogni contributo).
Pertanto, sommando questi contributi, si ricava:
\begin{displaymath}
\textit{residuo\_max_{32}}=(n_2+n_3) \cdot 2^{16}+n_1 \cdot 2^8;
\end{displaymath}
Esso per� sar� calcolato cos�:
\begin{displaymath}
\textit{residuo\_max_{32}}=[(n_2+n_3) \cdot 2^8+n_1] \cdot 2^8;
\end{displaymath}
AL TERMINE DEL 6� PASSO
\begin{align}
\textit{residuo\_max\_1�categoria} &= n_1 \cdot (\textit{Esub\_max} ^2)= n_1
\cdot (2^4)^2= n_1 \cdot 2^8    \notag \\
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_2�categoria} &= n_2 \cdot (\textit{Esub\_max} ^2)= n_2
\cdot (2^4)^2= n_2 \cdot 2^{16}     \notag \\
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_3�categoria} &= n_3 \cdot (\textit{LSBmax} \cdot
\textit{LSBmax})= 0   \notag \\
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_4�categoria} &= n_4 \cdot (LSBmax \cdot LSBmax)= 0
\notag \\
\end{align}
(sia della $3$� che della $4$� categoria � gi� stato considerato ogni
contributo).
Pertanto, sommando questi contributi, si ricava:
\begin{displaymath}
residuo\_max_{32}=n_2 \cdot 2^{16}+n_1 \cdot 2^8;
\end{displaymath}
AL TERMINE DEL 7� PASSO
\begin{align}
\textit{residuo\_max\_1�categoria} &= n_1 \cdot (\textit{Esub\_max} ^2)= n_1
\cdot {(2^4)}^2= n_1 \cdot 2^8   \notag \\
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_2�categoria} &= n_2 \cdot (\textit{Esub\_max} ^2)= 0
\notag \\
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_3�categoria} &= n_3 \cdot (\textit{LSBmax} \cdot
\textit{LSBmax})= 0  \notag  \\
%%%%%%%%%%%%%%%%%%%%%%%%%%%
\textit{residuo\_max\_4�categoria} &= n_4 \cdot (\textit{LSBmax} \cdot
\textit{LSBmax})= 0   \notag \\
\end{align}
(della $2$�, $3$� e $4$� categoria � gi� stato considerato ogni contributo):
Pertanto, sommando questi contributi, si ricava:
\begin{displaymath}
\textit{residuo\_max_{32}}=n_1 \cdot 2^8
\end{displaymath}
\end{document}
**************************************************************************
grazie,
adriano

 In realt�, come indicato nel paragrafo...,\textit{residuo\_max32} viene
$\textit{residuo\_max}_{32}$
Gli indici possono essere inseriti solo in modo matematico.
Ciao
Enrico

codice:
Non solo alla riga 88, anche il secondo problema che segnali � dello
stesso tipo e ce ne sono alcuni altri ancora sempre dello stesso tipo.
Se vuoi che il "32" sia un pedice segui il consiglio di Enrico, mentre
se vuoi che sia in carattere normale ma separato da un "_" dal resto
del nome ("residuo_max_32") devi semplicemente mettere il carattere
"\" prima del trattino orizzontale "\_" e puoi anche togliere le
graffe attorno a "32".
Il carattere "_" indica che il carattere che segue deve essere un
pedice, ma funziona solo nel modo matematico; Tu mettendolo dentro a
\textit{} sei momentanemanete uscito dal modo matematico.
A proposito, controlla il log (e anche l'otput) perche hai alcune
segnalazioni di "Overfull \hbox". Forse ti converrebbe accorciare il
nome delle variabili altrimenti alcune equazioni sono troppo lunghe.
 
-- 
Ciao, Dano

grazie per i chiarimenti.
però ho  errori di compilazione che non capisco.
ho vari errori di compilazione che non capisco.
******************************************************************
1° domanda)
Perchè il codice che segua non viene compilato?
///////////////////////////////////////////
\documentclass[10pt,a4paper]{report}
\usepackage[latin1]{inputenc}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amssymb}
\begin{document}
\empht{il progetto \textit{proge\_tutto\_global\_wfd\_wav\_txt}}
\end{document}
///////////////////////////////////////
Per caso il problema sta nel fatto che gli operatori: "\empht" ed
"\textit" non possano
essere nidificati?
Infatti se elimino \empht allora l'errore scompare.
******************************************************************
2° domanda)
Perchè il codice che segua non viene compilato?
///////////////////////////////////////////
\documentclass[10pt,a4paper]{report}
\usepackage[latin1]{inputenc}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amssymb}
\begin{document}
\empht{eseguo i confronti if($\textit{d\_varianza}_{64} < \textit
{residuo\_max}_{32}$) calcolando il valore esatto della loro
differenza}.
\end{document}
///////////////////////////////////////////////
Per caso il problema sta nel fatto che gli operatori: "\empht" ed
"\textit" non possano
essere nidificati?
Infatti se elimino \empht allora l'errore scompare.
******************************************************************
3° domanda)
Perchè il codice che segua non viene compilato?
/////////////////////////////////////////////////
\documentclass[10pt,a4paper]{article}
\usepackage[latin1]{inputenc}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amssymb}
\begin{document}
Pertanto il valore $k \vdot \textit{AVV}$ funge da soglia
discriminante fra la etichetta ``rumore'' e la etichetta ``voce''.
\end{document}
/////////////////////////////////////////////
******************************************************************
4° domanda)
Perchè il codice che segua non viene compilato?
/////////////////////////////////////////////
\documentclass[10pt,a4paper]{article}
\usepackage[latin1]{inputenc}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amssymb}
\begin{document}
I vincoli progettuali sono imposti soprattutto dal \mu controllore.
\end{document}
/////////////////////////////////////////////
******************************************************************
5° domanda)
Perchè il codice che segua non viene compilato?
/////////////////////////////////////////////
\documentclass[10pt,a4paper]{report}
\usepackage[latin1]{inputenc}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amssymb}
\begin{document}
\begin{displaymath}
$\textit{var}(\textit{frame\attuale})>k \cdot \textit{var}(\textit
{frame\_rumore\_riferimento})$
\end{displaymath}
\end{document}
/////////////////////////////////////////////
******************************************************************
grazie,
adriano


Ciao
Enrico

 nome delle variabili altrimenti alcune equazioni sono troppo lunghe.
In che senso le devo accorciare? Mi puoi fare un esempio?
Perchè il codice che allego di seguito mi dà  "Overfull \hbox" anche
in righe senza equazioni, come nelle righe 99-100 che contengono la
frase che segua:
"Ora, dire che $1$ byte di una variabile sia dedicato alla componente
frazionaria è equivalente a dire che la variabile contenga il valore
della grandezza moltiplicato per $256$".
??
Questo errore lo dà anche i vostri compilatori ?
Questo errore è dovuto al fatto che ho l'hard disk pieno ed il
computer vecchio, o non c'entra niente?
Perchè se estraggo la porzione di codice incriminata, e la inserisco
nel neofile, allora questi errori scompaiono?
Ecco il codice latex completo che mi dà questi errori:
******************************************
\documentclass[10pt,a4paper]{report}
\usepackage[latin1]{inputenc}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amssymb}
\usepackage[italian]{babel}
\usepackage{comment}
\begin{document}
APPROCCIO TEORICO CONCETTUALE
Ora viene esposto l'elenco delle strategie impiegate per rendere il
codice efficiente.
Esso, come già detto, trae origine dalle considerazioni esposte
nell'approccio bottom-up.
Per una loro visuale riepilogativa che vede queste strategie
sottoforma di scelte progettuali fra le varie alternative, si veda
l'albero delle scelte, esposto in fig ...
Ecco l'elenco delle scelte teorico-concettuali:
\begin{enumerate}
\item \emph{Si elaborano i campioni troncati ad $8$ bit, anzichè i
campioni a $10$ bit forniti dal ADC}.
Infatti l'esito del test:
\begin{displaymath}
\textit{var}(\textit{frame\_attuale})>k \cdot \textit{var}(\textit
{frame\_rumore\_riferimento})
\end{displaymath}
nel $99\%$ dei casi non cambia se il test venga eseguito considerando
i campioni a $10$ bit, o troncati ad $8$ bit.
Il $1\%$ dei casi in cui l'esito cambi, si verifica nel caso in cui ci
si trovi vicino la soglia, e quindi quando la scelta `V' o `R' per
l'esito del test, sia pressochè arbitraria.  A fronte di questa
lievissima approssimazione nell'esito del test, si guadagna tantissimo
al fine della efficienza statistica.
Infatti ciò comporta:
\begin{itemize}
\item
l'impiego delle variabili statisticamente più corte sia per contenere
gli \textit{Esub}, che l'energia, che i quadrati degli \textit{Esub}
(ciò è giustificato dalle scelte consecutive).
\item
l'impiego di operazioni aritmetiche multibyte che agiscano su operandi
più corti.
\end{itemize}
Questa scelta comporta che ogni \textit{s(i)} appartenga
all'intervallo [-128, 127)
Il prezzo da pagare è il dovere troncare i campioni da $10$ ad $8$
bit, ciò è eseguibile dividendo i campioni per $4$, tramite
l'istruzione assembly DIV.
In ogni caso questo costo computazionale è inferiore a quanto si
guadagna in efficienza a livello statistico da questa scelta.
\item \emph{si calcola la varianza tramite l'espressione fornita dal
teorema della varianza}:
\begin{displaymath}
\textit{var}=<\textit{Esub}^2>-<\textit{Esub}>^2
\end{displaymath}
Infatti questa scelta richiede: il calcolo dell'energia, $20$
moltiplicazioni $3 \cdot 3$, e $1$ sottrazione a $4$ byte.
Invece, se noi impiegassimo la definizione della varianza:
\begin{displaymath}
\textit{var}=1/N \cdot \sum{(\textit{Esub}-<\textit{Esub}>)^2}
\end{displaymath}
allora il calcolo della varianza richiederebbe: $20$ sottrazioni a $4$
byte e $20$ moltiplicazioni $3 \cdot 3$. Si capisce allora come
l'impiego della varianza comporti i calcoli più efficienti.
\item \emph{sostituisco il test: ? $\textit{var}(\textit{frame
\_attuale})>  k \cdot \textit{var}(\textit{frame\_rumore\_ref})$ con
il test: ? $5120 \cdot \textit{var}(\textit{frame\_attuale})>  k \cdot
5120 \cdot \textit{var}(\textit{frame\_rumore\_ref})$}.
Cioè si sceglie di comparare le varianze amplificate.
Questa scelta nasce dalla esigenza di limitare al massimo le divisioni
multibyte, senza compromettere nè la efficienza e nè la accuratezza
dei calcoli.
Per evitare la divisione per $N=20$ prevista dal fattore comune
presente nella espressione della varianza fornita dal teorema della
varianza, si decide dapprima di moltiplicare la varianza per $20$.
Ora rimane da eseguire solo la divisione per $20$ prevista dal calcolo
della potenza media:
\begin{displaymath}
<\textit{Esub}>=\textit{energia}/20=\sum(\textit{Esub})/20.
\end{displaymath}
Essa creerà i valori con la virgola.
Per limitare la perdita di accuratezza si decide di gestire la $\textit
{energia}^2/20$ in virgola fissa, con $1$ byte dedicato alla
componente frazionaria.
Esso serve molto se l'energia sia circa $0$.
Ora, dire che $1$ byte di una variabile sia dedicato alla componente
frazionaria è equivalente a dire che la variabile contenga il valore
della grandezza moltiplicato per $256$.
Pertanto ciò equivale a gestire la grandezza: $\textit{energia}^2
\cdot 256/20$.
Ora ciò significa che si confrontano:
\begin{displaymath}
? 256 \cdot 20 \cdot \textit{var}(\textit{frame\_attuale})>  k \cdot
256 \cdot 20 \cdot \textit{var}(\textit{frame\_rumore\_ref})
\end{displaymath}
Cioè si confrontano le varianze amplificate del fattore $5120$, e cioè
amplificate di $20$ con $1$ byte dedicato alla componente frazionaria.
Per evitare del tutto le divisioni si sarebbe potuto moltiplicare la
varianza per $400$ anzichè per $N=20$. Ciò avrebbe comportato il
dovere moltiplicare gli $\textit{Esub}^2$ per $N=20$.
Questa scelta è efficiente se vengano calcolati tutti i quadrati.
Nel presente contesto però, avendo già scelto di suddividere il
calcolo degli \textit{Esub} in $9$ passi, (la scelta n° ...), e di
inserire dei test dopo ogni passo per capire se valga la pena
proseguire nel procedimento, questa scelta comporterebbe il dovere
moltiplicare per $20$ i contributi $\textit{Esub}^2$ finora calcolati,
al termine di ogni passo, e quindi fino a $9$ volte nel caso peggiore.
Ciò sarebbe inefficiente. Ecco allora la scelta di moltiplicare per
$20$ anzichè per $400$.
\item \emph{Si classificano gli \textit{Esub} in $5$ categorie}:
a seconda del n° byte richiesti per contenere il quadrato del valore
\textit{Esub} considerato.
Se non fosse per il singolo caso estremo: $\textit{Esub}=2^{16}$,
\textit{Esub} sarebbe contenibile in $2$ byte.
La presenza di questo caso estremo (improbabile, ma a rigore non
impossibile) comporta che \textit{Esub} vada tenuta memorizzata in
almeno $3$ byte.
Il C però prevede i tipi interi a $2$ o a $4$ byte, ma non a $3$ byte.
Pertanto serve contenere ogni \textit{Esub} in una variabile a $32$
bit, per essere sicuri di tenerne memorizzato ogni bit.
Ora noi classifichiamo i $20$ \textit{Esub} in $5$ categorie, a
seconda del n° byte richiesti.
Si parte dal presupposto che ogni $s(i)$ appartiene all'intervallo: $
(-128, +127) \Rightarrow abs(s(i))$ appartiene ad: $[0,128]=[0,2^7]
\Rightarrow abs(s(i))^2$ appartiene: $[0,2^{14}] \Rightarrow \textit
{Esub}=\sum(s(i))$ appartiene: $[0,2^{16}] \Rightarrow $ al massimo
vale: $\textit{Esub}=2^{16}$
per mantenere memorizzati i quadrati di \textit{Esub}, servono da $1$
a $3$ byte.
\begin{itemize}
\item
1° categoria: \textit{Esub} appartiene all'intervallo $[0,2^4)
\Rightarrow \textit{Esub}^2$ appartiene all'intervallo: $[0,2^8)
\Rightarrow \textit{Esub}^2$ sta in $1$ byte.
\item
2° categoria: \textit{Esub} appartiene all'intervallo $[2^4,2^8)
\Rightarrow \textit{Esub}^2$ appartiene all'intervallo : $[0,2^{16})
\Rightarrow \textit{Esub}^2$ sta in $2$ byte.
\item
3° categoria: \textit{Esub} appartiene all'intervallo $[2^8,2^{12})
\Rightarrow \textit{Esub}^2$ appartiene all'intervallo :$[0,2^{24})
\Rightarrow \textit{Esub}^2$ sta in $3$ byte.
\item
4° categoria: \textit{Esub} appartiene all'intervallo $[2^{12},2^{16})
\Rightarrow \textit{Esub}^2$ appartiene all'intervallo :$[0,2^{32})
\Rightarrow \textit{Esub}^2$ sta in $4$ byte.
\item
5° categoria: $\textit{Esub}=2^{16} \Rightarrow \textit{Esub}^2=2^{32}
\Rightarrow \textit{Esub}^2$ sta in $5$ byte, ma solo il \textit{MSB}
ha un contenuto informativo (e per di più è noto aa priori, perchè si
sa che vale 1).
Questo caso si verifica solo se ogni \textit{s(i)} vale:
$s(i)=-128$ nel subframe j-esimo attuale.
Infatti $s(i)=s(i)\_max=2^7 \Rightarrow (s(i)\_max)^2=2^{14}
\Rightarrow Esub\_max=2^{16}$
\end{itemize}
Grazie a questa classificazione degli Esub, è possibile rendere molto
efficiente, al livello statistico, la implementazione del metodo wfd.
Infatti questa scelta consente:
\begin{itemize}
\item
di minimizzare il n° byte del fattore di ingresso \textit{Esub} nel
calcolo del quadrato $\textit{Esub}^2$, e quindi di impiegare le
moltiplicazioni $1 \cdot 1$, $2 \cdot 2$, al posto delle generiche
moltiplicazioni $3 \cdot 3$ che servirebbero se \textit{Esub} venga
memorizzato in $3$ byte effettivi, per tenere in considerazione il
caso peggiore.
\item
di minimizzare il n° byte da travasare nel gestire gli \textit{Esub}.
\item
di rendere più efficiente il calcolo della energia del frame.
\item
 è possibile eseguire i calcoli in ordine di rilevanza, nel
contribuire a creare la varianza del frame.
\end{itemize}
Il prezzo da pagare è lo spendere tempo a svolgere questa
classificazione.
In ogni caso questo costo è inferiore a quanto ci si guadagna al
livello statistico da questa scelta.
L'idea nasce dalla constatazione che è inutile calcolare la
moltiplicazione $3 \cdot 3$ anche quando \textit{Esub} sia contenibile
in $1$ o $2$ byte, visto che le moltiplicazioni multibyte siano molto
onerose, come visto nel capitolo n°.
\item \emph{Calcolo l'energia del frame solo dopo aver svolto la
classificazione degli \textit{Esub} nelle $5$ categorie}.
Una volta deciso che vada svolta la classificazione degli \textit
{Esub}, il calcolo delle energie trae vantaggio da questa
classificazione.
Infatti essa consente di sommare gli \textit{Esub} con lo stesso n° di
byte fra di loro, prima di sommarli alla $\textit{somma\_totale}=
\textit{energia}$.
In questa maniera si evita di sommare l'energia finora cumulata agli
\textit{Esub} ad 1 byte (il che richiede $4$ byte ogni volta).
\item \emph{si approssima il calcolo: $ \cdot (256/20)$ con $ \cdot
(13)$} e cioè:
\begin{displaymath}
\textit{contributo\_energia}=\textit{energia}^2 \cdot 13;
\end{displaymath}
Questa scelta consente di evitare del tutto l'impiego delle divisioni
(che sono onerose e problematiche da gestire) nel procedimento.
Il valore $256/20$ in realtà vale $12.8$ e quindi comporta l'errore
del $0.2\%$.
Ebbene, nel $99.9\%$ dei casi l'esito del test wfd non risente di
questa approssimazione.
La quantità $256/20$ si sarebbe potuta approssimare anche in maniere
più precise.
Eccone alcune:
\begin{align}
%%%%%%%%%%%%%%%%%%%%%%%%
\textit{contributo\_energia}&=[13-(1/4)+(1/16)] \cdot \textit{energia}
^2 = 12.8125 \cdot \textit{energia}^2 \notag  \\
%%%%%%%%%%%%%%%%%%%%%%%%
\textit{contributo\_energia}&=[13-(1/8)-(1/16)] \cdot \textit{energia}
^2 = 12.8125 \cdot \textit{energia}^2 \notag  \\
%%%%%%%%%%%%%%%%%%%%%%%%
\textit{contributo\_energia}&=[13-(1/4)+(1/32)+(1/64)] \cdot \textit
{energia}^2 = 12.7969 \cdot \textit{energia}^2   \notag  \\
%%%%%%%%%%%%%%%%%%%%%%%%
\textit{contributo\_energia}&=[13-(1/8)-(1/16)-(1/64)] \cdot \textit
{energia}^2= 12.7969 \cdot \textit{energia}^2  \notag \\
%%%%%%%%%%%%%%%%%%%%%%%%
\end{align}
I test empirici però ci dicono che non serve ricorrere a ciò.
\item \emph{si elimina la componente frazionaria di \textit{d
\_varianza} appena dopo il calcolo della soglia che debba oltrepassare
il contributo alla varianza da parte di tutti i quadrati}.
Questa scelta nasce dalla constatazione che dopo aver considerato il
contributo dell'energia ad aggiornare la distanza dalla soglia, i
calcoli residui (il calcolo di tutti i quadrati) non altereranno mai
la componente frazionaria, ma solo intera.
Dunque la componente frazionaria non verrà più alterata.
Pertanto d'ora in avanti (quando rimane da considerare solo il
contributo alla varianza da parte dei quadrati $\textit{Esub}^2$) è
possibile eliminare questa componente frazionaria ad $1$ byte.
Ciò equivale a dividere per $256$ il valore di \textit{d\_varianza}
che indica quanto manca al raggiungimento della soglia.
Con questa scelta si dà la possibilità di gestire la \textit{d
\_varianza} (che inizialmente è ad $8$ byte) con soli $4$ byte, già
dal 2° passo in poi così da rendere il codice più efficiente.
\item \emph{anzichè calcolare il valore esatto della varianza del
frame attuale, mi limito a capire passo-passo se la soglia sia già
stata oltrepassata, o non sia più raggiungibile, così da evitare i
calcoli inutili: al tale fine:
\begin{itemize}
\emph{scompongo il calcolo dei quadrati $\textit{Esub}^2$ $2 \cdot 2$,
$1 \cdot 1$ byte, a seconda di quanti byte occupa \textit{Esub} nei
singoli prodotti a fattori monobyte, e li eseguo in ordine di
rilevanza percentuale nel contribuire all'avvicinarci alla soglia}.
Ecco questa scomposizione:
\begin{align}
%%%%%%%%%%%%%%%%%%%%%%%%
\textit{prodotto}&=(\textit{MSB} \cdot 2^8+\textit{LSB}) \cdot (\textit
{MSB} \cdot 2^8+\textit{LSB}) \Rightarrow \notag  \\
%%%%%%%%%%%%%%%%%%%%%%%%
\textit{prodotto}&=(\textit{MSB}^2) \cdot {2^16}+(2 \cdot \textit{MSB}
\cdot \textit{LSB}) \cdot 2^8+\textit{LSB}^2 \notag  \\
%%%%%%%%%%%%%%%%%%%%%%%%
\end{align}
Infatti osservando le figure n° del prodotto $2 \cdot 2$, si osserva
come l'incidenza di $f1 \cdot f1$ sia almeno $256$ volte maggiore
dell'incidenza del prodotto $f2 \cdot f2$, nel contribuire
all'avvicinarci alla soglia.
Ecco allora che nasce l'idea di eseguire i calcoli in ordine di
rilevanza.
I calcoli di rilevanza inferiore vengono eseguiti solo se $\textit{var}
(\textit{frame\_attuale})$ si trovi vicino la soglia, oppure se tutti
gli \textit{Esub} siano contenibili in $1$ byte.
Questo ordinamento dei calcoli in ordine di rilevanza comporta la
suddivisione dei calcoli nei 9 passi i cui indici vanno da 0 ad 8.
Il 0° passo è quello che svolge i calcoli più rilevanti.
Il 8° passo è quello che svolge i calcoli meno rilevanti.
I passi sono denominati ed eseguiti in ordine decrescente di rilevanza
(il passo $n+1$ esimo, svolge i calcoli meno rilevanti, rispetto ai
calcoli del passo n esimo, per ogni n)
Ecco questi passi:
\begin{itemize}
\item emph{0° passo}:
si calcola il contributo a \textit{d\_varianza64} degli \textit{Esub}
della 5° categoria (il loro valore è già noto a priori: $2^{16}$, e
pertanto è agevole calcolare questo contributo).
\item emph{1° passo}:
si calcola il contributo a \textit{d\_varianza64} dei prodotti a
fattori monobyte: $\textit{MSB} \cdot \textit{MSB}$ per ogni \textit
{Esub} della 4° categoria.
\item emph{2° passo}:
si calcola il contributo a \textit{d\_varianza64} dei prodotti a
fattori monobyte $2*\textit{LSB} \cdot \textit{MSB}$ per ogni \textit
{Esub} della 4° categoria .
\item emph{3° passo}:
si calcola il contributo a \textit{d\_varianza64} dei prodotti a
fattori monobyte $\textit{MSB} \cdot \textit{MSB}$ per ogni \textit
{Esub} della 3° categoria.
\item emph{4° passo}:
si calcola il contributo a \textit{d\_varianza64} dei prodotti a
fattori monobyte $2 \cdot \textit{LSB} \cdot \textit{MSB}$ per ogni
\textit{Esub} della 3° categoria.
\item emph{5° passo}:
si calcola il contributo a \textit{d\_varianza64} dei prodotti a
fattori monobyte $\textit{LSB} \cdot \textit{LSB}$ per ogni \textit
{Esub} della 4° categoria.
\item emph{6° passo}:
si calcola il contributo a \textit{d\_varianza64} dei prodotti a
fattori monobyte $\textit{LSB} \cdot \textit{LSB}$ per ogni \textit
{Esub} della 3° categoria.
\item emph{7° passo}:
si calcola il contributo a \textit{d\_varianza64} dei prodotti a
fattori monobyte $\textit{LSB} \cdot \textit{LSB}$ per ogni \textit
{Esub} della 2° categoria.
\item emph{8° passo}:
si calcola il contributo a \textit{d\_varianza64} dei prodotti a
fattori monobyte $\textit{LSB} \cdot \textit{LSB}$ per ogni \textit
{Esub} della 1° categoria.
\end{itemize}
\item
L'effetto dei prodotti monobyte inseriti nel singolo passo,
nell'avvicinarci
alla soglia, è calcolato così :
\begin{displaymath}
\textit{d\_varianza}_{64} = \textit{d\_varianza}_{64} - c_1 \cdot
[\sum_(\textit{mol_1}(i) \cdot \textit{mol_2}(i))]
\end{displaymath}
Le possibili alternative sarebbero potute essere:
\begin{align}
%%%%%%%%%%%%%%%%%%%%%%%%
$\textit{d\_varianza}_{64} = \textit{d\_varianza}_{64}-[\sum(c_1 \cdot
mol_1(i) \cdot mol_2(i))]$ \notag  \\
%%%%%%%%%%%%%%%%%%%%%%%%
$\textit{d\_varianza}_{64} = [\sum(\textit{d\_varianza}_{64}-c_1 \cdot
\textit{mol_1}(i) \cdot \textit{mol_2}(i))]$ \notag  \\
%%%%%%%%%%%%%%%%%%%%%%%%
\begin{align}
dove $c_1$ = il fattore moltiplicativo che tiene conto della eventuale
traslazione dei bit (amplificazione della opportuna potenza di $2$),
per tener conto che questi prodotti coinvolgono i byte (\textit{MSB})
non sono incolonnati a destra nella moltiplicazione multibyte eseguita
byte a byte esposta in fig. ... .
Viene scelto il metodo citato, perchè esso è nettamente più efficiente
rispetto agli altri due, in quanto minimizza sia il n° operazioni
aritmetiche, sia i byte che servono per tenere memorizzata la
sommatoria dei singoli prodotti intermedi.
Ne consegue che vengono minimizzati i travasi mono-byte da e verso la
memoria RAM, e le somme mono-byte da eseguire per aggiornare la
sommatoria per ogni subframe considerato.
\item si inserisce al termine di ogni passo il controllo se la soglia
sia già stata oltrepassata: if$(\textit{d\_varianza} < 0)$.
Pertanto al massimo vengono eseguiti $7$ controlli di queste tipologie
(esso non viene inserito dopo il passo n° 0 perchè è improbabile che
ci siano elementi appartenenti alla 5° categoria).
\item si inserisce al termine di ogni passo il controllo se con i
calcoli residui (meno rilevanti di quelli già eseguiti) sia ancora
possibile oltrepassare la soglia. Essi sono esposti nel paragrafo ...
Al tale fine vengono eseguiti i calcoli del contributo massimo dei
calcoli residui nell'avvicinarci alla soglia.
In alternativa i confronti con \textit{residuo\_max}, o i controlli se
la soglia sia già stata oltrepassata, potevano anche essere eseguiti
dopo ogni singolo prodotto, anzichè dopo ogni passo.
In questo caso però essi avrebbero appesantito troppo la esecuzione
del codice.
\begin{itemize}
\item \emph{Il contributo massimo dei calcoli residui(indicato da
\textit{residuo\_max}) viene solo stimato da un maggiorante che sia
calcolabile in maniera più semplice del valore esatto dei calcoli
residui}.
Per esempio, anzichè valutare il contributo massimo dei calcoli
residui, nella maniera approssimata:
\begin{displaymath}
n_1 \cdot (2^8-1)+n_2 \cdot (2^{16}-1)+n_3 \cdot (2^{24}-1)
\end{displaymath}
lo si stima con il maggiorante:
\begin{displaymath}
n1 \cdot 2^8+n2 \cdot 2^{16}+n3 \cdot 2^{24}
\end{displaymath}
Questa espressione infatti è meno onerosa da calcolare rispetto alle
precedenti.
Per conoscere l'espressione di \textit{residuo\_max} dopo ogni passo,
si veda il paragrafo.
\item \emph{gestisco la distanza dalla soglia, quantificata da \textit
{\textit{d\_varianza}}, con $8$ byte fino al termine del 8° passo. Da
lì in avanti la gestisco con solo $4$ byte}.
Infatti dall'analisi di \textit{residuo\_max}, si evince che il
contributo dei calcoli residui stia in $4$ byte, già al termine del 1°
passo.
Allora, il fatto che si debba proseguire al termine del 1° passo,
implica che \textit{d\_varianza} debba essere contenibile in $4$
byte.
Cioè i $4$ byte più significativi di \textit{d\_varianza} devono
valere $0$.
Pertanto il valore di \textit{d\_varianza} ad $8$ byte ($\textit{d
\_varianza}_{64}$) è troncabile in \textit{d\_varianza} a $4$ byte ($
\textit{d\_varianza}_{32}$).
Ciò comporta il dover eseguire al termine dei passi n° $2$,$3$,$4$,$5$,
$6$,$7$ i confronti a $4$ byte: if($\textit{d\_varianza}_{32} < \textit
{residuo\_max}_{32)$) al posto dei confronti if($\textit{d\_varianza}_
{64} < \textit{residuo\_max}_{32}$).
Ciò comporta la maggiore efficienza.
\item \emph{si conserva ogni grandezza nella variabile con il n°
minimo di byte necessario per contenerla nel caso peggiore}.
In questa maniera diventano efficienti sia le istruzioni di
assegnamento, che aritmetiche, visto che esse coinvolgono il n° minimo
necessario di byte.
\item \emph{si calcola $$\textit{var}(\textit{frame\_rumore\_ref})$
con l'algoritmo inefficiente}
Questa scelta nasce da due considerazioni:
\begin{itemize}
\item esso va calcolato solo una volta per tutte (ad ogni accensione
del dispositivo)
\item per esso va impiegato il procedimento diverso da quello già
scritto per il generico frame (in quanto per esso serve calcolare il
valore esatto della varianza, e non serve invece eseguire un confronto
passo-passo con una soglia di riferimento).
Dunque non conviene sprecare tempo a progettare un algoritmo
efficiente che lo calcoli, visto che la incidenza di questi calcoli,
per la intera durata di accensione del dispositivo, tende allo $0\%$.
\end{itemize}
\end{itemize}
\end{enumerate}
\end{document}
**********************************
grazie,
adriano

 ...
Ciao
Enrico

In che senso le devo accorciare? Mi puoi fare un esempio?
Quando un'equazione � troppo lunga per stare su una sola riga, la devi
spezzare in due o pi� parti da collocare su righe differenti.
Se questa suddivisione non � fatta nel modo opportuno pu� peggiorare
la leggibilit� (e credo che capiti con le tue equazioni).
Nel tuo caso prendi in esame la possibilit� di ridurre il nome di
alcune variabili, ad esempio:
al posto di "residuo_max_1�categoria" puoi scrivere "RM_1" (dove "1" �
un pedice.
Per il resto segui i consigli di Enrico Gregorio.
-- 
Dano 

 provvedimenti tu, la macchina non ci può fare niente.
Visto che non sono errori, perchè queste problematiche  impediscono di
creare il pdf del file?
Magari il latex  potrebbe visualizzarmi il file pdf  privato dei
capoversi
che il tex non sa come gestire.
Invece  non riesco a visualizzarlo. Perchè?
Inoltre non capisco come sia possibile modificare l'impaginazione
della
versione definitiva del testo, apportando le  leggere modifiche, visto
che
non riesco a visualizzare il pfd del testo, e quindi a capire che cosa
vada
modificato nel testo.
Per quanto riguarda l'idea di accorciare il nome delle variabili, non
mi
piace!
Infatti ciò rende meno comprensibile il testo.
Preferisco provare l'uso degli ambienti split, multiline.
E' una buona idea?
In pratica basta spezzare (eventualmente) solo le formule fuori corpo,
ma
non quelle in corpo. E'così?
Però mi sembra di aver capito che pur spezzandole, il problema
potrebbe
persistere. E' così?
Invece per quanto riguarda gli aspetti tipografici, mi sembra di aver
capito
che:
1)gli ambienti diplyamath, equation, align, enumerate, itemize vanno
inseriti appena dopo la riga che precede, senza lasciare lo spazio
bianco,
altrimenti essi verrebbero troppo staccati dal testo.
2)agli ambienti diplyamath, equation, align deve seguire il testo
immediatamente, senza lasciare alcuna riga vuota, a meno che il
capoverso
termini con le espressioni inserite in questi ambienti.
3)agli ambienti enumerate, itemize può seguire un riga vuota, oppure
no,
dipende di gusti.
E' corretto ciò?
Ora espongo il  nuovo codice latex (a seguito delle modifiche
apportate).
Ditemi e ora è corretto (a parte gli overfull):
******************************************
\documentclass[10pt,a4paper]{report}
\usepackage[latin1]{inputenc}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amssymb}
\usepackage[italian]{babel}
\usepackage{comment}
\begin{document}
\chapter{APPROCCIO TEORICO CONCETTUALE}
Ora viene esposto l'elenco delle strategie impiegate per rendere il
codice
efficiente.
Esso, come già detto, trae origine dalle considerazioni esposte
nell'approccio bottom-up.
Per una loro visuale riepilogativa che vede queste strategie
sottoforma di
scelte progettuali fra le varie alternative, si veda l'albero delle
scelte,
esposto in fig ...
Ecco l'elenco delle scelte teorico-concettuali:
%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{enumerate}
\item \emph{Si elaborano i campioni troncati ad $8$ bit, anzichè i
campioni
a $10$ bit forniti dal ADC}.
Infatti l'esito del test:
%%%%%%%%%%%%%%%%%%%%%%
\begin{displaymath}
\textit{var}(\textit{frame\_attuale})>k \cdot
\textit{var}(\textit{frame\_rumore\_riferimento})
\end{displaymath}
%%%%%%%%%%%%%%%%%%%%%
nel $99\%$ dei casi non cambia se il test venga eseguito considerando
i
campioni a $10$ bit, o troncati ad $8$ bit.
Il $1\%$ dei casi in cui l'esito cambi, si verifica nel caso in cui ci
si
trovi vicino la soglia, e quindi quando la scelta `V' o `R' per
l'esito del
test, sia pressochè arbitraria.  A fronte di questa lievissima
approssimazione nell'esito del test, si guadagna tantissimo al fine
della
efficienza statistica.
Infatti ciò comporta:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{itemize}
\item
l'impiego delle variabili statisticamente più corte sia per contenere
gli
\textit{Esub}, che l'energia, che i quadrati degli \textit{Esub} (ciò
è
giustificato dalle scelte consecutive).
\item
l'impiego di operazioni aritmetiche multibyte che agiscano su operandi
più
corti.
\end{itemize}
Questa scelta comporta che ogni $s(i)$ appartenga all'intervallo $
[-128,
127)$
Il prezzo da pagare è il dovere troncare i campioni da $10$ ad $8$
bit, ciò
è eseguibile dividendo i campioni per $4$, tramite l'istruzione
assembly
DIV.
In ogni caso questo costo computazionale è inferiore a quanto si
guadagna in
efficienza a livello statistico da questa scelta.
\item \emph{si calcola la varianza tramite l'espressione fornita dal
teorema
della varianza}:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{displaymath}
\textit{var}=<\textit{Esub}^2>-<\textit{Esub}>^2
\end{displaymath}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Infatti questa scelta richiede: il calcolo dell'energia, $20$
moltiplicazioni $3 \cdot 3$, e $1$ sottrazione a $4$ byte.
Invece, se noi impiegassimo la definizione della varianza:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{displaymath}
\textit{var}=1/N \cdot \sum{(\textit{Esub}-<\textit{Esub}>)^2}
\end{displaymath}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
allora il calcolo della varianza richiederebbe: $20$ sottrazioni a $4$
byte
e $20$ moltiplicazioni $3 \cdot 3$. Si capisce allora come l'impiego
della
varianza comporti i calcoli più efficienti.
\item \emph{sostituisco il test: ? $\textit{var}(\textit{frame
\_attuale})>
k \cdot \textit{var}(\textit{frame\_rumore\_ref})$ con il test: ?
$5120
\cdot \textit{var}(\textit{frame\_attuale})>  k \cdot 5120 \cdot
\textit{var}(\textit{frame\_rumore\_ref})$}.
Cioè si sceglie di comparare le varianze amplificate.
Questa scelta nasce dalla esigenza di limitare al massimo le divisioni
multibyte, senza compromettere nè la efficienza e nè la accuratezza
dei
calcoli.
Per evitare la divisione per $N=20$ prevista dal fattore comune
presente
nella espressione della varianza fornita dal teorema della varianza,
si
decide dapprima di moltiplicare la varianza per $20$.
Ora rimane da eseguire solo la divisione per $20$ prevista dal calcolo
della
potenza media:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{displaymath}
<\textit{Esub}>=\textit{energia}/20=\sum(\textit{Esub})/20.
\end{displaymath}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Essa creerà i valori con la virgola.
Per limitare la perdita di accuratezza si decide di gestire la
$\textit{energia}^2/20$ in virgola fissa, con $1$ byte dedicato alla
componente frazionaria.
Esso serve molto se l'energia sia circa $0$.
Ora, dire che $1$ byte di una variabile sia dedicato alla componente
frazionaria è equivalente a dire che la variabile contenga il valore
della
grandezza moltiplicato per $256$.
Pertanto ciò equivale a gestire la grandezza: $\textit{energia}^2
\cdot
256/20$.
Ora ciò significa che si confrontano:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{displaymath}
? 256 \cdot 20 \cdot \textit{var}(\textit{frame\_attuale})>  k \cdot
256
\cdot 20 \cdot \textit{var}(\textit{frame\_rumore\_ref})
\end{displaymath}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%










[-128,
+127] \Rightarrow abs(s(i))$ appartiene ad: $[0,128]=[0,2^7]
\Rightarrow
abs(s(i))^2$ appartiene: $[0, 2^{14}] \Rightarrow \textit{Esub}=\sum(s
(i))$
appartiene: $[0, 2^{16}] \Rightarrow $ al massimo vale:
$\textit{Esub}=2^{16}$
per mantenere memorizzati i quadrati di \textit{Esub}, servono da $1$
a $3$
byte.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{itemize}






\end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Grazie a questa classificazione degli Esub, è possibile rendere molto
efficiente, al livello statistico, la implementazione del metodo wfd.
Infatti questa scelta consente:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{itemize}
\item
di minimizzare il n° byte del fattore di ingresso \textit{Esub} nel
calcolo
del quadrato $\textit{Esub}^2$, e quindi di impiegare le
moltiplicazioni $1
\cdot 1$, $2 \cdot 2$, al posto delle generiche moltiplicazioni $3
\cdot 3$
che servirebbero se \textit{Esub} venga memorizzato in $3$ byte
effettivi,
per tenere in considerazione il caso peggiore.
\item
di minimizzare il n° byte da travasare nel gestire gli \textit{Esub}.
\item
di rendere più efficiente il calcolo della energia del frame.
\item
 è possibile eseguire i calcoli in ordine di rilevanza, nel
contribuire a creare la varianza del frame.
\end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%





%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{displaymath}
\textit{contributo\_energia}=\textit{energia}^2 \cdot 13;
\end{displaymath}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Questa scelta consente di evitare del tutto l'impiego delle divisioni
(che
sono onerose e problematiche da gestire) nel procedimento.
Il valore $256/20$ in realtà vale $12.8$ e quindi comporta l'errore
del
$0.2\%$.
Ebbene, nel $99.9\%$ dei casi l'esito del test wfd non risente di
questa
approssimazione.
La quantità $256/20$ si sarebbe potuta approssimare anche in maniere
più
precise.
Eccone alcune:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{align*}
%%%%%%%%%%%%%%%%%%%%%%%%
\textit{contributo\_energia}&=[13-(1/4)+(1/16)] \cdot \textit{energia}
^2 =
12.8125 \cdot \textit{energia}^2  \\
%%%%%%%%%%%%%%%%%%%%%%%%
\textit{contributo\_energia}&=[13-(1/8)-(1/16)] \cdot \textit{energia}
^2 =
12.8125 \cdot \textit{energia}^2   \\
%%%%%%%%%%%%%%%%%%%%%%%%
\textit{contributo\_energia}&=[13-(1/4)+(1/32)+(1/64)] \cdot
\textit{energia}^2 = 12.7969 \cdot \textit{energia}^2    \\
%%%%%%%%%%%%%%%%%%%%%%%%
\textit{contributo\_energia}&=[13-(1/8)-(1/16)-(1/64)] \cdot
\textit{energia}^2= 12.7969 \cdot \textit{energia}^2   \\
%%%%%%%%%%%%%%%%%%%%%%%%
\end{align*}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%




%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{itemize}
\emph{scompongo il calcolo dei quadrati $\textit{Esub}^2$ $2 \cdot 2$,
$1
\cdot 1$ byte, a seconda di quanti byte occupa \textit{Esub} nei
singoli
prodotti a fattori monobyte, e li eseguo in ordine di rilevanza
percentuale
nel contribuire all'avvicinarci alla soglia}.
Ecco questa scomposizione:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{align*}
%%%%%%%%%%%%%%%%%%%%%%%%
\textit{prodotto}&=(\textit{MSB} \cdot 2^8+\textit{LSB}) \cdot (\textit
{MSB}
\cdot 2^8+\textit{LSB}) \Rightarrow   \\
%%%%%%%%%%%%%%%%%%%%%%%%
\textit{prodotto}&=(\textit{MSB}^2) \cdot {2^16}+(2 \cdot \textit{MSB}
\cdot
\textit{LSB}) \cdot 2^8+\textit{LSB}^2   \\
%%%%%%%%%%%%%%%%%%%%%%%%
\end{align*}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Infatti osservando le figure n° ... del prodotto $2 \cdot 2$, si
osserva
come l'incidenza di $f1 \cdot f1$ sia almeno $256$ volte maggiore
dell'incidenza del prodotto $f2 \cdot f2$, nel contribuire
all'avvicinarci
alla soglia.
Ecco allora che nasce l'idea di eseguire i calcoli in ordine di
rilevanza.
I calcoli di rilevanza inferiore vengono eseguiti solo se
$\textit{var}(\textit{frame\_attuale})$ si trovi vicino la soglia,
oppure se
tutti gli \textit{Esub} siano contenibili in $1$ byte.
Questo ordinamento dei calcoli in ordine di rilevanza comporta la
suddivisione dei calcoli nei 9 passi i cui indici vanno da 0 ad 8.
Il 0° passo è quello che svolge i calcoli più rilevanti.
Il 8° passo è quello che svolge i calcoli meno rilevanti.
I passi sono denominati ed eseguiti in ordine decrescente di rilevanza
(il
passo $n+1$ esimo, svolge i calcoli meno rilevanti, rispetto ai
calcoli del
passo n esimo, per ogni n)
Ecco questi passi:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{itemize}
\item emph{0° passo}:

\item emph{1° passo}:








\end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\item
L'effetto dei prodotti monobyte inseriti nel singolo passo,
nell'avvicinarci
alla soglia, è calcolato così :
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{displaymath}
\textit{d\_varianza}_{64} = \textit{d\_varianza}_{64} - c_1 \cdot
[\sum_(\textit{mol_1}(i) \cdot \textit{mol_2}(i))]
\end{displaymath}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Le possibili alternative sarebbero potute essere:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{align*}
%%%%%%%%%%%%%%%%%%%%%%%%
\textit{d\_varianza}_{64} = \textit{d\_varianza}_{64}-[\sum(c_1 \cdot
mol_1(i) \cdot mol_2(i))]   \\
%%%%%%%%%%%%%%%%%%%%%%%%
\textit{d\_varianza}_{64} = [\sum(\textit{d\_varianza}_{64}-c_1 \cdot
\textit{mol_1}(i) \cdot \textit{mol_2}(i))]   \\
%%%%%%%%%%%%%%%%%%%%%%%%
\end{align*}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%5









%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{itemize}
\item \emph{Il contributo massimo dei calcoli residui(indicato da
\textit{residuo\_max}) viene solo stimato da un maggiorante che sia
calcolabile in maniera più semplice del valore esatto dei calcoli
residui}.
Per esempio, anzichè valutare il contributo massimo dei calcoli
residui,
nella maniera approssimata:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{displaymath}
n_1 \cdot (2^8-1)+n_2 \cdot (2^{16}-1)+n_3 \cdot (2^{24}-1)
\end{displaymath}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
lo si stima con il maggiorante:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{displaymath}
n1 \cdot 2^8+n2 \cdot 2^{16}+n3 \cdot 2^{24}
\end{displaymath}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Questa espressione infatti è meno onerosa da calcolare rispetto alle
precedenti.
Per conoscere l'espressione di \textit{residuo\_max} dopo ogni passo,
si
veda il paragrafo... .
\item \emph{gestisco la distanza dalla soglia, quantificata da
\textit{\textit{d\_varianza}}, con $8$ byte fino al termine del 8°
passo. Da
lì in avanti la gestisco con solo $4$ byte}.
Infatti dall'analisi di \textit{residuo\_max}, si evince che il
contributo
dei calcoli residui stia in $4$ byte, già al termine del 1° passo.
Allora, il fatto che si debba proseguire al termine del 1° passo,
implica
che \textit{d\_varianza} debba essere contenibile in $4$ byte.
Cioè i $4$ byte più significativi di \textit{d\_varianza} devono
valere $0$.
Pertanto il valore di \textit{d\_varianza} ad $8$ byte
($\textit{d\_varianza}_{64}$) è troncabile in \textit{d\_varianza} a
$4$
byte ($\textit{d\_varianza}_{32}$).
Ciò comporta il dover eseguire al termine dei passi n°
$2$,$3$,$4$,$5$,$6$,$7$ i confronti a $4$ byte:
if($\textit{d\_varianza}_{32} < \textit{residuo\_max}_{32)$) al posto
dei
confronti if($\textit{d\_varianza}_{64} < \textit{residuo\_max}_
{32}$).
Ciò comporta la maggiore efficienza.
\item \emph{si conserva ogni grandezza nella variabile con il n°
minimo di
byte necessario per contenerla nel caso peggiore}.
In questa maniera diventano efficienti sia le istruzioni di
assegnamento,
che aritmetiche, visto che esse coinvolgono il n° minimo necessario di
byte.
\item \emph{si calcola $$\textit{var}(\textit{frame\_rumore\_ref})$
con
l'algoritmo inefficiente}
Questa scelta nasce da due considerazioni:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{itemize}
\item esso va calcolato solo una volta per tutte (ad ogni accensione
del
dispositivo)
\item per esso va impiegato il procedimento diverso da quello già
scritto
per il generico frame (in quanto per esso serve calcolare il valore
esatto
della varianza, e non serve invece eseguire un confronto passo-passo
con una
soglia di riferimento).
Dunque non conviene sprecare tempo a progettare un algoritmo
efficiente che
lo calcoli, visto che la incidenza di questi calcoli, per la intera
durata
di accensione del dispositivo, tende allo $0\%$.
\end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\end{enumerate}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\end{document}
*******************************************************************
grazie,
adriano

 ...
Va meglio. Ma "a seconda del n� byte richiesti" non � italiano. Che cosa
ti impedisce di scrivere "a seconda del numero di byte richiesti"?
Le parentesi ad angolo non si ottengono con i segni < e >, ma con
i comandi \langle e \rangle.
Ciao
Enrico

 E' un congiuntivo! E nessun prof di italiano me lo ha mai corretto! 
Nessuno dei due è un motivo valido per usare "segua" in quel caso, non 
suona affatto bene.
Così su due piedi direi che una proposizione relativa può usare il 
congiuntivo se indica un evento ipotetico, non uno certo come in questo 
caso.

nessun prof di italiano me lo ha mai corretto! ;-)
Mica perch� � un congiuntivo uno lo pu� usare quando gli pare :)
"la frase che segua" ha un uso specifico in italiano, e indica la remota
eventualit� che possa seguire una frase (ed ha un tono generalmente
formale).  Se tu la frase ce la metti, non c'� un'eventualit�, c'� una
certezza, e la frase segue.


No, non � corretto.
Ho provato con PDFLaTeX sotto Windows (MikTeX 2.7) e credo ci siaano
almeno 50 segnalazioni di errore. 
Alla fine il file viene comunque compilato (ma ad ogni segnalazione
devi premere return per poter proseguire).
Ti ho inviato per e-mail il file corretto dagli errori e il relativo
pdf prodotto e ho riportato nel sorgente delle annotazioni per tutte
le correzioni eseguite.
Non invio il file sul newsgroup perch� molte righe verrebbero spezzate
complicando ulteriormente la comprensione.
Naturalmente mi sono limitato a correggere solo gli errori pi� gravi e
a riportare alcuni consigli, per il resto vedi Tu come preferisci
avere l'output.
-- 
Ciao, Dano


A me non produce il file .log.
A me, ogni file tex produce in ogni caso il file .aux e .txt.
Spesso (ma non sempre) mi produce anche il file .pdf
Il file .txt � quello che riporta gli errori di compilazione.
Per esempio per il file .tex che ho inserito nel post precedente, viene
creato questo file .txt (nell'ultima riga di questo file c'� scritto
esplicitamente che non sar� creato alcun file pdf).
Mi dite cosa devo fare per visualizzare il file .pdf,  il che mi serve per
vedere visualizzate le righe che fuoriescano dal margine, avendo inserito
"draft"?
**********************************************
This is pdfTeX, Version 3.141592-1.40.4 (MiKTeX 2.6) (preloaded
format=pdflatex 2009.4.4)  13 JUN 2009 19:38
entering extended mode
**approccio_teorico_concettuale.tex
(approccio_teorico_concettuale.tex
LaTeX2e <2005/12/01>
Babel <v3.8g> and hyphenation patterns for english, dumylang, nohyphenation,
ge
rman, ngerman, french, loaded.
("E:\MiKTeX 2.6\tex\latex\base\report.cls"
Document Class: report 2005/09/16 v1.4f Standard LaTeX document class
("E:\MiKTeX 2.6\tex\latex\base\size10.clo"
File: size10.clo 2005/09/16 v1.4f Standard LaTeX file (size option)
)
\c@part=\count79
\c@chapter=\count80
\c@section=\count81
\c@subsection=\count82
\c@subsubsection=\count83
\c@paragraph=\count84
\c@subparagraph=\count85
\c@figure=\count86
\c@table=\count87
\abovecaptionskip=\skip41
\belowcaptionskip=\skip42
\bibindent=\dimen102
)
("E:\MiKTeX 2.6\tex\latex\base\inputenc.sty"
Package: inputenc 2006/05/05 v1.1b Input encoding file
\inpenc@prehook=\toks14
\inpenc@posthook=\toks15
("E:\MiKTeX 2.6\tex\latex\base\latin1.def"
File: latin1.def 2006/05/05 v1.1b Input encoding file
))
("E:\MiKTeX 2.6\tex\latex\amsmath\amsmath.sty"
Package: amsmath 2000/07/18 v2.13 AMS math features
\@mathmargin=\skip43
For additional information on amsmath, use the `?' option.
("E:\MiKTeX 2.6\tex\latex\amsmath\amstext.sty"
Package: amstext 2000/06/29 v2.01
("E:\MiKTeX 2.6\tex\latex\amsmath\amsgen.sty"
File: amsgen.sty 1999/11/30 v2.0
\@emptytoks=\toks16
\ex@=\dimen103
))
("E:\MiKTeX 2.6\tex\latex\amsmath\amsbsy.sty"
Package: amsbsy 1999/11/29 v1.2d
\pmbraise@=\dimen104
)
("E:\MiKTeX 2.6\tex\latex\amsmath\amsopn.sty"
Package: amsopn 1999/12/14 v2.01 operator names
)
\inf@bad=\count88
LaTeX Info: Redefining \frac on input line 211.
\uproot@=\count89
\leftroot@=\count90
LaTeX Info: Redefining \overline on input line 307.
\classnum@=\count91
\DOTSCASE@=\count92
LaTeX Info: Redefining \ldots on input line 379.
LaTeX Info: Redefining \dots on input line 382.
LaTeX Info: Redefining \cdots on input line 467.
\Mathstrutbox@=\box26
\strutbox@=\box27
\big@size=\dimen105
LaTeX Font Info:    Redeclaring font encoding OML on input line 567.
LaTeX Font Info:    Redeclaring font encoding OMS on input line 568.
\macc@depth=\count93
\c@MaxMatrixCols=\count94
\dotsspace@=\muskip10
\c@parentequation=\count95
\dspbrk@lvl=\count96
\tag@help=\toks17
\row@=\count97
\column@=\count98
\maxfields@=\count99
\andhelp@=\toks18
\eqnshift@=\dimen106
\alignsep@=\dimen107
\tagshift@=\dimen108
\tagwidth@=\dimen109
\totwidth@=\dimen110
\lineht@=\dimen111
\@envbody=\toks19
\multlinegap=\skip44
\multlinetaggap=\skip45
\mathdisplay@stack=\toks20
LaTeX Info: Redefining \[ on input line 2666.
LaTeX Info: Redefining \] on input line 2667.
)
("E:\MiKTeX 2.6\tex\latex\amsfonts\amsfonts.sty"
Package: amsfonts 2001/10/25 v2.2f
\symAMSa=\mathgroup4
\symAMSb=\mathgroup5
LaTeX Font Info:    Overwriting math alphabet `\mathfrak' in version `bold'
(Font)                  U/euf/m/n --> U/euf/b/n on input line 132.
)
("E:\MiKTeX 2.6\tex\latex\amsfonts\amssymb.sty"
Package: amssymb 2002/01/22 v2.2d
)
("E:\MiKTeX 2.6\tex\generic\babel\babel.sty"
Package: babel 2005/05/21 v3.8g The Babel package
*************************************
* Local config file bblopts.cfg used
*
("E:\MiKTeX 2.6\tex\latex\00miktex\bblopts.cfg"
File: bblopts.cfg 2006/07/31 v1.0 MiKTeX 'babel' configuration
)
("E:\MiKTeX 2.6\tex\generic\babel\italian.ldf"
Language: italian 2005/02/05 v1.2q Italian support from the babel system
("E:\MiKTeX 2.6\tex\generic\babel\babel.def"
File: babel.def 2005/05/21 v3.8g Babel common definitions
\babel@savecnt=\count100
\U@D=\dimen112
)
Package babel Warning: No hyphenation patterns were loaded for
(babel)                the language `Italian'
(babel)                I will use the patterns loaded for \language=0
instead.
\l@italian = a dialect from \language0
Package babel Info: Making " an active character on input line 91.
)) ("E:\MiKTeX 2.6\tex\latex\comment\comment.sty"
\CommentStream=\write3
 Excluding comment 'comment')
(approccio_teorico_concettuale.aux)
LaTeX Font Info:    Checking defaults for OML/cmm/m/it on input line 10.
LaTeX Font Info:    ... okay on input line 10.
LaTeX Font Info:    Checking defaults for T1/cmr/m/n on input line 10.
LaTeX Font Info:    ... okay on input line 10.
LaTeX Font Info:    Checking defaults for OT1/cmr/m/n on input line 10.
LaTeX Font Info:    ... okay on input line 10.
LaTeX Font Info:    Checking defaults for OMS/cmsy/m/n on input line 10.
LaTeX Font Info:    ... okay on input line 10.
LaTeX Font Info:    Checking defaults for OMX/cmex/m/n on input line 10.
LaTeX Font Info:    ... okay on input line 10.
LaTeX Font Info:    Checking defaults for U/cmr/m/n on input line 10.
LaTeX Font Info:    ... okay on input line 10.
LaTeX Font Info:    Checking defaults for LGR/cmr/m/n on input line 10.
LaTeX Font Info:    Try loading font information for LGR+cmr on input line
10.
 ("E:\MiKTeX 2.6\tex\generic\babel\lgrcmr.fd"
File: lgrcmr.fd 2001/01/30 v2.2e Greek Computer Modern
)
LaTeX Font Info:    ... okay on input line 10.
Capitolo 1.
LaTeX Font Info:    Try loading font information for U+msa on input line 22.
("E:\MiKTeX 2.6\tex\latex\amsfonts\umsa.fd"
File: umsa.fd 2002/01/19 v2.2g AMS font definitions
)
LaTeX Font Info:    Try loading font information for U+msb on input line 22.
("E:\MiKTeX 2.6\tex\latex\amsfonts\umsb.fd"
File: umsb.fd 2002/01/19 v2.2g AMS font definitions
)
LaTeX Font Info:    Try loading font information for OMS+cmr on input line
37.
("E:\MiKTeX 2.6\tex\latex\base\omscmr.fd"
File: omscmr.fd 1999/05/25 v2.5h Standard LaTeX font definitions
)
LaTeX Font Info:    Font shape `OMS/cmr/m/n' in size <10> not available
(Font)              Font shape `OMS/cmsy/m/n' tried instead on input line
37.
 [1
{psfonts.map}]
Overfull \hbox (0.69505pt too wide) in paragraph at lines 89--91
[]\OT1/cmr/m/n/10 Ora, dire che $1$ byte di una vari-abile sia ded-i-ca-to
al-l
a com-po-nente frazionar-|
 []
[2]
Overfull \hbox (18.35545pt too wide) in paragraph at lines 120--123
[]\OT1/cmr/m/n/10 Si parte dal pre-sup-pos-to che og-ni $\OML/cmm/m/it/10
s\OT1
/cmr/m/n/10 (\OML/cmm/m/it/10 i\OT1/cmr/m/n/10 )$ ap-par-tiene
al-l'in-ter-val-
lo: $[\OMS/cmsy/m/n/10  \OT1/cmr/m/n/10 128\OML/cmm/m/it/10 ;
\OT1/cmr/m/n/10 +
127] \OMS/cmsy/m/n/10 )|
 []
Overfull \hbox (7.85112pt too wide) in paragraph at lines 120--123
\OML/cmm/m/it/10 abs\OT1/cmr/m/n/10 (\OML/cmm/m/it/10 s\OT1/cmr/m/n/10
(\OML/cm
m/m/it/10 i\OT1/cmr/m/n/10 ))$ ap-par-tiene ad: $[0\OML/cmm/m/it/10 ;
\OT1/cmr/
m/n/10 128] = [0\OML/cmm/m/it/10 ; \OT1/cmr/m/n/10 2[]] \OMS/cmsy/m/n/10 )
\OML
/cmm/m/it/10 abs\OT1/cmr/m/n/10 (\OML/cmm/m/it/10 s\OT1/cmr/m/n/10
(\OML/cmm/m/
it/10 i\OT1/cmr/m/n/10 ))[]$ ap-par-tiene: $[0\OML/cmm/m/it/10 ;
\OT1/cmr/m/n/1
0 2[]] \OMS/cmsy/m/n/10 )|
 []
[3]
Overfull \hbox (9.83978pt too wide) in paragraph at lines 200--200
[] |
 []
)
Runaway argument?
{anzich� calcolare il valore esatto della varianza del frame attuale,\ETC.
! File ended while scanning use of \emph .
<inserted text>
                \par
<*> approccio_teorico_concettuale.tex
I suspect you have forgotten a `}', causing me
to read past where you wanted me to stop.
I'll try to recover; but if the error is serious,
you'd better type `E' or `X' now and fix your file.
! Emergency stop.
<*> approccio_teorico_concettuale.tex
*** (job aborted, no legal \end found)
Here is how much of TeX's memory you used:
 1668 strings out of 95295
 18548 string characters out of 1185280
 73575 words of memory out of 1072667
 4805 multiletter control sequences out of 60000
 7296 words of font info for 28 fonts, out of 1000000 for 2000
 14 hyphenation exceptions out of 8191
 27i,11n,24p,453b,257s stack positions out of
5000i,500n,10000p,200000b,32768s
!  ==> Fatal error occurred, no output PDF file produced!
**********************************************
grazie,
adriano

 ...
E il messaggio di errore ti dice esattamente quello.
Ciao
Enrico

 avere l'output.
grazie mille.
Il problema grosso, da cui è scaturito il tutto, è che  in presenza di
certi errori, il compilatore non segnala gli errori nel file .txt, ma
si arresta al 1° errore (fra l'altro senza neanche riportare la riga
in cui capita), ed esce dalla compilazione.
Ne consegue che a me quei 50 errori non me li segnalava, ma mi
segnalava solo gli overfull.
L'aspetto strano è che è bastato correggerere solo il 1° errore
(mancava una parentesi "}" per chiudere il comando \emph), e
compilare, per ottenere finalmente il file .txt con tutti i 50 errori
presenti.
Però non  sono ancora riuscito a capire perchè, in presenza di certi
errori, il file pdf venga creato lo stesso, mentre  in presenza di
altri errori,  no.
Inoltre non  sono ancora riuscito a capire quali siano errori che
portino il compilatore ad arrestare l'analisi sintattica del codice,
senza proseguire oltre,  e quali siano invece gli errori che il
compilatore, una volta individuati, li egnali nel file .txt, e poi
prosegua.
adriano

 prosegua.
Buona norma �, quando si scrive \emph (o un qualsiasi comando con
argomento), aggiungere gi� {} e tornare indietro per scrivere il
testo da comporre in corsivo. Molti editor specializzati lo fanno
automaticamente.
Ciao
Enrico

scusate, ma ho un problema sugli stessi argomenti.
Chi mi dice come va corretto il codice che segua?
/////////////////////////////////////
\documentclass[10pt,a4paper]{report}
\usepackage[latin1]{inputenc}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amssymb}
\begin{document}
Infatti, con il codice C ... allegato, si è dedotto che, nel caso del
quadrato, dette $i$ e $j$ due varibili monobyte, e detti \textit{LO}
ed \textit{HI} ripettivamente il \textit{LSByte} ed il \textit{MSByte}
di una varibile a 2 byte,  valga:
\begin{align*}
max \{ LO(i \cdot i)\}&=249           ciò si verifica per i=53 \\
max \{ HI(i \cdot i)\}&=254           ciò si verifica per i=255 \\
max \{ LO(i \cdot j)\}&=255           ciò si verifica per i=1 e j=255 \
\
max \{ HI(i \cdot j)\}&=254           ciò si verifica per i=255 e
j=255 \\
max \{ LO[2 \cdot LO(i \cdot j)]\}&=254     ciò si verifica per i=1 e
j=127 \\
max \{ LO[2 \cdot HI(i \cdot j)]\}&=254     ciò si verifica per i=128
e j=254
\end{align*}
Pertanto, alla luce di queste considerazioni, non è detto che un
riporto comporti l'innesco di una concatenazione di riporti in ogni
byte più significativo. Ciò dipende da quale sia il valore massimo che
possano presentare i byte più significativi generati dalle altre
moltiplicazioni monobyte.
\end{document}
/////////////////////////////////////
****************************************
grazie,
adriano

 Chi mi dice come va corretto il codice che segua?
Vedo che insisti con questo congiuntivo sbagliato. :)
Mostro solo una riga, le altre si fanno allo stesso modo:
\begin{align*}
\max \{ LO(i \cdot i)\}&=249  &&\text{ci� si verifica per $i=53$} \\
...
\end{align*}
Nota che per indicare il massimo si deve usare \max; per scrivere
testo in formule si usa \text; al suo interno puoi tornare nel modo
matematico per un'altra formula. :)
Ciao
Enrico

> Chi mi dice come va corretto il codice che segua?
La frase che preceda questa frase è sbagliata! (ed anche questa) ;)