lnostdal

gcd er assosiativ, noe som vil si:

SWGtk> (defun my-gcd (a b)
         (if (zerop b)
             a
             (my-gcd b (mod a b))))
my-gcd
SWGtk> (my-gcd (my-gcd 203 91) 77)
7
SWGtk> (my-gcd 203 (my-gcd 91 77))
7
SWGtk> (my-gcd 30 (my-gcd 10 5))
5
SWGtk> (my-gcd (my-gcd 30 10) 5)
5

Common Lisp har allerede en funksjon `gcd' som tar et vilkårlig antall argumenter - derfor navnet `my-gcd'.

edit: rettet på indenteringen - som dette forumet fortsatt klusser til ... :|

edit2: en iterativ versjon, bare for morro:

(defmacro while (pred &body body)
  (let ((result (gensym)))
    `(let ((,result nil))
       (do () ((not ,pred) ,result)
         (setf ,result (progn ,@body))))))

(defun my-gcd2 (a b)
  (let ((tmp b))
    (while (not (zerop b))
      (setf b (mod a b))
      (setf a tmp))))

what? jeg trenger definitivt penger, og kan godt skrive om det der til c/c++

edit: ta gjerne kontakt på mail/msn/gtalk

6783446[/snapback]

lol - ja, kanskje det var det man skulle ha gjort; tatt skrinsjått av Emacs for hver bidige kodesnutt og hostet på hw-serveren - hadde blitt populært tenker jeg :}

ser ut til at det er en bug i forumet når man bruker semikolon i code-tags.. måtte teste dette litt ut, og gjorde det her: https://www.diskusjon.no/index.php?showtopic=625306

Når jeg vil skrive "a ; b" i en code-tag så blir dette trekt sammen til "a; b":

a; b
aa; bb

dette ser ut til å skje når man har en sekvens av tegn som dette:

* ett eller flere tegn

* mellomrom

* semikolon

* mellomrom

* ..og ett eller flere tegn

forresten irriterende hvordan forum-programvaren rører rundt med ting som indentering o.s.v. .. man må manuellt drive å rydde opp i koden etter man har pastet den for å "lure" en eller annen "smart" parser som står å justerer ting .. nærmest umulig å poste kode som ser bra ut :|

Tilsvarende eksempel som matcher det du var ute etter:

#include <oxymora/util/table.hpp>
#include <iostream>
#include <string>
#include <cstdlib>
#include <ctime>


using namespace std;
using namespace Oxymora;


template<typename T>
void readStdin(T& t, string msg, string on_wrong_input){	
 cout << msg << flush;
 while(!(cin >> t)){
   cout << on_wrong_input;
   cin.clear();
   cin.ignore(numeric_limits<streamsize>::max(), '\n');
   cout << msg << flush;}}


template<typename T>  
inline T toType(std::string const& source){
 std::istringstream iss(source);
 T ret;
 iss >> ret;
 return(ret);}


int main(){
 // This makes sure the random numbers really are random.
 srand(time(0)); srand(time(0));
 
 // 2 dimensional array of ints, with characters as "axis-elements".
 Table<2, int, char> table;

 table['1']['A'] = rand();
 table['1']['B'] = rand();
 table['1']['C'] = rand();
 table['2']['A'] = rand();
 table['2']['B'] = rand();
 table['2']['C'] = rand();
 table['3']['A'] = rand();
 table['3']['B'] = rand();
 table['3']['C'] = rand();

 while(true)
   {char x, y;
     readStdin(x, "Type in the X-axis-thingy: ", "No, I expect a character for the X-axis-thingy: ");
     cin.ignore(numeric_limits<streamsize>::max(), '\n');
     readStdin(y, "Type in the Y-axis-thingy: ", "No, I expect a character for the Y-axis-thingy: ");
     cin.ignore(numeric_limits<streamsize>::max(), '\n');
     cout << "table['" << x << "']['" << y << "']: " << table[x][y] << endl;}}

lars@ibmr52:~/programming/c/oxymora/demo/util$ ./table2

Type in the X-axis-thingy: 1

Type in the Y-axis-thingy: A

table['1']['A']: 724860259

Type in the X-axis-thingy: 1

Type in the Y-axis-thingy: B

table['1']['B']: 712215369

Type in the X-axis-thingy: 1

Type in the Y-axis-thingy: A

table['1']['A']: 724860259

Type in the X-axis-thingy:

edit:

siden det er _tegn_ som blir brukt til å spesifisere posisjoner på aksene må du gå over til `std::string' om du ønsker å lagre "tall" større enn 9 (altså flere enn étt tegn) .. du bør dog vurdere å bruke heltall på aksene i stedet - da kan ofte ting forenkles (og optimaliseres, om ønskelig) endel

Hm, forståelig?

6780121[/snapback]

nei

 

men kanskje det blir tydeligere med et lisp eksempel?

6780539[/snapback]

okei - hva vil du se? det er ikke dumt å trekke frem lisp, siden lisp er hva mange (nye; ironisk nok) språk trekker seg mot

edit:

forøvrig ganske forbauset over at en som allerede "kan" c++ ikke skjønner eks. mitt - for om jeg ikke husker feil så har du postet litt her tidligere?

åssen ville du ha forklart det? jeg har forsøkt å forklare dette "rom-messig" eller visuellt.. det er andre måter å forklare eller forstå disse tingene på, men det kan hende du bare er ute etter å lage faen og/eller mangler evnen til å bidra med noe selv .. :}

edit2 (såkallt "off topic"):

Skjult tekst: (Marker innholdet i feltet for å se teksten):

(defun long-calculation (arg)
 "A time consuming calculation."
 (let ((result (+ arg 2)));; not that long really, but ok
   (if (oddp result)
       result
       nil)))

#|
cl-user> (long-calculation 50)
nil
cl-user> (long-calculation 51)
53
cl-user> (long-calculation 52)
nil
cl-user> (long-calculation 53)
55
|#

(defun test ()
 (let ((result (long-calculation (random 98))))
   (if result 
;; no need to call long-calculation again here; we have it in a context named `result'
       (format t "long-calculation returned ~A~%" result) 
       (write-line "long-calculation failed!"))))


#|
cl-user> (test)
long-calculation failed!
"long-calculation failed!"
cl-user> (test)
long-calculation returned 51
nil
cl-user> (test)
long-calculation returned 51
nil
cl-user> (test)
long-calculation failed!
"long-calculation failed!"
cl-user> (test)
long-calculation returned 13
nil
|#

(defmacro aif (result-symbol test-form then-form &optional else-form)
 `(let ((,result-symbol ,test-form))
    (if ,result-symbol ,then-form ,else-form)))


(defun test ()
 (aif result (long-calculation (random 98))
;; no need to call long-calculation again here; we have it in a context named `result'
      (format t "long-calculation returned ~A~%" result) 
      (write-line "long-calculation failed!")))


#|
;; We take a peek at what happens behind the scenes:

cl-user> (macroexpand-1 '(aif result (long-calculation (random 98))
                ;; no need to call long-calculation again here; we have it in a context named `result'
                         (format t "long-calculation returned ~A~%" result) 
                         (write-line "long-calculation failed!")))
(let ((result (long-calculation (random 98))))
 (if result (format t "long-calculation returned ~A~%" result)
     (write-line "long-calculation failed!")))
t

;; ..see how this matches the previous definition of `test'?
|#

sorry dette.. veldig OT, men e veldig nobbie doobie doo her, så...

 

ka e vitsen med "std::" når det funker like bra å ikkje bruke d?

6779278[/snapback]

Det funker ikke "like bra". Man må bruke `std::' eller `using namespace std'.

Hverken spørsmålet eller svar folk gir, gir noen mening om du ikke forstår det som ligger bak dette med namespaces.

Et namespace er som ordet tilsier et "rom med navn i". Man kan ha flere "rom med navn i", og hvert av disse rommene har navn selv - så disse tingene kan nestes. Du kan tenke deg husnummer; de starter med 1 og går videre 2, 3, 4, 5 o.s.v.. Selv om jeg bor i "hus nr. 2" og en annen også bor i "hus nr. 2", bor vi i forskjellige gater - og ved å ta med gatenavnet (namespacet) i tillegg til husnummeret så er det ikke lenger tvil om hvilke av husene som menes når noen sier "åfossringen, hus nr. 2".

Noen ganger er det slitsomt å ta med gatenavnet hele veien i en litt lengre samtale - altså måtte legge til `std::' forran alt, og man starter derfor med å sette opp en sammenheng - `using namespace std', og det forståes dermed at det er hus nr. 2 i den-og-den gaten som gjelder når ikke noe annet blir sagt eksplisitt.

Hm, forståelig?

"What every computer scientist should know about floating-point arithmetic." ==> google

edit:

Tipper du kan få printf til å skrive ut flere desimaler, da ser du hva som skjer. Dette skjer på samme vis uansett språk:

cl-user> (let ((i 0))
          (loop
             (incf i 0.1)
             (format t "i = ~A~%" i)
             (when (> i 1.0)
               (write-line "reset!")
               (setf i 0))
             (sleep 1)))
i = 0.1
i = 0.2
i = 0.3
i = 0.4
i = 0.5
i = 0.6
i = 0.70000005
i = 0.8000001
i = 0.9000001
i = 1.0000001
reset!
i = 0.1
i = 0.2
i = 0.3
i = 0.4
i = 0.5
i = 0.6
i = 0.70000005
i = 0.8000001
i = 0.9000001
i = 1.0000001
reset!

..også når jeg bruker double (den defaulter til C's float over):

cl-user> (let ((i 0d0))
          (loop
             (incf i 0.1d0)
             (format t "i = ~A~%" i)
             (when (> i 1.0d0)
               (write-line "reset!")
               (setf i 0d0))
             (sleep 1)))
i = 0.1d0
i = 0.2d0
i = 0.30000000000000004d0
i = 0.4d0
i = 0.5d0
i = 0.6d0
i = 0.7d0
i = 0.7999999999999999d0
i = 0.8999999999999999d0
i = 0.9999999999999999d0
i = 1.0999999999999999d0
reset!
i = 0.1d0
i = 0.2d0

Som et alternativ kan du gå over til "brøk" (C.L. har innebygget støtte for dette btw.) i stedet for flytetall. Da lagrer du to heltall - teller og nevner, og oppnår dermed 100% nøyaktighet. Du kan også lagre det forran komma som et tall og det etter komma som et tall på et lignende vis - om jeg ikke husker helt feil i farta her.

her er en som gjør at du kan bruke "hva som helst" til indeksering:

http://nostdal.org/~lars/programming/c/oxy.../util/table.hpp

http://nostdal.org/~lars/programming/c/oxy.../util/table.cpp

under kjøring:

edit: ble bedre her: http://paste.lisp.org/display/25008

lars@ibmr52:~/programming/c/oxymora/demo/util$ ./table

tegner brettet

....................

....................

....................

....................

....................

....................

....................

....................

....................

....................

 

setter et kryss

tegner brettet

....................

....................

....................

..X.................

....................

....................

....................

....................

....................

....................

 

setter en sirkel

tegner brettet

....................

....................

....................

..X.................

...O................

....................

....................

....................

....................

....................

 

                                                                      #

                                                                    # #

                                                                    #  #

                                                                  # # # #

                                                                  #      #

                                                                # #    # #

                                                                #  #  #  #

                                                              # # # # # # # #

                                                              #              #

                                                            # #            # #

                                                            #  #          #  #

                                                          # # # #        # # # #

                                                          #      #      #      #

                                                        # #    # #    # #    # #

                                                        #  #  #  #  #  #  #  #

                                                      # # # # # # # # # # # # # # # #

                                                      #                              #

                                                    # #                            # #

                                                    #  #                          #  #

                                                  # # # #                        # # # #

                                                  #      #                      #      #

                                                # #    # #                    # #    # #

                                                #  #  #  #                  #  #  #  #

                                              # # # # # # # #                # # # # # # # #

                                              #              #              #              #

                                            # #            # #            # #            # #

                                            #  #          #  #          #  #          #  #

                                          # # # #        # # # #        # # # #        # # # #

                                          #      #      #      #      #      #      #      #

                                        # #    # #    # #    # #    # #    # #    # #    # #

                                        #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #

                                      # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

                                      #                                                              #

                                    # #                                                            # #

                                    #  #                                                          #  #

                                  # # # #                                                        # # # #

                                  #      #                                                      #      #

                                # #    # #                                                    # #    # #

                                #  #  #  #                                                  #  #  #  #

                              # # # # # # # #                                                # # # # # # # #

                              #              #                                              #              #

                            # #            # #                                            # #            # #

                            #  #          #  #                                          #  #          #  #

                          # # # #        # # # #                                        # # # #        # # # #

                          #      #      #      #                                      #      #      #      #

                        # #    # #    # #    # #                                    # #    # #    # #    # #

                        #  #  #  #  #  #  #  #                                  #  #  #  #  #  #  #  #

                      # # # # # # # # # # # # # # # #                                # # # # # # # # # # # # # # # #

                      #                              #                              #                              #

                    # #                            # #                            # #                            # #

                    #  #                          #  #                          #  #                          #  #

                  # # # #                        # # # #                        # # # #                        # # # #

                  #      #                      #      #                      #      #                      #      #

                # #    # #                    # #    # #                    # #    # #                    # #    # #

                #  #  #  #                  #  #  #  #                  #  #  #  #                  #  #  #  #

              # # # # # # # #                # # # # # # # #                # # # # # # # #                # # # # # # # #

              #              #              #              #              #              #              #              #

            # #            # #            # #            # #            # #            # #            # #            # #

            #  #          #  #          #  #          #  #          #  #          #  #          #  #          #  #

          # # # #        # # # #        # # # #        # # # #        # # # #        # # # #        # # # #        # # # #

          #      #      #      #      #      #      #      #      #      #      #      #      #      #      #      #

        # #    # #    # #    # #    # #    # #    # #    # #    # #    # #    # #    # #    # #    # #    # #    # #

        #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #

      # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

      #                                                                                                                              #

    # #                                                                                                                            # #

    #  #                                                                                                                          #  #

  # # # #                                                                                                                        # # # #

  #      #                                                                                                                      #      #

# #    # #                                                                                                                    # #    # #

    #  #  #                                                                                                                  #  #  #

  # # # # # #                                                                                                                # # # # # #

  #          #                                                                                                              #          #

# #        # #                                                                                                            # #        # #

    #      #  #                                                                                                          #  #      #

  # #    # # # #                                                                                                        # # # #    # #

  #  #  #      #                                                                                                      #      #  #  #

# # # # # #    # #                                                                                                    # #    # # # # # #

            #  #  #                                                                                                  #  #  #

          # # # # # #                                                                                                # # # # # #

          #          #                                                                                              #          #

        # #        # #                                                                                            # #        # #

        #  #      #  #

........

edit: ble bedre her: http://paste.lisp.org/display/25008

hvorfor det? man sparer masse tid på det, og det er lite sansynlig at man får kluss siden så lenge man ikke gjør det i header-filer slik at det "smitter" til definisjons-filer

edit: tipper du ikke spiser din egen hundemat her (hva er norsk for dette uttrykket btw.? http://en.wikipedia.org/wiki/Eat_one's_own_dog_food )

øhh .. men dere? .. jeg kom akkurat på at C99 - som ironisk nok er det jeg bruker her for å få til det stuffet i `for' har støtte for run-time sizeof-stasj, slik:

edit:

nope; GCC støtter ikke dette helt ennå [*] gir en advarsel om det i det minste .. sjekk http://www.informit.com/guides/content.asp...seqNum=215&rl=1

Om du absolutt - av en eller annen grunn - ikke ønsker å sende antall elementer inn som et eget argument til funksjonen, kan du gjøre det slik:

#include <stdio.h>
#include <stdlib.h>

typedef unsigned int uint;


typedef struct {
 int x, y;
} Stuff;


void printStuff(Stuff* stuff){
 uint const n_stuff = *(uint*)stuff;
 printf("We now know that the number of items is: %d\n", n_stuff);
 stuff++;
 for(uint i = 0; i < n_stuff; i++)
   printf("%d %d\n", stuff[i].x, stuff[i].y);}


int main(){
 uint const n_stuff = 5;

 Stuff stuff[n_stuff + 1];
 *(uint*)stuff = n_stuff; // yay - we "cheat"
 for(uint i = 1; i < n_stuff + 1; i++){
   stuff[i].x = i * i;
   stuff[i].y = i + i;}
 
 printStuff(stuff);
 return 0;} 

lars@ibmr52:~/programming/c$ gcc -std=c99 -g -Wall a.c -o a && ./a

We now know that the number of items is: 5

1 2

4 4

9 6

16 8

25 10

..men ville helt klart holdt meg til den noe (lol) mer tradisjonelle løsningen der man sender inn antall elementer som et eget argument ja. Denne ble kun satt sammen for morro; einaros kommer til å grine når han ser dette - hehe

I Nautilus: File -> Connect to Server

Så velger du SSH (SFTP) og taster inn brukernavn/passord etc. (port 22 er vanlig for SSH). Du kan få den til å "cache" passord.

Trykker du siden F9 og har "Places" valgt i dropdown-boksen så ser du en snarvei til serveren.

edit:

SSHFS er forresten kjempefin å jobbe med. Da "mounter" du en katalog fra en annen maskin lokalt på samme vis som du "mounter" vanlige disker - og du får tilgang på samme vis, altså som om det var en vanlig disk.

Både Ubuntu og SUSE har live-CDer .. last ned og test selv.

Jeg er 100% fornøyd med Ubuntu, og har ikke testet SUSE.

Noen tips til optimalisering?

6746802[/snapback]

Paste eller link til koden så kanskje.

Tar jeg ikke helt feil så har du ikke noe kode i det hele tatt. Finner det lite sansynlig at du har problemer med hastighet i GUI-biten da GTK er skrevet i C. Den dispatcher bare til Python (callback á C-sjargong) ved events, noe som i "dataverdenen" skjer ytterst sjeldent.

For det andre så sitter sjeldent problemer med hastighet i GUI-biten i utgangspunktet. Som Frank2004 er inne på så håndterer man ikke ting som tar tid i GUI-tråden, men i en egen bakgrunnstråd.

..okei, kan flame litt - siden jeg har vondt i hue og føler meg ussel..

Signaturen din ("jeg har masse tullete innlegg") ser ut til å matche postene dine, og det ser ut til at du er et troll med subjektive og innholdsløse meninger uten noe konkret å henvise til.

edit: Gjør deg selv en tjeneste og vis at jeg tar feil.

m'huh .. har du noe konkret å henvise til?

edit:

..altså som har gjort at du har måttet gi opp pygtk basert på problemer med hastighet

(vet kanskje dette fra før, men hvorfor ikke..)

44.1kHz/s vil si hvor ofte (x-aksen) målingen blir gjort pr. sekund; tror Giddion spør om hvor høy oppløsning (y-aksen) hver måling skal ha.

8 bits oppløsning vil si at signalet kan ha 256 mulige posisjoner eller verdier (y-aksen) ved hver måling. Et eksempel her kan være verdier mellom -128 og 128, der 0 i sammenheng med en høyttaler vil si hvilestilling, -128 vil si fullt utslag inn og 128 vil si fullt utslag ut.

44.1kHz 16bit er vanlige oppløsninger for CD-lyd, noe som gir 65536 mulige posisjoner/verdier á y-aksen.

edit:

Egentlig bør det vel være enkelt å parameterisere disse tingene - sånn at brukeren kan spesifisere selv.

Tror jeg skulle få til dette under Linux, men du er sikkert ute etter noe til win32?

edit:

uhm, eller hva med å ganske enkelt kalle en ekstern prosess (altså starte et program) som gjør det for en? .. tipper det finnes et lite verktøy for dette til linux

dette holder sikkert i mange tilfeller:

rec --rate=44100 result.wav

sox result.wav result.raw

Leste ikke hele innlegget til lnostdal,

6724380[/snapback]

haha, nei - det er det visst sjelden folk gidder

neida; jeg bare troller/kjeder meg

Arrayer i C (og mer eller mindre alle andre språk) starter fra 0, så du skal gjøre `int kort = 52;' og gå fra kortstokk[0] til kortstokk[51].

Siden du bruker C++ bør du her bruke f.eks. std::list http://cppreference.com/cpplist/index.html

Når du leser inn navnet på kortet den skal lete etter må du bruke `getline', slik: getline(cin, valgtkort);

Når du bruker C++ og skal lete etter ting i konteinere som f.eks. std::list bruker du std::find http://cppreference.com/cppalgorithm/find.html

*blablabla .. Wintendo .. blablbla*

..synd for deg..

På Windows trenger man ofte "Intel CHipset driver", "Via 4-in-1" osv, særlig på nyere hardware som har kommet etter Windowslanseringen. Finnes det en distro hvor jeg "slipper" å bekymre meg for dette? 

Ja, alle distroer som holdes oppdatert. Sjekk eventuelle "klager" - der kjernen sier "kan bare bruke generiske drivere" e.l. i logger under /var/log/* og/eller ved å taste inn dmesg og trykke enter.

Google kjører Linux - Google har mange brukere - Google går kjappt.

- Er det andre ting jeg bør vite om, både fordeler og ulemper, før jeg barker avgårde på Linux & VMware??

6719076[/snapback]

Nah, Linux & VMWare fungerer utmerket.

#include <iostream>

using namespace std;

int main()
{
 string s;
 getline(cin, s);
 for(string::size_type i = 0; i < s.length(); i++)
   cout << hex << static_cast<int>(s[i]) << " ";
 cout << endl;
 return 0;
}

lars@ibmr52:~/programming/c$ g++ -g -Wall string-to-hex-values.cpp -o string-to-hex-values && ./string-to-hex-values

Dette er en test

44 65 74 74 65 20 65 72 20 65 6e 20 74 65 73 74

http://www.cppreference.com/cppstring/index.html

http://www.cppreference.com/io_flags.html#format_flags

Om du ikke har noen konkrete spørsmål gidder jeg ikke forklare det her da det er basic stuff; google etter "Thinking in C++" så ser du selv.

edit:

Samme i Lisp, siden jeg er et Off Topic trollende rasshøl med alt for mye fritid .. vel, óg fordi jeg synes Lisp er morro:

cl-user> (map 'list (lambda (ch)
                      (format nil "~X" (char-code ch)))
              "Dette er en test")
("44" "65" "74" "74" "65" "20" "65" "72" "20" "65" "6E" "20" "74" "65" "73" "74")

..indenteringa på møkkaforumet er offbeat igjen btw..

hum, noe slikt?

#include <iostream>

using namespace std;

int main()
{
 string s = "Hello World";
 for(string::size_type i = 0; i < s.length(); i++)
   cout << hex << static_cast<int>(s[i]) << " ";
 cout << endl;
 return 0;
}

lars@ibmr52:~/programming/c$ g++ -g -Wall string-to-hex-values.cpp -o string-to-hex-values && ./string-to-hex-values

48 65 6c 6c 6f 20 57 6f 72 6c 64

Eventuellt assoc array, map eller hash-table. (jeg har ikke oversikt over hva klassene for disse tingene heter i C# atm.)