Newsgroup: it.comp.lang.visual-basic
Titolo: [?] se numero è pari o dispari

ciao a tutti,
come è possibile sapere se un numero è pari o dispari?
avevo già pensato di  verificare l'ultima cifra se =1,3,5,7,9
quindi dispari, se diverso pari.
grazie
jack

 ha scritto nel messaggio
news:_2bra.15598$3M4.4...@news1.tin.it...

in matematica come faresti ?

 come è possibile sapere se un numero è pari o dispari?
domanda già posta, giusto questo mese....
Ma qualcuno cerca mai su google?
http://makeashorterlink.com/?K36B12D54
Salutoni
Sergio

 ha scritto nel messaggio
news:_2bra.15598$3M4.4...@news1.tin.it...


 ha scritto nel messaggio
news:_2bra.15598$3M4.4...@news1.tin.it...


quindi dispari, se diverso pari.
Sia value il tuo intero da testare
If value Mod 2 = 0 Then 
   'Pari
Else
   'Dispari
End if
Stefano "HappyMan"
--
Database Gate - The Powerful SQL Editor
HD Checker - The S.M.A.R.T. Hard Disk Reader
Asus Checker - CPU and Asus MB Checker
http://www.sgr.info

 ha scritto nel messaggio
news:t7bra.22631$K35.7...@news2.tin.it...


 ha scritto nel messaggio
news:_2bra.15598$
3M4.4...@news1.tin.it

Non so' se e' peggio la tua soluzione o quella del MOD che ti hanno
suggerito in diecimila...

 suggerito in diecimila...
vabbe' tu che avresti usato ?
io "if a\b = a/b" ma alla fine il mod e' lo stesso e risparmio una manciata
di cicli macchina ^_^
-- 
<Gigio2K>
Sito Comune
Nokia -> I.T.H.N. -> 
http://www.ithn.it/
VB -> I.C.L.VB -> 
http://www.it-lang-vb.net/

 ha scritto nel messaggio
news:dLira.17919$3M4.5...@news1.tin.it...

Dicci la tua...
Ciao
--
Luca Dormio - 
luca....@tin.it
________________________________
"Marty, non stai ragionando in maniera quadridimensionale"
Dr. Emmet L. Brown

> come è possibile sapere se un numero è pari o dispari?
Io uso sempre Mod, una strada alternativa potrebbe essere l'And con 1, che è
leggermente più prestante (16.2 contro 20.4 secondi per 100 milioni di
iterazioni in debug).
A occhio la differenza sta nel fatto che la divisione è pesante - anche se
la divisione per 2 è in realtà un semplice shift - mentre le operazioni
logiche sui bit dovrebbero essere più o meno "atomiche".
Oltre i limiti del long va comunque in overflow come il mod.
--
Ciao, Silv:o)

 di cicli macchina ^_^
prova questa:
If (A AND 1) <> 0 then
   ' dispari!
Else
    ' pari!
End If
Ciao

 If (A AND 1) <> 0 then
nnaggia all' LSB me ne scordo a volte che sto in binario ^_^;
quindi sara' sicuramente la piu' performante visto che fa l'and con un bit ?

 un bit ?
In realta' il modo migliore sarebbe un bel testbit in ASM, ma in VB viene
male ;-D
Per inciso, anche questa istruzione:
If (A AND 1) <> 0 then
e' sbagliata, sia concettualmente che dal punto di vista delle
prestazioni...

 operazioni logiche sui bit dovrebbero essere più o meno "atomiche".
E' uno shift solo se il compilatore lo riconosce e lo ottimizza in quel modo
e si inventa qualche modo per gestirlo. Il MOD e' il resto della divisione,
non il risultato. Con lo shift invece ottieni il risultato, per ottenere il
resto dovresti avere un modo per recuperare il bit che e' appena stato
"perso".

 prestazioni...
E qual è quella giusta, restando sintatticamente corretta?
Ciao

>>>>
</Troll-O-Meter>
--
Sito Comune: 
http://www.it-lang-vb.net/
Manifesto: 
http://www.it-lang-vb.net/docs/Manifesto.txt
UGIdotNET - 
http://www.ugidotnet.org
Troll-O-Meter(TM) e' un Marchio registrato di proprieta' di
GbC.

 Gia', qual'e' quella giusta?
           ^^^
