DIG Digital Corner
Alles wat je altijd al over computers, hardware, software, internet en elektronische gadgets had willen weten, maar niet op Tweakers.net durft te vragen.
Daar ga ik een keer naar kijken. Bedankt!
Op zich heb ik wel veel geleerd van vectors ondertussen (ook de beperkingen ervan), dus ik zie het niet als verspilde tijd.
Mijn doel is gewoon om een beetje handig met C++ te worden, totdat ik genoeg vertrouwen in mezelf heb om een wat groter project te starten. Uiteindelijk wil ik een app maken die de kortste route tussen een paar punten vindt, daar een plaatje van maakt, en dat alles in een mooie GUI die ik gemaakt heb met Qt. Dat plaatje zal ook nog erg lastig worden denk ik.
Op zich heb ik wel veel geleerd van vectors ondertussen (ook de beperkingen ervan), dus ik zie het niet als verspilde tijd.
Mijn doel is gewoon om een beetje handig met C++ te worden, totdat ik genoeg vertrouwen in mezelf heb om een wat groter project te starten. Uiteindelijk wil ik een app maken die de kortste route tussen een paar punten vindt, daar een plaatje van maakt, en dat alles in een mooie GUI die ik gemaakt heb met Qt. Dat plaatje zal ook nog erg lastig worden denk ik.
Ik heb altijd een class willen maken voor grote integers.quote:Op woensdag 8 augustus 2012 22:58 schreef thenxero het volgende:
Dat is vast niet zo leerzaam als dit geklooi
Wil je mee helpen?
Heb je git?
Weet iemand hoe de overflow kan opvangen met C++?
In amd64 kan je gewoon 2 registers gebruiken op resultaat op te slaan.
Je kan het natuurlijk met een int en long int doen, maar long int hoeft niet groter te zijn dan int.
(long long ook niet)
In amd64 kan je gewoon 2 registers gebruiken op resultaat op te slaan.
Je kan het natuurlijk met een int en long int doen, maar long int hoeft niet groter te zijn dan int.
(long long ook niet)
Overflow kan je niet opvangen in C++ en is ook moeilijk te detecteren. Je enige optie is zorgen dat het niet gebeurt.quote:
Weet iemand hoe de overflow kan opvangen met C++?
In amd64 kan je gewoon 2 registers gebruiken op resultaat op te slaan.
Je kan het natuurlijk met een int en long int doen, maar long int hoeft niet groter te zijn dan int.
(long long ook niet)
"Slechts diegene mag slopen die iets beters kan bouwen."
Maar is er ook zo iets als RDX:RAX <- RAX * r/m64?quote:
[..]
Overflow kan je niet opvangen in C++ en is ook moeilijk te detecteren. Je enige optie is zorgen dat het niet gebeurt.
Dat is natuurlijk heel erg processor-afhankelijk, dus het lijkt me sterk dat zoiets native in een taal als C++ zit. Als je een echt efficiënte library voor grote getallen wilt maken, zul je sowieso veel assembly code erbij moeten doen.quote:
[..]
Maar is er ook zo iets als RDX:RAX <- RAX * r/m64?
Wat als je vectoren niet even lang zijn?quote:while(!(k==a.rend()) && !(l==b.rend()))
Kan k==b.rend() uberhaupt op dit punt?quote:if(*k>9 && !(k==b.rend()))
Cute, maar nu lopen je iterators niet gelijk en dus..?quote:*(++k)++;
b?quote:b.insert(b.begin(),1);
Ook is t waar dat dit de iterator invalideert, maar is dat erg in deze toepassing? Afhankelijk van je while conditie wel (in de huidige ook), maar bedenk i.h.a. ook dat insert weer een (valide) iterator teruggeeft.
More oneness, less categories
Open hearts, no strategies
Decisions based upon faith and not fear
People who live right now and right here
Open hearts, no strategies
Decisions based upon faith and not fear
People who live right now and right here
Ja dacht ik al. Nouja kan wel inline asm gebruiken.quote:
[..]
Dat is natuurlijk heel erg processor-afhankelijk, dus het lijkt me sterk dat zoiets native in een taal als C++ zit. Als je een echt efficiënte library voor grote getallen wilt maken, zul je sowieso veel assembly code erbij moeten doen.
Alleen als een gewone int al 64-bits is. Het is een beetje vreemd dat je richting intrinsics/assembler gaat omdat je rekening wilt houden met zo'n (currently) outlandish mogelijkheid.quote:
Weet iemand hoe de overflow kan opvangen met C++?
In amd64 kan je gewoon 2 registers gebruiken op resultaat op te slaan.
Je kan het natuurlijk met een int en long int doen, maar long int hoeft niet groter te zijn dan int.
(long long ook niet)
More oneness, less categories
Open hearts, no strategies
Decisions based upon faith and not fear
People who live right now and right here
Open hearts, no strategies
Decisions based upon faith and not fear
People who live right now and right here
Ik zou de vector::resize method gebruiken om de vectoren groot genoeg te maken. Dat scheelt je weer wat if statements waardoor je code eenvoudiger wordt en je minder snel bugs krijgt.quote:
Een nieuwe poging vectors bij elkaar op te tellen alsof het getallen zijn. Dus bijvoorbeeld, als
a = {9, 8, 6, 4}
b = {9, 6, 7}
Dan wil ik dat de functie add(a,b) ervoor zorgt dat b = {1, 0, 8, 3, 1}. De functie moet in ieder geval werken voor vectors b die minstens even lang zijn als a. De moeilijkheid zit hem in de verschillende lengtes van de vector. Volgens mij is dit de beste methode om daarmee om te gaan, alleen krijg ik nog wat errors waar ik geen touw aan vast kan knopen.
Ik kan natuurlijk ook gewoon u_int64, u_int32 gebruiken etc.quote:Op donderdag 9 augustus 2012 20:10 schreef trancethrust het volgende:
[..]
Alleen als een gewone int al 64-bits is. Het is een beetje vreemd dat je richting intrinsics/assembler gaat omdat je rekening wilt houden met zo'n (currently) outlandish mogelijkheid.
Maar met asm kan ik 128 bit als opslag gebruiken...
Net even gechecked en int is 32bit, long en long long zijn 64bit.quote:
[..]
Alleen als een gewone int al 64-bits is. Het is een beetje vreemd dat je richting intrinsics/assembler gaat omdat je rekening wilt houden met zo'n (currently) outlandish mogelijkheid.
size_t is ook 64bit.
Dat hangt helemaal van je architectuur af. Zou je dit soort dingen ook echt aannemen in je code, dan kunnen andere mensen het dus niet gebruiken.quote:
[..]
Net even gechecked en int is 32bit, long en long long zijn 64bit.
size_t is ook 64bit.
Klinkt wel leuk, maar ik weet niet of je veel aan me hebtquote:
[..]
Ik heb altijd een class willen maken voor grote integers.
Wil je mee helpen?
Heb je git?
Ja daar zit het probleem dus...quote:
[..]
Dat hangt helemaal van je architectuur af. Zou je dit soort dingen ook echt aannemen in je code, dan kunnen andere mensen het dus niet gebruiken.
Het punt is dat assembler ook compleet van je architectuur afhangt; dat is als zodanig ook niet echt een oplossing.quote:
[..]
Ja daar zit het probleem dus...
Ook is een truc om toch maar 128-bits precisie te gebruiken voor detectie eigenlijk uitstel van executie; wat als je dan toch ook maar met 128-bits waarden wilt gaan werken, als het toch kan? Je blijft bezig.
Ik zou dan ook per applicatie bekijken of overflows daadwerkelijk problemen geven; als je enige operatie een telkens 1 optellen is, dan is een i == static_cast< unsigned int >( -1 ) genoeg om overflow te detecteren. Als het twee ints optellen is, dan hoef je alleen iets speciaals te doen als een van de getallen de 32e meest significante bit heeft gezet. Als je RNGs aan het maken bent en je hebt elk stukje performance nodig, dan kijk je naar Schrage's truc; enzovoorts.
More oneness, less categories
Open hearts, no strategies
Decisions based upon faith and not fear
People who live right now and right here
Open hearts, no strategies
Decisions based upon faith and not fear
People who live right now and right here
edit:
Het werkt
Het werkt
| 1 2 3 4 5 | uint64_t x, y; unsigned __int128 z; x = y = 0xffffffffffffffff; z = static_cast<unsigned __int128>(x) * y; |
Sure, maar het is niet ANSI en het blijft uitstel van executie in de zin van hierboven.
More oneness, less categories
Open hearts, no strategies
Decisions based upon faith and not fear
People who live right now and right here
Open hearts, no strategies
Decisions based upon faith and not fear
People who live right now and right here
Ja ik weet dat het geen ISO is.quote:Op vrijdag 10 augustus 2012 19:41 schreef trancethrust het volgende:
Sure, maar het is niet ANSI en het blijft uitstel van executie in de zin van hierboven.
Dus dan moet ik maar uint32_t en uint64_t gebruiken.
En dan met ifdef gaan werken.
Of is er een andere mogelijk om de grootste integer te krijgen en een integer die 2 keer zo klein is.
Voor mijn arbitrary precision integer implementatie heb ik een willekeurig unsigned integer-datatype genomen en daar alleen de onderste helft van de bits van gebruikt. Dat betekent dat de gebruiker vrij is de snelste int voor zijn compiler/platform te gebruiken en dat het automatisch meegroeit als de ints ook groter worden.quote:
Of is er een andere mogelijk om de grootste integer te krijgen en een integer die 2 keer zo klein is.
Het is zonde om je zo vast te zetten op een bepaalde grootte int.
"Slechts diegene mag slopen die iets beters kan bouwen."
Ja ik wil ook niet vast zitten op een bepaalde grootte.quote:
[..]
Voor mijn arbitrary precision integer implementatie heb ik een willekeurig unsigned integer-datatype genomen en daar alleen de onderste helft van de bits van gebruikt. Dat betekent dat de gebruiker vrij is de snelste int voor zijn compiler/platform te gebruiken en dat het automatisch meegroeit als de ints ook groter worden.
Het is zonde om je zo vast te zetten op een bepaalde grootte int.
Jij zegt zelf dat je een willekeurige gebruikt, maar hoe weet je dat je dat onderste helft van de bits gebruikt?
Dat werkt, maar dan moet je dus wel voor een nieuw type een nieuwe template-specificatie maken etc.quote:
De onderste helft is sizeof(Type) * 4 bits en de maximale waarde is dus 2^(sizeof(Type) * 4). Zolang je daaronder zit, zit je veilig. Als je daar overheen gaat (of het raakt), schuif je de overflow naar het volgende getal.quote:Jij zegt zelf dat je een willekeurige gebruikt, maar hoe weet je dat je dat onderste helft van de bits gebruikt?
"Slechts diegene mag slopen die iets beters kan bouwen."
