Newsgroup: it.comp.lang.c++
Titolo: Algebra booleana...

Ciao, ho tre valori booleani, vorrei testare quando uno o due di questi e'
TRUE, ma non tutti e tre, voglio dunque ottenere TRUE solo nei seguenti
casi:
T T F
T F F
T F T
F T T
F T F
F F T
chiamati i valori A, B, C, ho scritto:
if ((!(A && B && C)) && (A || B || C))
  DoSomething(...)
Il controllo funziona, volevo solo sapere se vi viene in mente un modo piu'
"elegante" o "canonico" di eseguire il confronto.
Di che operazione si tratta? (non ' un NAND, non e' un NOR...)
Grazie, ciao e buon lavoro, Davide.
---------------------
Davide Piras
NRC - CNRC - CANADA
davide...@nrc.ca
---------------------
-- 
Posted from 
origin.vit.iit.nrc.ca
 [132.246.41.10] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 Di che operazione si tratta? (non ' un NAND, non e' un NOR...)
Prova questa:
(A^B) || (A^C)
con le evantuali variazioni sul tema
Non so se sia elegante. Non e' canonico (e' canonica la formula che hai usato tu
che e' ricavabile direttamente dalla una mappa di Karnaught (non sono sicuro
dello spelling). Ma sicuramente e' piu' efficiente in C++.
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

 dello spelling).
Credo si scriva senza la t finale.
EMG

 Di che operazione si tratta? (non ' un NAND, non e' un NOR...)
"Ne tutti, ne nessuno"? :-)
Ciao,
Nicola
-- 
Posted from 
mail.divalsim.it
 [194.185.113.194] 


if ((!(A && B && C)) && (A || B || C))
uno debba mettersi con carta e penna a costruire
la tabella di verita' al contrario per
ricordarsi cosa aveva voluto fare quel giorno.

ricordarsi cosa aveva voluto fare quel giorno.
Se il codice e' sufficientemente commentato non credo ci sia il bisogno di
ricorrere a carta e penna.
Chiaramente nelle righe di codice che ho postato non erano inclusi i
commenti.
Ciao, Davide.
-- 
Posted from 
origin.vit.iit.nrc.ca
 [132.246.41.10] 


 "Ne tutti, ne nessuno"? :-)
LOL
not "Tutti per uno, uno per tutti"


 Quindi avrei fatto una bestialita' del tipo:
Il problema della leggibilità lo risolverei con una istanza dell'operatore
doppioslash!


 ricorrere a carta e penna.
Certo, certo.
Piu' che una soluzione al tuo problema,
il mio post voleva porre la questione:
"quanto è lecito -o conveniente- perseguire la canonicità,
la compattezza formale, l'eleganza, a discapito
della leggibilita' e della possibilità di fare
rapidamente \"mente locale\""?
Forse i piu' bravi di voi ci saranno avvezzi
ma io, certi articoli di Carlo Pescio sui template
dovevo decodificarli.
E mica sempre ci riuscivo.

 ha scritto nel messaggio
news:9b0onq$j1p$1...@serverlinux.frigoveneta.interno...


 >   DoSomething(...)
Che al crescere degli elementi diventa:
if ( ! ( A && B && C && D && E ) && ( A || B || C || D || E ) )
Poiche' tutti i predicati coinvolti compaiono nello stesso modo in
entrambe le sottoespressioni, la difficolta' di comprensione non cambia
all'aumentare del numero di predicati.
Ciao,
Nicola
-- 
Posted from 
mail.divalsim.it
 [194.185.113.194] 


 all'aumentare del numero di predicati.
Se interpretiamo il problema originale come:
"dato un numero qualsiasi di variabili booleane,
creare una funzione che restituisca VERO quando:
almeno una è vera E almeno una è falsa"
allora il problema si risolve elegantemente anche nel caso di N variabili
booleane.
Ma io ho interpretato il problema cosi':
"dato un numero qualsiasi di variabili booleane,
restituire VERO quando è vera almeno una ma non piu' di due"
ovvero, quando sono veri al massimo due elementi su N.
Non è sempre possibile trovare una espressione elegante e
compatta che sintetizza una mappa di Karnaugh, una  formula insomma.
Nei casi in cui bisogna sintetizzare una rete booleana siffatta,
nulla ci salva da un'implementazione "bruta", per esteso.
Nel caso specifico tener conto di tutte le possibili coppie su N elementi,
tramite l'algebra booleana, diventa secondo me un formulone
prolisso e incomprensibile a partire da 4-5 elementi.

 per non andar via di testa!