non questa
--
Ciao, Silv;o)

 non questa
Bastardo!!! :)
Lokar


 E qual è quella giusta, restando sintatticamente corretta?
Oh, intendiamoci, e' solo una finezza...pero' quella corretta sarebbe
If (A AND 1) then
Questo perche'
If (A AND 1) then
equivale a dire al processore "
 - Esegui A AND 1
 - Se il risultato di A AND 1 e' diverso da 0 allora...
Mentre
If (A AND 1) <>0 then
equivale a "
 - Esegui A AND 1
 - esegui Risultato <>0
 - Se il risultato di Risultato <>0 e' diverso da 0 allora...
Ripeto, piu' che errori sono solo sottigliezze. Un po' come il classico
Dim blnVariabile as boolean
.
[codice che modifica blnVariabile]
.
If blnVariabile = True then
[etc.]
Che ho visto usare da una marea di gente e che e' abbastanza stupido...

 Che ho visto usare da una marea di gente e che e' abbastanza stupido...
Assolutamente d'accordo.
Tra l'altro in questo caso sembra che VB valuti anche il True, poichè
If blnVariabile = True then
è più lento di
If blnVariabile then
che in asm dovrebbero di fatto coincidere.
Ciao

che in asm dovrebbero di fatto coincidere.
Qui ci vorrebbe un asmatico:
<codice>
5:    Public Sub Main()
00401554   push        ebp
00401555   mov         ebp,esp
00401557   push        4
00401559   pop         eax
0040155A   call        VB@TEXT (00401090)
6:        Dim test As Boolean
7:
8:        test = True
0040155F   or          word ptr [test],0FFFFh
9:
10:       If (test) Then
00401564   movsx       eax,word ptr [test]
00401568   test        eax,eax
0040156A   je          Module1::Main+24h (00401578)
11:           If (test = True) Then
0040156C   cmp         word ptr [test],0FFFFh
00401571   jne         Module1::Main+24h (00401578)
12:               test = False
00401573   and         word ptr [test],0
13:           End If
14:       End If
15:   End Sub
00401578   leave
00401579   ret
</codice>
-- 
ciao, hal

 stupido...
Scusa ciccio ma a me sembra + stupido dare un numero ad un boolean che
l'esplicitarlo !
in fase di prestazioni non mi frega , altrimenti uso un altro linguaggio e
non vb , in fase di lettura trovo + leggibile e + comodo
"if test = true"  che " if test "
sono sottigliezze come dite giustamente ma quando leggo :
if booleano = unNumero mi viene un sorrisino e penso ad un "niubbo"
^_^ logicamente senza offesa per nessuno ( io esplicito anche le offese )



wrote:

Non sara' il massimo il termini di prestazioni, ma se devo ottimizzare
il singolo ciclo macchina non programmo in VB ma in C/C++ :-)


 "if test = true"  che " if test "
Beh, io trovo molto più leggibile (anche grammaticalmente) un
If ItemFound Then
che un ridondante
If ItemFound = True Then
(e nel caso del negativo
If Not ItemFound Then
anzichè
If ItemFound = False Then
)
Ciao
--
Math Parser : 
http://www.neodatatype.net
Sito Comune : 
http://www.it-lang-vb.net

 If ItemFound = True Then
umm umm , no, non mi piace , trattiamo tutte le typevar allo stesso modo ,
if varNum = 0 | 100 ...
if varBool = true | false
if varString  = 'a' | ...
il costrutto io lo leggo come
se _qualcosa_  =  _qualcosaltro_ allora ...
adesso io il _qualcosaltro_ lo esplicito sempre per una questione di
rispettare le mie (famose) regole (o pippe?) mentali ^_^


 rispettare le mie (famose) regole (o pippe?) mentali ^_^
