Newsgroup: it.comp.lang.c
Titolo: Lavoro binario

Dunque ho scovato il problema nell'approccio binario sempre allo stesso
programma.
Primo per avere 64 bit utilizzabili mi serve
unsigned long long
Su un sistema a 32 bit lavorando pesantemente su 52 di questi 64 bit il
programma andrà a rilento?
Comunque in sostanza la cosa strana è che facendo questo
     IntDeck deck = (1 << size) -1;
Passando 52 ottengo 2^64 -1, e non 2^52-1 come mi aspetterei, cosa
potrebbe essere?

 writes:

Ancora più strano, su osx invece ottengo questo
1048575, che è 2^20-1, da questo:
     IntDeck deck = (1 << 52) -1;
dove IntDeck è unsigned long long..
Mi pare faccia un po' come gli pare...

 Mi pare faccia un po' come gli pare...
non e' che fa come gli pare, sei tu che fai delle assunzioni non
giuste.
Ciao Jack

 Ciao Jack
Caspita ecco perché grazie.
Davo per scontato che avendo un tipo (sì è a 64 bit) settato a 0 il
resto sarebbe venuto di conseguenza, comunque ho risolto con ~0.
Ora come dicevo negli altri post mi sembra corretto, ma ottengo valori
un po' diversi.
Tra l'altro qui è ancora più corretto in teoria perché resetto veramente
il mazzo a ogni loop...
Ho caricato su github anche il branch sperimentale dove sto provando
questo approccio...
http://github.com/AndreaCrotti/Razz/tree/exp
In pratica provo prima a cancellare
4 -> 4 + 13 -> 4 + (13 * 2) -> 4 + (13 * 3)
e se proprio non lo trovo estraggo un altro numero a caso (questo non
succede praticamente mai comunque)..

Ho cambiato approccio, dato che devo togliere mi conviene settare
inizialmente a 0 e poi fare degli or per togliere.
Però ho ancora un problema localizzato qui...
--8<---------------cut here---------------start------------->8---
void
remove_card_from_int_deck(Deck *deck, Card card) {
     IntDeck orig = deck->deck;
     IntDeck rem = 1 << card;
     printf("removing card %d\n", card);
     deck->deck |= rem;
     deck->len--;
     print_int_deck(deck);
     assert(deck->deck != orig);
     // smaller deck
}
--8<---------------cut here---------------end--------------->8---
In sostanza rem quando la carta diventa più grande ottengo questo:
--8<---------------cut here---------------start------------->8---
removing card 42, rem = 1024
deck = 1031, len = 48
--8<---------------cut here---------------end--------------->8---
eppure IntDeck è un "unsigned long long", quindi per quale motivo non
vuole prendere il valore corretto (sizeof(IntDeck) == 8)??

 vuole prendere il valore corretto (sizeof(IntDeck) == 8)??
Attenzione alle costanti. Di default sono int per cui quando fai 1<<card 
fai uno shift su un int che poi viene castato a IntDeck.
Su tutte le costanti che devono essere unsigned long long fai seguire 
ULL, ossia:
IntDeck rem = 1ULL << card;

 vuole prendere il valore corretto (sizeof(IntDeck) == 8)??
e per la visualizzazione di un tipo long long int, fai cos� : 
printf("%llu",rem)

 IntDeck rem = 1ULL << card;
Ok grazie, non ci avevo pensato... Comunque non era quello il problema,
in effetti cercava di togliere la stessa carta due volte consecutive,
mettendo un loop non va in loop infinito e quindi funziona
apparentemente.
Però purtroppo è più lento dell'altro approccio, quindi lasciamo stare...