• Anmelden
  • Registrieren
  • Suche
  1. Dashboard
  2. Forum
    1. Unerledigte Themen
  3. Mitglieder
    1. Letzte Aktivitäten
    2. Benutzer online
    3. Team-Mitglieder
    4. Trophäen
    5. Mitgliedersuche
  4. Tutorial Bereich
Alles
  • Alles
  • Artikel
  • Seiten
  • Forum
  • Lexikon
  • Erweiterte Suche
  1. Informatik Forum
  2. Mitglieder
  3. Plantschkuh!

Beiträge von Plantschkuh!

  • Student Connect: Chello

    • Plantschkuh!
    • 11. September 2006 um 00:14
    Zitat von Craft4

    Aber - funkt das Teil mit Laptop auch? da hab ich nichts gefunden, ich will mir sowohl PC als auch Laptop anschließen können.


    Ja, funktioniert mit einer ganz normalen Ethernetkarte. Aber: der Anschluß wird an die MAC-Adresse einer Netzwerkkarte gebunden, d.h. zwischen PC und Laptop umstecken is nich, zumindest nicht ohne weiteres. (Ich versteh deinen Post so, daß du das so willst.) Da muß dann ein Router dazwischen, was von Chello aus wieder nicht erlaubt ist, aber die finden das ja nicht raus.

  • Student Connect: Chello

    • Plantschkuh!
    • 10. September 2006 um 16:24

    Das war bei mir auch mal irgendwie so. Ich hab mich dann nach nochmal gerührt, ich glaub direkt bei Chello, dann ist es eh schnell gegangen. Wenn du schon mehrere Wochen wartest, steig ihnen aufs Dach.

  • Zeitintervalle messen

    • Plantschkuh!
    • 5. September 2006 um 21:58
    Zitat

    Es sieht für mich jetzt so aus als ob clock() nur die Clocks im aktuellen Prozess misst und nicht systemweit


    Zuallererst mißt clock() Prozessorzeit, nicht wall time. Und eben vielleicht nur Prozessorzeit als "user", also ohne Syscalls.

    Zitat

    Wie kann ich Zeitintervalle zuverlässig und plattformunabhängig messen?


    In ISO C++ gar nicht, du wirst eine Library brauchen. Nur aus Interesse, ist dein Grafikcode rein plattformunabhängig?

    Zitat

    (CLOCKS_PER_SEC ist dort 100, unter Windows ist es 1000; unter Linux sogar 1.000.000 - funktioniert aber wie gesagt nicht).


    Die Million ist auch nur Show, soweit ich das im Kopf hab zählt unter Linux die clock-Funktion eben in Tausenderschritten.

  • Problem mit jpeglib.h

    • Plantschkuh!
    • 31. August 2006 um 01:22
    Zitat von weixi

    Warum jedoch reicht es nicht im zu kompilierenden File einfach alles mittels Include einzubinden, wie man es etwa mit stdio.h macht?


    Das Header-File enthält nur Deklarationen der verwendeten Funktionen (und Makros, Typen etc.). Die Definitionen der Funktionen, also der wirkliche Code, sind in Libraries zu finden.

    Der Compiler (bzw. richtigerweise der Linker) weiß nicht, welcher Header zu welcher Library gehört, also muß man das explizit angeben. Die Standard-Library ist da eine Ausnahme, die wird automatisch immer eingebunden; die in stdio.h deklarierten Funktionen gehören da dazu. (Noch eine Ausnahme gibt es: Unter Unix ist es traditionell so, daß die Funktionen von math.h, obwohl auch zur Standard-Library gehörig, nicht automatisch gelinkt werden. Wenn man also math.h verwendet, ist normalerweise auch ein -lm auf der Kommandozeile für den Linker notwendig.)

  • Wie oft ist ein String in einem Array?

    • Plantschkuh!
    • 30. August 2006 um 18:18
    Zitat von Christoph R.

    Assoziative Arrays würden sich in PHP anbieten, wobei ich aber nicht weiß wie gut oder schlecht da die Performance ist. Ich würde es einfach mal ausprobieren.


    Notfalls kann man sich auch assoziative Arrays mittels AVL-Bäumen oder sowas selber basteln. Jedenfalls ist so ziemlich jede Datenstruktur besser als ein unsortiertes Array von Strings mit Mehrfachvorkommen...

    Zitat

    Mit Hash-Werten wäre ich eher vorsichtig, weil die u. U. nicht eindeutig sind


    Trotzdem ein großer Schritt vorwärts, wenn man nur noch eine (normalerweise sehr kurze) Liste von Strings mit genau dem Hashwert betrachten muß.

  • Rechenprogramm

    • Plantschkuh!
    • 19. Juli 2006 um 20:59

    Auf Unixen gibts üblicherweise das Programm bc, das sowas kann; auf den Studservern ist es auch vorhanden.

    Code
    10^1000
    1000000000000000000000000000000000000000000000000000000000000000000000\
    0000000000000000000000000000000000000000000000000000000000000000000000\
    0000000000000000000000000000000000000000000000000000000000000000000000\
    0000000000000000000000000000000000000000000000000000000000000000000000\
    0000000000000000000000000000000000000000000000000000000000000000000000\
    0000000000000000000000000000000000000000000000000000000000000000000000\
    0000000000000000000000000000000000000000000000000000000000000000000000\
    0000000000000000000000000000000000000000000000000000000000000000000000\
    0000000000000000000000000000000000000000000000000000000000000000000000\
    0000000000000000000000000000000000000000000000000000000000000000000000\
    0000000000000000000000000000000000000000000000000000000000000000000000\
    0000000000000000000000000000000000000000000000000000000000000000000000\
    0000000000000000000000000000000000000000000000000000000000000000000000\
    0000000000000000000000000000000000000000000000000000000000000000000000\
    000000000000000000000
    Alles anzeigen

    Was den Komfort betrifft, schaust du dir am besten an, ob es dir paßt.

  • Verbessert eueren Linksysrouter WRT54G (und auch andere) mit DD-WRT!

    • Plantschkuh!
    • 6. Juli 2006 um 18:44
    Zitat von For3st

    Hi leute hab gestern meinen Linksys WRT54G Wireless Router mit einer neuen Firmware aufgeppet


    Das Schlüsselwort ist "gestern". Ich bin vor einem halben Jahr einige Zeit mit DD-WRT gefahren, es war aber ziemlich instabil. Alle 24-48 Stunden ging mal nix, ich mußte den Router neu booten.
    Jetzt hab ich wieder die normale Linksys-Firmware und keinen Grund zur Klage. (Die angepriesenen Vorteile von DD-WRT habe ich nicht gebraucht.)

  • Binäre Quersumme in C/Assembler optimieren

    • Plantschkuh!
    • 27. Juni 2006 um 12:29

    Ich verwend den gcc 3.3, aber halt auf meinem iBook, da wird natürgemäß PowerPC-Code generiert. Variante 1:

    Code
    _quersumme32:
            mflr r7
            bcl 20,31,"L00000000001$pb"
    "L00000000001$pb":
            mflr r2
            srwi r11,r3,16
            addis r6,r2,ha16(_quersumme_8-"L00000000001$pb")
            rlwinm r5,r3,0,24,31
            la r12,lo16(_quersumme_8-"L00000000001$pb")(r6)
            rlwinm r4,r3,24,24,31
            rlwinm r8,r11,0,24,31
            srwi r9,r11,8
            lbzx r10,r12,r5
            mtlr r7
            lbzx r0,r12,r4
            lbzx r5,r12,r9
            lbzx r6,r12,r8
            add r7,r10,r0
            rlwinm r3,r7,0,0xff
            add r2,r6,r5
            rlwinm r4,r2,0,0xff
            add r2,r3,r4
            rlwinm r3,r2,0,0xff
            blr
    Alles anzeigen

    Variante 2:

    Code
    _quersumme32:
            mflr r6
            bcl 20,31,"L00000000001$pb"
    "L00000000001$pb":
            mflr r2
            srwi r11,r3,24
            addis r5,r2,ha16(_quersumme_8-"L00000000001$pb")
            rlwinm r10,r3,16,24,31
            la r12,lo16(_quersumme_8-"L00000000001$pb")(r5)
            rlwinm r8,r3,24,24,31
            lbzx r4,r12,r11
            rlwinm r7,r3,0,24,31
            lbzx r9,r12,r10
            mtlr r6
            lbzx r6,r12,r8
            add r0,r4,r9
            lbzx r4,r12,r7
            add r5,r6,r0
            add r2,r4,r5
            rlwinm r3,r2,0,0xff
            blr
    Alles anzeigen

    Sicher kein weltbewegender Unterschied, und ich wüßt nichtmal, ob zweiteres schneller ist. Schaut aber etwas besser aus.

  • Binäre Quersumme in C/Assembler optimieren

    • Plantschkuh!
    • 27. Juni 2006 um 03:28

    Ich hab keine Vergleichsplattform zur Verfügung und meine Assembly-Kenntnisse sind etwas eingerostet, aber: Wenn du willst, daß der Optimierer gute Leistungen bringt, pfusch ihm nicht ins Handwerk. Für folgenden Code:

    Code
    unsigned char quersumme32(unsigned int x) {
        return quersumme_8[(x>>24) & 0xff] + quersumme_8[(x>>16) & 0xff]
            + quersumme_8[(x>>8) & 0xff] + quersumme_8[x & 0xff];
    }


    spuckt mein gcc mit -O3 hübscheren, kürzeren Code aus als für deinen. Wieso? Weil die Semantik von dem, was du erreichen willst, viel klarer rüberkommt. Und die Semantik ist das, womit der Optimierer nunmal arbeitet; viele Optimierungen hauen (leider) nicht hin, wenn man die gewünschte Berechnung über mehrere Statements verteilt.

  • Idee für Regexpression

    • Plantschkuh!
    • 15. Juni 2006 um 20:26

    Es ist mit Regexps nicht möglich, sowas wie "einer von diesen Buchstaben, und später genau der selbe nochmal" auszudrücken.

    Das beste, was man tun könnte, wären getrennte Regexps für jeden Buchstaben (d.h. "a kommt negiert und nicht negiert vor", "b kommt negiert und nicht negiert vor", ...), die dann mit | verbunden werden. Das ist aber natürlich nicht befriedigend; ich würde sagen, du brauchst ein mächtigeres Tool.

  • Wozu braucht ihr euer Handy?

    • Plantschkuh!
    • 22. Mai 2006 um 16:17
    Zitat von Swoncen

    Wozu brauch ich einen Fernseher, wenn ich unterwegs bin?

    Naheliegende Antwort: Um auch unterwegs das Fernsehprogramm konsumieren zu können, wenn einen das freut. Während der olympischen Spiele hab ich einen in der U6 gesehen, der sich auf seinem Handy die Herrenabfahrt gegeben hat, sie war ihm halt wichtig und er war gerade nicht zuhause. Wieso auch nicht?

    Zu den Fotos: Ich mache manchmal Schnappschüsse mit meiner Handykamera, aber die Qualität ist nicht besonders und ich bräuchte einen Windows-Rechner, um die Bilder irgendwohin transferieren zu können. Also würde ich die Kamera kaum vermissen, hab deswegen die erste Option angekreuzt.

  • Sudoku in Prolog

    • Plantschkuh!
    • 15. Mai 2006 um 17:53

    In der einen Datei kannst du deine Instanzen definieren:

    Code
    sudokuinstanz([[1,2,3,_,_,9,7,8,4], ...]).


    oder

    Code
    sudokuinstanz(1,2,3,_,_,9,7,8,4, ...).

    Und in der anderen Datei in deinem Sudoku-Prädikat diese sudokuinstanz als Ziel (am Anfang) einfügen.

  • Integer und Long

    • Plantschkuh!
    • 6. Mai 2006 um 20:51

    "integer" ist weder das selbe wie "int" noch "Integer", no?
    "integer" heißt "ganzzahlig", du hast also eine zu große ganze Zahl angegeben. Zu groß für irgendeinen der ganzzahligen Datentypen, die Java so kennt.

  • Ganzzahlige Datentypen

    • Plantschkuh!
    • 6. Mai 2006 um 19:56

    Das Vorzeichenbit ist eines der acht Bits, üblicherweise das "erste".
    0 bis 127 werden meistens durch die Bitmuster 00000000 bis 01111111 dargestellt, -128 bis -1 durch 10000000 bis 11111111. Das sind, wie du schon richtig festgestellt hast, 128 + 128 = 256 Bitmuster.

  • Grundrechnungsarten

    • Plantschkuh!
    • 20. April 2006 um 14:53
    Zitat von Swoncen

    Oder ist alles gleich schnell?


    Ja. Subtraktionen sind auch nur Additionen (mit vorheriger Ermittlung des Komplements, aber das ist gratis), und Vergleiche mit > sind auch nur Subtraktionen. Du hast also bei jeder Variante die Kosten von zwei Additionen, und die sind wohl immer gleich schnell.

    Aber... bist du dir sicher, daß du diese Frage überhaupt stellen solltest? Wenn dein Programm zu langsam ist, optimiere richtig, statt an solchen winzigen Kleinigkeiten zu feilen. Oder verwende nicht Java... (das ist jetzt eine Annahme).
    Wenn es aber nicht zu langsam ist, dann ist Mikrooptimierung Zeitverschwendung.

  • rechnet sun-jdk falsch?

    • Plantschkuh!
    • 17. April 2006 um 11:45
    Zitat von Swoncen

    Wo isn da der Unterschied im Quelltext?


    Direkt vor deiner Nase :) Der eine verwendet 3.2, der andere "3.2". Das ist relevant, weil 3.2 schon als Gleitpunktzahl dargestellt wird und daher ungenau ist. Aus dem String "3.2" kann sich der Konstruktor allerdings ein genaue Darstellung ausschnapsen.

    Zitat

    Bigdecimal kann zwar eine genauere Darstellung liefern, aber nie 100%ig exakt sein


    Doch, kann es. Jede Zahl, die aus einem endlich langen Dezimalstring konstruiert wird, ist notwendigerweise rational; rationale Zahlen kannst du mit einem Paar aus einer ganzen und einer natürlichen Zahl exakt darstellen (natürlich ist für beliebige Genauigkeit beliebig viel Speicher nötig, aber in der "Praxis" wird der üblicherweise reichen). Weiters sind die rationalen Zahlen abgeschlossen gegenüber den Grundrechnungsarten. Solang du also nur +, -, *, / rechnest, werden deine Ergebnisse intern immer genau sein.
    Daß etwa 1/3 im Output nicht als endlicher Dezimalstring darstellbar ist, ist eine andere Geschichte.

    EDIT: Na gut, das obige stimmt so nicht für BigDecimal; es ist problemlos möglich, rationale Zahlen exakt darzustellen, allerdings macht BigDecimal was anderes.

  • Sudoku in Prolog

    • Plantschkuh!
    • 6. April 2006 um 00:24
    Zitat von klausi

    Plantschkuh muss ich jetzt respekt oder angst vor dir haben, weil du mir mit einer vollwertigen lösung binnen einer stunde aufwartest?:zwinker:


    Mir ist beides recht :) Naja, viel war echt nicht zu machen, der größte Teil des Codes stammt von dir. Ich hab nur ein paar Sachen umbenannt und die Vergleiche nach vorne gezogen.
    Außerdem hätte ich gerade total fleißig eine Präsentation ausarbeiten sollen, also hatte ich viel Zeit für sowas...

  • Sudoku in Prolog

    • Plantschkuh!
    • 5. April 2006 um 14:36

    Es ist in Prolog zwar relativ straight forward, sowas zu formulieren, aber wenn der Suchraum exponentiell ist, dann wird der Interpreter auch exponentiell lang suchen...
    Was extrem ineffizient ist, ist daß dein Programm (sehr oft) alle möglichen Kombinationen der Ziffern 1 bis 9 aufzählt und erst dann auf Ungleichheit testet. Besser ist sicher, zuerst mit dif/2 alle Constraints zuzusichern und erst dann die Variablen mit Werten zu belegen. dif/2 unterscheidet sich von =\= und anderen Ungleichheitsprädikaten darin, daß die Argumente noch nicht instanziiert sein müssen; wenn irgendwann später mal beide bekannt sind, wird erst verglichen. Damit schließt man schon während der Aufzählung möglichst früh ungünstige Konstellationen aus.

    Hier ist dein Code mit entsprechenden Modifikationen:

    Code
    zahl(1). zahl(2). zahl(3).
    zahl(4). zahl(5). zahl(6).
    zahl(7). zahl(8). zahl(9).
    
    
    unterschiedlich(A,B,C,D,E,F,G,H,I) :-
        dif(A,B), dif(A,C), dif(A,D), dif(A,E), dif(A,F), dif(A,G), dif(A,H), dif(A,I),
                  dif(B,C), dif(B,D), dif(B,E), dif(B,F), dif(B,G), dif(B,H), dif(B,I),
                            dif(C,D), dif(C,E), dif(C,F), dif(C,G), dif(C,H), dif(C,I),
                                      dif(D,E), dif(D,F), dif(D,G), dif(D,H), dif(D,I),
                                                dif(E,F), dif(E,G), dif(E,H), dif(E,I),
                                                          dif(F,G), dif(F,H), dif(F,I),
                                                                    dif(G,H), dif(G,I),
                                                                              dif(H,I).
    zahlen(A,B,C,D,E,F,G,H,I) :-
        zahl(A), zahl(B), zahl(C),
        zahl(D), zahl(E), zahl(F),
        zahl(G), zahl(H), zahl(I).
    
    
    sudoku( X11,X12,X13,X14,X15,X16,X17,X18,X19,
            X21,X22,X23,X24,X25,X26,X27,X28,X29,
            X31,X32,X33,X34,X35,X36,X37,X38,X39,
            X41,X42,X43,X44,X45,X46,X47,X48,X49,
            X51,X52,X53,X54,X55,X56,X57,X58,X59,
            X61,X62,X63,X64,X65,X66,X67,X68,X69,
            X71,X72,X73,X74,X75,X76,X77,X78,X79,
            X81,X82,X83,X84,X85,X86,X87,X88,X89,
            X91,X92,X93,X94,X95,X96,X97,X98,X99) :-
            % zeilen
            unterschiedlich(X11,X12,X13,X14,X15,X16,X17,X18,X19),
            unterschiedlich(X21,X22,X23,X24,X25,X26,X27,X28,X29),
            unterschiedlich(X31,X32,X33,X34,X35,X36,X37,X38,X39),
            unterschiedlich(X41,X42,X43,X44,X45,X46,X47,X48,X49),
            unterschiedlich(X51,X52,X53,X54,X55,X56,X57,X58,X59),
            unterschiedlich(X61,X62,X63,X64,X65,X66,X67,X68,X69),
            unterschiedlich(X71,X72,X73,X74,X75,X76,X77,X78,X79),
            unterschiedlich(X81,X82,X83,X84,X85,X86,X87,X88,X89),
            unterschiedlich(X91,X92,X93,X94,X95,X96,X97,X98,X99),
            % spalten
            unterschiedlich(X11,X21,X31,X41,X51,X61,X71,X81,X91),
            unterschiedlich(X12,X22,X32,X42,X52,X62,X72,X82,X92),
            unterschiedlich(X13,X23,X33,X43,X53,X63,X73,X83,X93),
            unterschiedlich(X14,X24,X34,X44,X54,X64,X74,X84,X94),
            unterschiedlich(X15,X25,X35,X45,X55,X65,X75,X85,X95),
            unterschiedlich(X16,X26,X36,X46,X56,X66,X76,X86,X96),
            unterschiedlich(X17,X27,X37,X47,X57,X67,X77,X87,X97),
            unterschiedlich(X18,X28,X38,X48,X58,X68,X78,X88,X98),
            unterschiedlich(X19,X29,X39,X49,X59,X69,X79,X89,X99),
            % kaestchen
            unterschiedlich(X11,X12,X13,X21,X22,X23,X31,X32,X33),
            unterschiedlich(X14,X15,X16,X24,X25,X26,X34,X35,X36),
            unterschiedlich(X17,X18,X19,X27,X28,X29,X37,X38,X39),
            unterschiedlich(X41,X42,X43,X51,X52,X53,X61,X62,X63),
            unterschiedlich(X44,X45,X46,X54,X55,X56,X64,X65,X66),
            unterschiedlich(X47,X48,X49,X57,X58,X59,X67,X68,X69),
            unterschiedlich(X71,X72,X73,X81,X82,X83,X91,X92,X93),
            unterschiedlich(X74,X75,X76,X84,X85,X86,X94,X95,X96),
            unterschiedlich(X77,X78,X79,X87,X88,X89,X97,X98,X99),
            % alles zahlen
            zahlen(X11,X12,X13,X14,X15,X16,X17,X18,X19),
            zahlen(X21,X22,X23,X24,X25,X26,X27,X28,X29),
            zahlen(X31,X32,X33,X34,X35,X36,X37,X38,X39),
            zahlen(X41,X42,X43,X44,X45,X46,X47,X48,X49),
            zahlen(X51,X52,X53,X54,X55,X56,X57,X58,X59),
            zahlen(X61,X62,X63,X64,X65,X66,X67,X68,X69),
            zahlen(X71,X72,X73,X74,X75,X76,X77,X78,X79),
            zahlen(X81,X82,X83,X84,X85,X86,X87,X88,X89),
            zahlen(X91,X92,X93,X94,X95,X96,X97,X98,X99).
    Alles anzeigen

    Das ist mit deinem Testfall ziemlich schnell: 429,041 inferences, 0.34 CPU in 0.38 seconds (89% CPU, 1261885 Lips)
    Ob auch das Ergebnis stimmt, kann wer anderer überprüfen :)

    Hübscher wäre das ganze übrigens mit Listen, aber was soll's. Und auch mit Constraints, siehe 11.8 im SWI-Manual.

  • rechnet sun-jdk falsch?

    • Plantschkuh!
    • 4. April 2006 um 19:12
    Zitat von Kampi

    was mache ich falsch?


    Du rufst dir nicht das minimale Grundwissen in Erinnerung, das du in Grundzüge der Informatik über Numerik erworben hast.
    Die Kurzfassung: Computer können nicht rechnen, und wenn es um Subtraktion geht, sind die Ergebnisse ganz besonders phantasievoll frei erfunden.

  • Umgang mit falschen Aufrufparametern bei Command-Line-Tools

    • Plantschkuh!
    • 29. März 2006 um 16:38

    Ich bin kein C++-Philosoph, aber soweit ich das verstanden habe, verwendet man Exceptions in C++ wirklich nur für Ausnahmen. Anders als in Java, wo man "normale" Fehlerbehandlung über Exceptions macht, werden sie in C++ also echt nur für Sachen benutzt, die normalerweise nicht auftreten und also nicht erwartet werden.
    Daß ein User falsche Parameter angibt, ist zu erwarten, also nimmt man da ein normales if, keine Exception. Macht den Code sowohl kürzer als auch leichter verständlich.

  1. Datenschutzerklärung
  2. Impressum
Community-Software: WoltLab Suite™
Website-Design: Fury - © NetzLiving GmbH