Ognuno ha le sue. Anch'io. Uso, anche con variabili numeriche (non solo
boolean), fare un test per un _implicito_ diverso da 0 (vecchia discussione,
per me vuol dire così, non = True).
Quindi "If pippo Then" e non (se non mi scappa) "If pippo<>0 Then".
Per vecchi retaggi (dovuti a un antico buco, forse ancora di MS Basic Prof
7) esplicito il <>0 quando vi sono due o più test sulla stessa riga, quindi
"If pippo<>0 And pluto<>0 Then"

0040156C   cmp         word ptr [test],0FFFFh
<citazione>
Art of Assembly
9.5.6 TEST Operations
http://webster.cs.ucr.edu/Page_asm/ArtofAssembly/ch09/CH09-6.html#HEADING6-83
Remember, the test instruction is an and instruction that doesn't
retain the results of the and operation (other than the flag
settings).
[cut]
Another important use of the test instruction is to efficiently
compare a register against zero. The following test instruction sets
the zero flag if and only if ax contains zero (anything anded with
itself produces its original value; this sets the zero flag only if
that value is zero): 
                test ax, ax 
The test instruction is shorter than 
                cmp     ax, 0 or                 cmp     eax, 0 
though it is no better than 
                cmp     al, 0
</citazione>
Sembrerebbe un briciolo piu' performante la soluzione che viene
tradotta nell'istruzione "test" che e' 
	If (variabile) Then
-- 
ciao, hal

 riga, quindi "If pippo<>0 And pluto<>0 Then"
... spero che pippo e pluto siano numeriche senno' ti odio ^_^
-- 
<Gigio2K>< Esplicitare e' bello! Do it >


 If (variabile) Then
non ci sto, facciamo 2 su 3 ? ^_^
Scherzi a parte me lo aspettavo che quel bastardone di vb mi andasse contro
anche stavolta come sempre ! :(
Ultimamente quando apro vubbě mi fa un "prot" e poi si apre ma stizzato !
Cosa puo' essere ?


 ... spero che pippo e pluto siano numeriche senno' ti odio ^_^
Certo che sono numeriche, per chi m'hai preso? :-P
Ah, no (lo sai bene) sono Variant :-P :-P

 Ah, no (lo sai bene) sono Variant :-P :-P
uff, menomale che abbiamo ancora qualcosa in comune ... ^_-
-- 
<Gigio2K>


 e allora perche se scrivi if pippo <> 0 non scrivi if trovato <> true ?
Rileggi: Quell'esempio era per indicare i casi in cui sulla stessa riga ci
sono due o più test. Se il test è uno solo faccio "If pippo Then"

 Se il test è uno solo faccio "If pippo Then"
Che brutto, sembra quasi che pippo sia una function che restituise un bool
^_^
Buon WE a tutti !


 ^_^
Metti tutte le faccione che vuoi, ma io ti chiamerň GigioPigro.
Facciamo una scommessa?
Se un paragrafo ha piů di due righe, tu leggi, al max, giust'appunto le
prime due.
Ho vinto, vero che ho vinto? ;-)

 Ho vinto, vero che ho vinto? ;-)
non e' vero dai :p ieri ero stanco, ho riletto il tuo post ma il risultato
non cambia !
:p


 non cambia !