Gia'.
Bisognerebbe conoscere il contesto,
poichè ognuno porta la sua esperienza personale.
La mia esperienza personale è questa:
costruire applicazioni di supervisione industriale non real-time.
Non scrivo driver.
Per inciso, penso che solo quelli che scrivono driver
o applicazioni real-time o routine di calcolo
(filtri grafici, matematici etc...)
abbiano bisogno di velocita' e compattezza:
tutti gli altri, anche se usano il c++ come front-end
per un database o applicazioni web, non ne hanno bisogno.
I colli di bottiglia sono altrove, imho.

 I colli di bottiglia sono altrove, imho.
Parole sante!
--


 rapidamente \"mente locale\""?
La mia risposta sembrera' una risposta da XP ma comunque ...
fai la cosa piu' veloce da fare (non da eseguire) che e' corretta.
la leggibilità la migliori con i commenti.
l'efficienza la migliori se e solo se piu' avanti sei in grado di MISURARE che
quello specifico codice e' il tuo collo di bottiglia.


 conoscere Smalltalk o Eiffel, vero Andrea?).
Certo. Ma non mi pare che ci fosse carenza su questo fronte. La domanda era piu'
che altro stilistica. L'implementazione proposta era corretta e persino
minimale. Solo non ne era sicuro. E per esserne formalmente sicuro ... ci vuole
qualche cosa di piu' che semplice dimestichezza.


Parole sante!
Si, ma basta avere un solo membro del team di sviluppo che non è in
accordo con questa 'regola' e quando qualcun'altro deve prendere in
mano il suo codice sono ca**i amari...
Il voler far vedere che si è in grado di scrivere software ultraveloce
ed ultracompatto a prescindere dall'applicazione non è quindi
apprezzabile come lo sarebbe la semplicità e la leggibilità.
Luc.

Messa in questi termini sono d'accordo.


 la leggibilità la migliori con i commenti.
Sono d'accordo.
Personalmente pero' mi capita questo:
<preambolo>
    il mio lavoro è di realizzare supervisione e telecontrollo,
    in locale e a distanza, di impianti industriali real-time.
    E' roba che deve funzionare 24/24, 7/7 etc...
    Quando c'e' un problema -quando _sembra_ esserci un problema-
    la prima cosa che fanno quelli dell'assistenza è di imputarlo al
software.
    Molte volte si sbagliano, altre volte hanno ragione.
    Comunque io devo riprendere in mano codice che ho scritto anche
    mesi prima e riguardarlo.
</preambolo>
Ora, anche se sto esaminando un pezzo di codice e ci trovo il
commento che ci avevo appiccicato tempo addietro che mi spiega
perchè avevo fatto in un certo modo, e cosa avevo intenzione di fare
devo VERIFICARE che il codice faccia esattamente quello.
Devo rimettere in gioco il codice, in una parola sola
devo DUBITARE di quello che ho scritto.
Se c'e' un problema, il commento mi aiuta a far mente
locale piu' velocemente al fine di RICONTROLLARE il codice.
A questo punto, un guizzo stilistico,
una riga criptata, un abuso di un template mi rendono
la vita mooolto ma moooolto piu' difficile.
Per quanto mi riguarda, i benefici dell'oop mi aiutano nel mantenere
ordinato un grande progetto, in modo manutenibile ed estensibile.
Le singole linee di codice poi, cerco di scriverle come se
stessi usando -orrore- un linguaggio di scripting,
usando "frasi" brevi, semplici e chiare.

 mano il suo codice sono ca**i amari...
Come nel calcio, i fuoriclasse sono difficili da gestire.
Nella mia squadra del cuore c'č uno che
si crede un fuoriclasse perchč tenta
di dribllarne sempre uno di troppo.

 la vita mooolto ma moooolto piu' difficile
nel mio piccolo ho un compagno di classe imbecille che scrive  righe di
codice incasinato e senza commenti
e  perde un sacco di tempo per tapullare quando qualcosa non va.
Meglio una variabile in più  che uscirci di testa e far uscire di testa gli
altri che devono studiare o lavorare in gruppo con te.