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.
Nee, klopt had ik idd al bedacht was meer dat ik niet zo bekent ben met memcpy en memset dus in dat opzicht had ik dat gekopieerd van iemand anders zijn code (snap wel wat het doet) Had idd ook gewoon de & en * kunnen gebruiken.quote:Op donderdag 20 juni 2013 00:54 schreef trancethrust het volgende:
Je kan er een struct van maken als in
[ code verwijderd ]
Een sizeof(receive_buffer) is dan 1500*sizeof(char).
(Overigens is dynamisch alloceren van de receive-buffer via new niet nodig)
maar stel dat ik de buffer statisch alloceer als
| 1 | char RecvBuff[1500]; |
| 1 | recvfrom(Sock,RecvBuff,sizeof(RecvBuff),0,0,0); |
Beware of the Raping Zebra's
Die struct stond er voor een redenquote:Op donderdag 20 juni 2013 09:40 schreef netolk het volgende:
[..]
Nee, klopt had ik idd al bedacht was meer dat ik niet zo bekent ben met memcpy en memset dus in dat opzicht had ik dat gekopieerd van iemand anders zijn code (snap wel wat het doet) Had idd ook gewoon de & en * kunnen gebruiken.
maar stel dat ik de buffer statisch alloceer als
[ code verwijderd ]
Dan zou je zeggen dat dit ook zou moeten werken
[ code verwijderd ]
Maar dat werkt dus niet en faalt de recvfrom functie
Een
| 1 | T x[ n ] |
Als je de boel in een struct gooit, dan neemt de struct de grootte van alle velden, dus de grootte van de totale char array.
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
klinkt logisch iddquote:Op donderdag 20 juni 2013 09:51 schreef trancethrust het volgende:
[..]
Die struct stond er voor een reden
Een
[ code verwijderd ]
alloceert een statische array van type T en grootte n. De type van x is dan dus een array van T, ofwel een pointer naar T, en de size daarvan is sizeof( void* ).
Als je de boel in een struct gooit, dan neemt de struct de grootte van alle velden, dus de grootte van de totale char array.
maar dan zou sizeof(*recvBuff) ook moeten werken maar bij de dynamische allocatie kreeg ik daar ook een error van recvfrom
Beware of the Raping Zebra's
Een *recvbuffer is een pointer, dus wederom 4 of 8 bytes. sizeof(recvbuffer) is wat je wilt (als recvbuffer een struct is dat de char-array bevat, zoals hierboven).quote:
[..]
klinkt logisch idd
maar dan zou sizeof(*recvBuff) ook moeten werken maar bij de dynamische allocatie kreeg ik daar ook een error van recvfrom
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
k, dus sizeof neemt alleen de grote van het object wat je er instopt en niet waar het naar verwijst ongeacht het gebruikt van * ?quote:
[..]
Een *recvbuffer is een pointer, dus wederom 4 of 8 bytes. sizeof(recvbuffer) is wat je wilt (als recvbuffer een struct is dat de char-array bevat, zoals hierboven).
Beware of the Raping Zebra's
http://en.cppreference.com/w/cpp/language/sizeofquote:
[..]
k, dus sizeof neemt alleen de grote van het object wat je er instopt en niet waar het naar verwijst ongeacht het gebruikt van * ?
Wordt onder compile-time bepaald, dus niet onder runtime.
Grootte van het type van het object dat je erin stopt, inderdaad, of de grootte van het type dat je meegeeft (sizeof werkt op zowel objecten/instances als datatypes). Dit is ook precies wat je wilt.quote:
[..]
k, dus sizeof neemt alleen de grote van het object wat je er instopt en niet waar het naar verwijst ongeacht het gebruikt van * ?
De * maakt in deze zin altijd een pointer data type.
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
Uhm, nee?quote:
[..]
Die struct stond er voor een reden
Een
[ code verwijderd ]
alloceert een statische array van type T en grootte n. De type van x is dan dus een array van T, ofwel een pointer naar T, en de size daarvan is sizeof( void* ).
Als je de boel in een struct gooit, dan neemt de struct de grootte van alle velden, dus de grootte van de totale char array.
| 1 2 3 4 5 6 | long buffer[256]; int True = (sizeof(buffer) == 1024); for(int i=0; i<sizeof(buffer)/sizeof(*buffer); i++) printf("%d\n", buffer[i]); |
Oh. Redelijk stonedquote:
Op 
Blijkbaar wordt een (niet-dynamische array) als een soort struct gezien; nooit geweten!SPOILEROm spoilers te kunnen lezen moet je zijn ingelogd. Je moet je daarvoor eerst gratis Registreren. Ook kun je spoilers niet lezen als je een ban hebt.More oneness, less categories
Open hearts, no strategies
Decisions based upon faith and not fear
People who live right now and right here
quote:Op vrijdag 21 juni 2013 16:32 schreef trancethrust het volgende:
[..]
Oh. Redelijk stonedsizeof geeft size van een object, een C array is ook gewoon een object.SPOILEROm spoilers te kunnen lezen moet je zijn ingelogd. Je moet je daarvoor eerst gratis Registreren. Ook kun je spoilers niet lezen als je een ban hebt.
Alleen zijn C arrays best wel klote want je kan niet pass by value doen, alleen maar by reference.
En als je dus in een function sizeof doet van je parameter "array" krijg je size van je reference ipv array.
http://ideone.com/jcU5D8
ahh, vandaarquote:
[..]
sizeof geeft size van een object, een C array is ook gewoon een object.
Alleen zijn C arrays best wel klote want je kan niet pass by value doen, alleen maar by reference.
En als je dus in een function sizeof doet van je parameter "array" krijg je size van je reference ipv array.
http://ideone.com/jcU5D8
Ik heb het nu opgelost door de grote in een aparte (constante) int te zetten zodat ik alleen die hoef aan te passen als ik de grote wil veranderen
Beware of the Raping Zebra's
Ah ik snap de tegenstelling nu. Mijn eerste reactie was `dit is nog lelijker dan een struct'`, maar de grap is natuurlijk dat als een C array geen aparte datatype was, dat een struct zoals hier ook nooit zou kunnen werken; de struct zou anders precies de grootte zijn van een array pointer.quote:
[..]
sizeof geeft size van een object, een C array is ook gewoon een object.
Alleen zijn C arrays best wel klote want je kan niet pass by value doen, alleen maar by reference.
En als je dus in een function sizeof doet van je parameter "array" krijg je size van je reference ipv array.
http://ideone.com/jcU5D8
En een pass-by-value zou nooit letterlijk kunnen omdat de grootte van een argument nooit compile-time bepaald kon worden. Noodzakelijk kwaad. Cool, weer wat geleerd.
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
Je weet dat het zetten van struct voor de typename C is en niet nodig (deprecated?) in C++?quote:Op vrijdag 21 juni 2013 23:53 schreef trancethrust het volgende:
[..]
Ah ik snap de tegenstelling nu. Mijn eerste reactie was `dit is nog lelijker dan een struct'`, maar de grap is natuurlijk dat als een C array geen aparte datatype was, dat een struct zoals hier ook nooit zou kunnen werken; de struct zou anders precies de grootte zijn van een array pointer.
En een pass-by-value zou nooit letterlijk kunnen omdat de grootte van een argument nooit compile-time bepaald kon worden. Noodzakelijk kwaad. Cool, weer wat geleerd.
Zie std::array als je een array als value will passen.
In C++14 komt er waarschijnlijk een dynamic array.
http://ideone.com/swuvZrquote:Op zaterdag 22 juni 2013 00:15 schreef t4rt4rus het volgende:
[..]
Je weet dat het zetten van struct voor de typename C is en niet nodig (deprecated?) in C++?
Het was meer een discussie over waarom een T foo[500] geen T*-type had, wat (mij) aanvankelijk veel natuurlijker leek. Persoonlijk als ik arrays doorgeef gebruik ik pointers/iterators, het andere komt me wat onnatuurlijk over.quote:Zie std::array als je een array als value will passen.
In C++14 komt er waarschijnlijk een dynamic array.
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
nee, ik heb een boek uit 2002 van hem (wel is waar vertaald naar NL in die tijd was ik nog niet zo'n voorstander van Engelse boeken)quote:
Is er al iemand die Stroustrups nieuwe boek heeft?
En zijn er mensen die C++14 een beetje volgen?
Beware of the Raping Zebra's
Omdat het van GS42 hier moet 
------------------
Hai!
Ik heb een programma dat redelijk veel verschillende handelingen op dezelfde manier (maar toch altijd net even anders) uitvoert. Het gaat om bewerkingen / analyses over OpenCV matrices.
Voor het gemak een voorbeeldje:
Dit loopt door alle pixels van een gegeven resolutie set heen, en geeft bijvoorbeeld een maximum terug, of een gemiddelde, of telt het aantal pixels > 0, soms voor de Y matrix, soms de Z, soms de X, soms een combinatie. Soms past het bovendien de matrixen aan.
Anyway, ik zou dit een beetje handiger willen verpakken want die nested for loop zit op heel veel plekken en ik heb het idee dat dit overzichtelijker kan.
Bovendien... Dit moet toch sneller kunnen? Iemand een idee of dit in C++ in een object class zou kunnen en zo ja hoe kan ik die dan toch dynamisch genoeg maken om er vanalles mee te doen? Of ben ik echt gebonden aan de huidige aanpak?
------------------
Hai!
Ik heb een programma dat redelijk veel verschillende handelingen op dezelfde manier (maar toch altijd net even anders) uitvoert. Het gaat om bewerkingen / analyses over OpenCV matrices.
Voor het gemak een voorbeeldje:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | for (size_t y = 0; y < p_Par->Xtion.CanvasYRes; y = y++) { for (size_t x = 0; x < p_Par->Xtion.CanvasXRes; x = x++) { float py = OpenNiDataObj->OriginalYMatrix.at<float>(y,x); float px = OpenNiDataObj->OriginalXMatrix.at<float>(y,x); if ((abs(px-Par->obj.leftx)<10 || abs(px-Par->objrightx)<10) && py!=0) { OpenNiDataObj->OriginalYMatrix.at<float>(y,x)=-501; } } } |
Dit loopt door alle pixels van een gegeven resolutie set heen, en geeft bijvoorbeeld een maximum terug, of een gemiddelde, of telt het aantal pixels > 0, soms voor de Y matrix, soms de Z, soms de X, soms een combinatie. Soms past het bovendien de matrixen aan.
Anyway, ik zou dit een beetje handiger willen verpakken want die nested for loop zit op heel veel plekken en ik heb het idee dat dit overzichtelijker kan.
Bovendien... Dit moet toch sneller kunnen? Iemand een idee of dit in C++ in een object class zou kunnen en zo ja hoe kan ik die dan toch dynamisch genoeg maken om er vanalles mee te doen? Of ben ik echt gebonden aan de huidige aanpak?
Je zou met een Lambda functie de 2 for loops kunnen vervangen.
Maar dat is waarschijnlijk minder leesbaard dan 2 for loops, om nog maar te zwijgen over de potentiële snelheidsverlies...
Of het sneller kan, zou je dat even in de OpenCV documentatie moeten halen (wellicht zijn er bepaalde iterators die je kunt gebruiken). maar zo bekend ben ik niet met OpenCV.
Maar dat is waarschijnlijk minder leesbaard dan 2 for loops, om nog maar te zwijgen over de potentiële snelheidsverlies...
Of het sneller kan, zou je dat even in de OpenCV documentatie moeten halen (wellicht zijn er bepaalde iterators die je kunt gebruiken). maar zo bekend ben ik niet met OpenCV.
Robert Moog died for our synths
Dit is een derde snellerquote:
Je zou met een Lambda functie de 2 for loops kunnen vervangen.
Maar dat is waarschijnlijk minder leesbaard dan 2 for loops, om nog maar te zwijgen over de potentiële snelheidsverlies...
Of het sneller kan, zou je dat even in de OpenCV documentatie moeten halen (wellicht zijn er bepaalde iterators die je kunt gebruiken). maar zo bekend ben ik niet met OpenCV.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 | for (size_t y = 0; y < p_Par->Xtion.CanvasYRes;y=y++) { float* My = (p_OpenNiDataObj->ZMatrix).ptr<float>(y); for (size_t x = 0; x < p_Par->Xtion.CanvasXRes; x = x++) { float& Myx = My[x]; } } [code] Maar waar ik eigenlijk naar op zoek was is iets als [code] matrixoperation(doeditendat); |
en de bijbehorende functie dan zoiets is als
| 1 2 3 4 5 6 7 | for (size_t y = 0; y < p_Par->Xtion.CanvasYRes;y=y++) { float* My = (p_OpenNiDataObj->ZMatrix).ptr<float>(y); for (size_t x = 0; x < p_Par->Xtion.CanvasXRes; x = x++) { doeditendat } } |
Doeditendat is altijd iets simpels. Soms trekt het lijntjes als x = iets, soms somt het alle waarden op, etc.
Misschien maak ik het mijzelf hierin alleen maar moeilijker, dat begrijp ik ook wel, maar ik had stille hoop dat je iets kon doen als:
(syntax is uiteraard manco)
| 1 2 3 | matrixoperation( (if(px)<40 || px>80){px=2}); of matrixoperation((if(px)<40 || px>80){sumx++},pointertosumx); |
waarbij px, py, pz bijvoorbeeld standaardtermen zijn die ie herkent als 'een punt uit die en die matrix, een punt uit die en die matrix of die en die matrix' en het 2e voorbeeld een argument meegegeven moet worden (pointersumx) omdat ie anders niets heeft om op te tellen (de sumx++). Met andere woorden, de variabele sumx zelf komt helemaal niet voor in de matrixoperation functie
Als ik het goed begrijp wil je dus graag een functie 'doeditendat' meegeven als argument van de functie 'matrixoperation'?quote:
[..]
Dit is een derde sneller
[ code verwijderd ]
en de bijbehorende functie dan zoiets is als
[ code verwijderd ]
Doeditendat is altijd iets simpels. Soms trekt het lijntjes als x = iets, soms somt het alle waarden op, etc.
Dan is dit wellicht iets voor je: http://stackoverflow.com/(...)-as-a-parameter-in-c
Robert Moog died for our synths
Denk het wel jaquote:
[..]
Als ik het goed begrijp wil je dus graag een functie 'doeditendat' meegeven als argument van de functie 'matrixoperation'?
Dan is dit wellicht iets voor je: http://stackoverflow.com/(...)-as-a-parameter-in-c
Vind het gewoon een beetje naar om o-ve-ral die dubbele forloop te hebben (ook al is het wel sneller)
Ja, hier staat namelijk een oneindige loop.quote:
for (size_t y = 0; y < p_Par->Xtion.CanvasYRes; y = y++)
Dit moet toch sneller kunnen?
En in die oneindige loop nog een oneindige loopquote:
[..]
Ja, hier staat namelijk een oneindige loop.
Holy_Goat lees je boek eens even over operator++
Ja verbaasde mij ook alquote:
Normaal was ik de gene die het actief hield met vragen
Beware of the Raping Zebra's
Kom maar op met de vragenquote:
[..]
Ja verbaasde mij ook al
Normaal was ik de gene die het actief hield met vragen
Die for-loops van jou zijn niet zo groot.quote:
[..]
Denk het wel ja
Vind het gewoon een beetje naar om o-ve-ral die dubbele forloop te hebben (ook al is het wel sneller)
Kan je makkelijk in meerdere functies stoppen.
Dus daar is op zich niets op tegen? Ik dacht dat als je dingen vaak gebruikte je moest bedenken of je niet iets anders compacters moest bedenkenquote:
[..]
Die for-loops van jou zijn niet zo groot.
Kan je makkelijk in meerdere functies stoppen.
Sorry, momenteel met m'n minor bezig en daar moeten we een game in javaquote:
makeneventueel als je vaak dezelfde loops gebruikt zou je ze nog in een andere methode kunnen zetten. Soms word je code daar leesbaarder van maar dat is het dan ookquote:
[..]
Dus daar is op zich niets op tegen? Ik dacht dat als je dingen vaak gebruikte je moest bedenken of je niet iets anders compacters moest bedenken
Beware of the Raping Zebra's
Een game in Java. Ik heb echt medelijden.quote:
[..]
Sorry, momenteel met m'n minor bezig en daar moeten we een game in java
[..]
eventueel als je vaak dezelfde loops gebruikt zou je ze nog in een andere methode kunnen zetten. Soms word je code daar leesbaarder van maar dat is het dan ook
Een beetje off-topic, maar voor een schoolproject maak ik ook een game in XNA. Wat een ramp. C++ en SFML.
Ja, weet ook niet waarom ze dat bedacht hebben....quote:
[..]
Een game in Java. Ik heb echt medelijden.
Een beetje off-topic, maar voor een schoolproject maak ik ook een game in XNA. Wat een ramp. C++ en SFML.
Zal wel zijn omdat we object georiënteerd programmeren in Java hebben gehad.
Maar mis de referentie dingen enzo heel erg. Java heeft rare regels met het doorgeven van dingen want primitives gaan bij value en de rest bij reference ofzo echt zo bagger
Plus natuurlijk dat openGL voor Java ook niet echt geweldig is
Beware of the Raping Zebra's
Op de een of andere manier gaat OOP mij moeilijker af in C++ dan in Java. De header-files vind ik zo'n zooitje.
Als ik een C+=2 zou maken zouden die header files er definitief uit mogen.
Als ik een C+=2 zou maken zouden die header files er definitief uit mogen.
C# (c sharp) misschien?quote:
Op de een of andere manier gaat OOP mij moeilijker af in C++ dan in Java. De header-files vind ik zo'n zooitje.
Als ik een C+=2 zou maken zouden die header files er definitief uit mogen.
En anders Python proberen
Robert Moog died for our synths
CSharp lukt me ook prima, maar er zijn dingen waarvoor je liever C++ gebruikt.quote:
[..]
C# (c sharp) misschien?
En anders Python proberen
Ik moet me er gewoon iets beter in gaan verdiepen.
Java is dan ook mijn favoriet, maar serieus, die header files zijn heus zo erg niet.quote:
Op de een of andere manier gaat OOP mij moeilijker af in C++ dan in Java. De header-files vind ik zo'n zooitje.
Als ik een C+=2 zou maken zouden die header files er definitief uit mogen.
Je moeder is een hamster
Als ik eerlijk ben vind ik het echt een last.quote:
[..]
Java is dan ook mijn favoriet, maar serieus, die header files zijn heus zo erg niet.
En het verschil tussen een abstracte klasse in Java en een Virtual in C++ is me na wat ingelezen te hebben ook niet zo duidelijk.
Maar de headers, tsja. Elke keer als je iets toevoegt moet je ook gelijk de headers aanpassen. Het werkt echt contraproductief.
tja het is maar een regeltje per toegevoegde functie, is dat nu echt zo erg? (toegegeven het is niet ideaal vanaf de programmeurs kant gezien)quote:
[..]
Als ik eerlijk ben vind ik het echt een last.
En het verschil tussen een abstracte klasse in Java en een Virtual in C++ is me na wat ingelezen te hebben ook niet zo duidelijk.
Maar de headers, tsja. Elke keer als je iets toevoegt moet je ook gelijk de headers aanpassen. Het werkt echt contraproductief.
Robert Moog died for our synths
Het is eigen Java, maar volgens maar volgens mij komen C en Java op dit basale niveau precies overeen.
Dit is code uit een app die ik gepubliceerd heb en ben per ongeluk een & vergeten, wat het een bitwise AND maakt. De oplossing van het probleem is een & toevoegen. Doel van de vraag is dus enkel om te snappen wat er gebeurt.
In de logs die ik nu heb is daysInstalled 0 of groter en ik verwacht nog steeds dat hij altijd enkel groter dan 2 is. Wat gaat er mis?
[ Bericht 1% gewijzigd door MichielPH op 07-12-2013 11:58:32 ]
| 1 2 3 4 | int daysInstalled = util.getDaysInstalled(context); int random = new Random().nextInt(10); if (random == 0 & daysInstalled > 2) { |
Dit is code uit een app die ik gepubliceerd heb en ben per ongeluk een & vergeten, wat het een bitwise AND maakt. De oplossing van het probleem is een & toevoegen. Doel van de vraag is dus enkel om te snappen wat er gebeurt.
In de logs die ik nu heb is daysInstalled 0 of groter en ik verwacht nog steeds dat hij altijd enkel groter dan 2 is. Wat gaat er mis?
[ Bericht 1% gewijzigd door MichielPH op 07-12-2013 11:58:32 ]
'To alcohol, the cause of and the solution to all of life's problems' - Homer J. Simpson
Absoluut niet. Groot verschil is hierbij dat booleans in C gewoon een integraal datatype zijn en (in C++) automatisch gepromoveerd worden tot integers voor bitwise berekeningen, terwijl in Java er een aparte overload is voor bitwise & op boolean types. In C evalueert bitwise & altijd tot een integer type, terwijl in dit geval Java een Boolean type teruggeeft.quote:
volgens mij komen C en Java op dit basale niveau precies overeen
> Wat gaat er mis?
In jouw voorbeeld, grappig genoeg: niets. De code werkt precies hetzelfde met & of &&, met als enige uitzondering dat bij (A & B) altijd zowel A als B geëvalueerd wordt, terwijl bij (A && B) de waarde van B alleen wordt geëvalueerd als A true is. Dit gedrag van && heet "short circuiting". Aangezien jouw vergelijkingen geen bijwerkingen hebben, is het resultaat hetzelfde (maar iets minder efficient).
Zie http://docs.oracle.com/ja(...)-15.html#jls-15.22.2 voor details.
[ Bericht 1% gewijzigd door GS42 op 08-12-2013 23:16:16 ]
"Slechts diegene mag slopen die iets beters kan bouwen."
Ah, leuk om te weten!quote:
[..]
Absoluut niet. Groot verschil is hierbij dat booleans in C gewoon een integraal datatype zijn en gepromoveerd worden tot integers voor bitwise berekeningen, terwijl in Java er een aparte overload is voor bitwise & op boolean types. In C evaluaeert bitwise & altijd tot een integraal type, terwijl in dit geval Java een Boolean type teruggeeft.
Ik had zelf ook verwacht dat het resultaat niet anders zou zijn. Toch komt daysInstalled met waarden van -1, 0, 1, 2 en groter voor in m'n logs, dus er gaat iets mis. Ik kan met 100% zekerheid zeggen dat dat gelogd wordt doordat die statement true is.quote:> Wat gaat er mis?
In jouw voorbeeld, grappig genoeg: niets. De code werkt precies hetzelfde met & of &&, met als enige uitzondering dat bij (A & B) altijd zowel A als B geevalueerd wordt, terwijl bij (A && B) de waarde van B alleen wordt geevalueerd als A true is. Dit gedrag van && heet "short circuiting". Aangezien jouw vergelijkingen geen bijwerkingen hebben, is het resultaat hetzelfde (maar iets minder efficient).
Zie http://docs.oracle.com/ja(...)-15.html#jls-15.22.2 voor details.
'To alcohol, the cause of and the solution to all of life's problems' - Homer J. Simpson
(Let op lezers: we hebben het nog steeds over Java.)quote:
Ik had zelf ook verwacht dat het resultaat niet anders zou zijn. Toch komt daysInstalled met waarden van -1, 0, 1, 2 en groter voor in m'n logs, dus er gaat iets mis. Ik kan met 100% zekerheid zeggen dat dat gelogd wordt doordat die statement true is.
En dit gebeurt niet meer nadat je & hebt vervangen door &&? En dat is ook het enige dat je veranderd hebt?
Dan kan ik het niet verklaren. Het enige verschil tussen de bitwise & en de logische && voor Java Booleans heb ik uitgelegd en zou hier geen verschillend resultaat mogen geven. Dit wordt gegarandeerd door de Java standaard.
Dus of (I) er gaat iets anders fout dan het &-&& verschil, of (II) je Java implementatie is kapot (of (III) ik heb het helemaal verkeerd, natuurlijk, maar ik denk van niet
).[ Bericht 0% gewijzigd door GS42 op 07-12-2013 12:27:39 ]
"Slechts diegene mag slopen die iets beters kan bouwen."
Hello again!
Dit stukje had ik eerder al geplaatst:
En nu zit ik wat verder te prutsen en kom er achter dat dit ook zou mogen
Welke zou jullie voorkeur hebben? Ik neig naar dit nieuwe voorbeeld, omdat ik dan een extra reference kwijt ben. Qua snelheid zit er volgens mij geen enkel verschil in? Wel is het zo dat de eerste variant wellicht iets leesbaarder is
//edit
moment. Nr 2 lijkt niet eens goed te werken
[ Bericht 4% gewijzigd door Holy_Goat op 09-12-2013 09:35:56 ]
Dit stukje had ik eerder al geplaatst:
| 1 2 3 4 5 6 7 8 | for (size_t y = 0; y < p_Par->Xtion.CanvasYRes;y=y++) { float* My = (p_OpenNiDataObj->ZMatrix).ptr<float>(y); for (size_t x = 0; x < p_Par->Xtion.CanvasXRes; x = x++) { float& Myx = My[x]; doe dingen met Myx } } |
En nu zit ik wat verder te prutsen en kom er achter dat dit ook zou mogen
| 1 2 3 4 5 6 7 8 9 10 | for (size_t y = 0; y < p_Par->Xtion.CanvasYRes;y=y++) { float* My = (p_OpenNiDataObj->ZMatrix).ptr<float>(y); for (size_t x = 0; x < p_Par->Xtion.CanvasXRes; x = x++) { Doe dingen met *My My++; //increment de pointer dus, ipv My[x] in een Myx reference zetten } } |
Welke zou jullie voorkeur hebben? Ik neig naar dit nieuwe voorbeeld, omdat ik dan een extra reference kwijt ben. Qua snelheid zit er volgens mij geen enkel verschil in? Wel is het zo dat de eerste variant wellicht iets leesbaarder is
//edit
moment. Nr 2 lijkt niet eens goed te werken
[ Bericht 4% gewijzigd door Holy_Goat op 09-12-2013 09:35:56 ]
Bonusvraag:
De Matrices waar ik mee werk zijn 320x240, en bevatten float data. Echter, de punten achter de komma zijn voor mij volkomen irrelevant.
Zou het programma met de vele loops die dus ook de vele float waarden aandoet er veel sneller van worden op het moment dat ik de matrices bij het verkrijgen al om zou zetten naar signed int zodat het complete programma met ints werkt?
Bonusvraag2: (triviaal?)
Ik weet dat de volgorde van if/else if statements de performance kan beinvloeden. De eerste statement voor wat je verwacht dat het vaakst gaat voorkomen, de tweede wat je iets minder vaak verwacht, etc.
Maar het gebeurt ook wel dat je waarden tegenkomt (vaak!) waar je niets mee doen wilt.
Is bovenste code dan beter dan de onderste?
[ Bericht 70% gewijzigd door Holy_Goat op 09-12-2013 10:08:01 ]
De Matrices waar ik mee werk zijn 320x240, en bevatten float data. Echter, de punten achter de komma zijn voor mij volkomen irrelevant.
Zou het programma met de vele loops die dus ook de vele float waarden aandoet er veel sneller van worden op het moment dat ik de matrices bij het verkrijgen al om zou zetten naar signed int zodat het complete programma met ints werkt?
Bonusvraag2: (triviaal?)
Ik weet dat de volgorde van if/else if statements de performance kan beinvloeden. De eerste statement voor wat je verwacht dat het vaakst gaat voorkomen, de tweede wat je iets minder vaak verwacht, etc.
Maar het gebeurt ook wel dat je waarden tegenkomt (vaak!) waar je niets mee doen wilt.
Is bovenste code dan beter dan de onderste?
| 1 2 3 4 5 6 7 8 9 10 11 12 | if (waarde==0) { //doe niets, en de waarde 0 komt 90% van de tijd voor } else if ( waarde == 1 ) { //doe iets met betrekking op gevonden waarde 1, komt 5% van de tijd voor } else if ( waarde == 2) { //doe iets met betrekking op gevonden waarde 2, komt het minst voor } |
| 1 2 3 4 5 6 7 8 | if ( waarde == 1 ) { //doe iets met betrekking op gevonden waarde 1, komt 5% van de tijd voor } else if ( waarde == 2) { //doe iets met betrekking op gevonden waarde 2, komt het minst voor } |
[ Bericht 70% gewijzigd door Holy_Goat op 09-12-2013 10:08:01 ]
Je zou zeggen van wel, en vroeger was dit ook vaak het geval. Maar tegenwoordig blijkt dat dit vooral aan de processor ligt waarmee je werkt. Ik zou zeggen probeer beide eens. Timer functie erom heen en kijk welke het snelst is (ik ben zelf ook wel benieuwd)quote:
Bonusvraag:
De Matrices waar ik mee werk zijn 320x240, en bevatten float data. Echter, de punten achter de komma zijn voor mij volkomen irrelevant.
Zou het programma met de vele loops die dus ook de vele float waarden aandoet er veel sneller van worden op het moment dat ik de matrices bij het verkrijgen al om zou zetten naar signed int zodat het complete programma met ints werkt?
Omdat er geen operatie bij if(waarde == 0) wordt gedaan, wordt deze if bij (verre weg de meeste) compilers weggegooid bij de optimalisatie. Dus er zal als het goed is geen verschil zijn in de performance tussen beide algoritmes.quote:Bonusvraag2: (triviaal?)
Ik weet dat de volgorde van if/else if statements de performance kan beinvloeden. De eerste statement voor wat je verwacht dat het vaakst gaat voorkomen, de tweede wat je iets minder vaak verwacht, etc.
Maar het gebeurt ook wel dat je waarden tegenkomt (vaak!) waar je niets mee doen wilt.
Is bovenste code dan beter dan de onderste?
[ code verwijderd ]
[ code verwijderd ]
Verder is de volgorde van de if statements idd wel iets wat je in je achterhoofd wil houden, je moet zorgen dat wat het vaakst voorkomt ook als eerste wordt geëvalueerd.
Dat geld ook voor 'nested conditions' zoals:
if ( (A && B) || (C && D) )
waarbij geld:
1. if A is false, goto 3.
2. if B is true, return true.
3. if C is false, return false.
4. if D is false, return false
[ Bericht 0% gewijzigd door Gehenna op 09-12-2013 10:48:30 ]
Robert Moog died for our synths
Dan maak je er ints van, ook al maakt het niets uit qua snelheid.quote:
Bonusvraag:
De Matrices waar ik mee werk zijn 320x240, en bevatten float data. Echter, de punten achter de komma zijn voor mij volkomen irrelevant.
switch/case. Of je gaat richting ijle matrices voor de minder-voorkomende waarden?quote:...
Bonusvraag2: (triviaal?)
Ik weet dat de volgorde van if/else if statements de performance kan beinvloeden. De eerste statement voor wat je verwacht dat het vaakst gaat voorkomen, de tweede wat je iets minder vaak verwacht, etc.
Maar het gebeurt ook wel dat je waarden tegenkomt (vaak!) waar je niets mee doen wilt.
Is bovenste code dan beter dan de onderste?
[ code verwijderd ]
[ code verwijderd ]
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
Hoe kun je dan het beste er voor zorgen dat het proces zo min mogelijk tijd kwijt is bij tegenkomen van een 0? Anders gaat ie voor elke 0 toch allebei de ifs checkenquote:
[..]
Je zou zeggen van wel, en vroeger was dit ook vaak het geval. Maar tegenwoordig blijkt dat dit vooral aan de processor ligt waarmee je werkt. Ik zou zeggen probeer beide eens. Timer functie erom heen en kijk welke het snelst is (ik ben zelf ook wel benieuwd)
[..]
Omdat er geen operatie bij if(waarde == 0) wordt gedaan, wordt deze if bij (verre weg de meeste) compilers weggegooid bij de optimalisatie. Dus er zal als het goed is geen verschil zijn in de performance tussen beide algoritmes.
Verder is de volgorde van de if statements idd wel iets wat je in je achterhoofd wil houden, je moet zorgen dat wat het vaakst voorkomt ook als eerste wordt geëvalueerd.
Dat geld ook voor 'nested conditions' zoals:
if ( (A && B) || (C && D) )
waarbij geld:
1. if A is false, goto 3.
2. if B is true, return true.
3. if C is false, return false.
4. if D is false, return false
Ik mis een betje waarom je uberhaubt met OpenCV matrices aan het werken bent. Je lijkt de matrix te 'misbruiken' als canvas van 320x240 pixels, en daarmee ben je opzoek naar optimalisaties omdat het blijkbaar niet snel genoeg is? Wat doet OpenCV preceis voor je in deze casus?
Ik zou zeggen dat als je een 'echte' canvas alloceerd (aaneengesloten blok geheugen, wat een twee-dimensionale array van (signed) integers representeerd), dat dat veel sneller en overzichtelijker werkt?
Ik zou zeggen dat als je een 'echte' canvas alloceerd (aaneengesloten blok geheugen, wat een twee-dimensionale array van (signed) integers representeerd), dat dat veel sneller en overzichtelijker werkt?
| 1 2 3 4 5 6 7 8 9 10 11 12 | #define RED(x) ((x)&0xff) #define GREEN(x) (((x)&0xff)<<8) #define BLUE(x) (((x)&0xff)<<16) static const unsigned c_width = 320; static const unsigned c_height = 240; unsigend long canvas[c_width * c_height] = {0}; unsigned long *pix = canvas; for(int y=0; y<c_height; y++) for(int x=0; x<c_width; x++) *pix++ = RED(x / 2) | GREEN(y/2); |
| Forum Opties | |
|---|---|
| Forumhop: | |
| Hop naar: | |