Mi cito:
"Uso, anche con variabili numeriche (non solo boolean),
fare un test per un _implicito_ diverso da 0
(vecchia discussione, per me vuol dire così, non = True)."
E mi spiego (strafregandomente di cosa fa VB):
Se faccio "If var_boolean Then" mi sta bene che venga intesa come =True,
anzi (e qui introdurrei un'altra interpretazione), <>False
Se faccio "If var_numerica Then" _io_ la intendo come <>0
Alfine (potremmo parlare per giorni del binario e, quindi, del On/Off,
True/False, bandierina alzata/abbassata) poco mi importa se VB testa con un
True o un False, ma son convinto che se faccio "If var_boolean<>0 Then"
oppure "If var_numerica<>0 Then" andrà sempre bene, anche fra cent'anni.
Ho invece dei dubbi che, pur fra cent'anni, "If var_boolean<>False" (ovvero
If var_boolean=True) oppure "If var_numerica<>False" (ovvero ... già ora, e
l'ho messa per utima per vedere se stai attento, If var_numerica=True)
possano funzionare.
Insomma, False e True sono (IMHO!!!) delle pure invenzioni, le uniche (!!!)
realtà sono =0 e <>0. Le costanti (tali sono) True e False sono
concettualmente assurde e la prima potrà cambiare come vuoi (introducendo,
come ora, delle conversioni totalmente inutili), ma la seconda non potrà mai
valere qualcosa di <>0.

valere qualcosa di <>0.
Concordo su quanto riportato.
Penso che TRUE e FALSE siano state inventate per favorire la
tipizzazione e (anche se non nel caso di VB) per favorire il
porting del codice da una piattaforma all' altra.
-- 
ciao, hal

 porting del codice da una piattaforma all' altra.
Rileggendolo stasera ho capito finalmente cosa voleva intendere lupo !
Quindi se ho capito quello che vuole dire lupo e' che la "costante" "False"
in realta' non e' una costante in quanto mentre il True vale 0 il false non
ha un valore ma semplicemente, non vale 0 !?
Interessante , non le avevo mai analizzate partendo dal punto di vista
numerico !
Cmq per come la vedo io nella scrittura del codice io preferisco il mio
costrutto :
[qualcosa operatore qualcosaltro] quindi "if trovato then" lo scivero'
sempre come "if trovato = true then"
(cmq stiamo mischiando 2 concetti in questo 3ad e la mia mente non comincia
+ a starci dietro...)
^_^


 sempre come "if trovato = true then"
Libertà di pensiero, che rispetto e mi sta pure bene per una boolean.
Ma "If var_numerica Then" per me è più leggibile (oltre che pigramente
comoda perchè non devo scrivere il <>0) e (di questo si parlava)
_identicamente_ applicabile a un boolean: "If trovato Then". Perchè pensare
più del dovuto? ;-)

 pensare più del dovuto? ;-)
bhe , sarebbe il caso di dire che seguiamo "diverse scuole di pigrizia" ^_^
Interessante ... si fanno corsi ?


 qualcosa ? )
No, era solo una divagazione per dire che quel -1 per dire True non serve
assolutamente a niente. Poi, per mettere un -1 mi pare che si debba alzare
tutti i bit del "gruppo" usato.
Per dire "è True?", sarebbe bastato dire:
quel Bit o Byte o Integer o Long o Double o Piripicchio è diverso da 0?
Insomma, che cacchio mi frega dire Vero o Falso quando in realtà mi
stra-basta dire <>0 o =0?
No?! ;-)

 realtà sono =0 e <>0.
Certo che lo sono :)
Ma evitano alcune ambiguità, specie quando l'AND funziona sia come operatore
logico che binario.
All'inizio vi era vbTrue (integer -1) e vbFalse (integer 0), non esistevano
i boolean, poi sono state inserite direttamente nel compilatore come True e
False.
Adesso internamente (come in quasi tutti i linguaggi) true viene visto
come -1 integer (2 byte con tutti i bit a 1) e false come intero a 0, e
finora VB non faceva una piega, ma ora anche .net si adegua a molti altri, e
quando vede qalcosa del tipo
if (0 = false) then
Ti avverte che 0 è un numero e false è una condizione logica.
Io che sono uno smanettone preferisco il sistema =0 o <>0, ma bisogna starci
un po' attenti :)


 un po' attenti :)
Approvo. Hai sintetizzato precisamente il mio pensiero.

come -1 integer (2 byte con tutti i bit a 1) e false come intero a 0,
In C/C++ e' visto come 1:
#define TRUE                1
-- 
ciao, hal

 #define TRUE                1
In C. In C++ esiste il tipo bool (minuscolo) e true (minuscolo) è uno 
dei due valori (true e false) che può assumere una variabile di tipo
bool. Poi, per motivi ovvi, i valori booleani possono essere convertiti
in interi, ed in questo caso true per definizione corrisponde al valore
1 e false al valore 0. Viceversa un intero può essere convertito in un
bool, ed in questo caso i valori interi diversi da zero vengono
convertiti in true e 0 è convertito in false.
Ciao.
-- 
BSD is for UNIX lovers -- linux is for Windows haters.

 stra-basta dire <>0 o =0?
JZ e JNZ...che tempi!