Laden...

Forenbeiträge von Seikilos Ingesamt 753 Beiträge

08.12.2007 - 11:58 Uhr

Ja, ich denke auch, dass dies eine gute Idee, ist, wäre mir ohne den Thread hier nicht eingefallen 🙂

Vielleicht hilft der Thread ja noch jemandem mal

08.12.2007 - 11:46 Uhr

Ich habe zwei Punkte, deren Koordinaten sind mir bekannt.
Was ich suche, ist die Distanz dieser beiden Punkte und zwar schnell.
Mir ist der Satz des Pythagoras natürlich bekannt, mein Problem ist, dass diese Operation ca 3.000.000 machen muss, und dies in 100 ms. Sicherlich klappt es nicht, aber ich brauche einen möglichst schnelleren Algorithmus, der Haken bei Euklidischen Entfernung ist ganz klar der Overhead von zwei Potenzen und eine Wurzelberechnung, wobei am Ende eh ein Int beim rumkommen muss.

Eine Alternative, die ich noch testen muss ist die "Manhattan Distance", mir geht es nicht um präzise Angaben (wie auch mit Int 😄), aber wenn ein Punkt die maximale Entfernung von 5 hat, sprich Punkt A (0,0) und Punkt B(5,5), soll die maximale Entfernung auch 5 betragen, bei der Manhattan Entfernung wäre sie jedoch 10.
Und nein, einfach halbieren klappt bei Manhattan nicht 🙂

Ich überlege auch, ob es Sinn macht, die Potenzen zu cachen, da ich ja zu beginn die maximale Entfernung weiß, kann ich diese einmal berechnen, evtl auch die Wurzeln

07.12.2007 - 17:45 Uhr

Die Lösung war doch nicht so gut, so ignoriere ich alle 10er die am Rand plaziert werden, verflucht

07.12.2007 - 17:21 Uhr

Ja klar, aber das Ding wird ja nun evtl bei mir mindestens 128 * 96 mal aufgerufen und da versucht man das Teil schon richtig optimal zu machen 🙂

07.12.2007 - 17:15 Uhr

Nun überlege ich gerade, wie ich am besten die maximal 8 Werte ändere.

Wenn ich eine Methode modifyNeighbors(int x, int y, int maxX, int maxY); habe, dann müssen ja Szenarien abgefangen werden, wo x und/oder y an den grenzen liegen und dann noch jeder Wert auf != 10 geprüft werden. Das wäre ja irgendwie ziemlich umständlich.
Man kann es natürlich in 2 for schleifen packen, ich mein auch nicht die Menge an code, sondern die performance der Border checks usw.

Eine andere Idee wäre es die Randbereich nicht zu iterieren, das wäre auch nicht schlecht

07.12.2007 - 13:25 Uhr

Man kann es leider nicht abfragen, nur wenn man jedes Feld einmal prüft, was ja die Iteration wäre 🙂

Danke euch beiden fürs Feedback 🙂

07.12.2007 - 13:23 Uhr

🙂 Ich meinte, ob man es optimieren könnte. Vor dem Thread hätt ich wohl zwei Iterationen gemacht, nun versuche ich doch nur eine 🙂

Hat also schon was gebracht

07.12.2007 - 13:21 Uhr

Stimmt eigentlich, zu doof, dass ich nicht vorhersagen kann, wie die 10er verteilt werden, die werden von einem Seed zufällig generiert, ohne Einfluss von mir

07.12.2007 - 13:19 Uhr

Ja, aber zufällig ist ja nur ein Beispiel, im Grunde iteriere ich jede Position und lese aus einer fremden Quelle Werte, die mir sagen, ob es eine 10 ist oder nicht 🙂 Kapselt man dass wissen aus, ist es für den Betrachter eine zufällige Plazierung 🙂

07.12.2007 - 13:11 Uhr

@herbivore: Ob mehrfache Iterationen der einzige Weg ist, oder ob es noch was schnelleres gibt ( im Hinblick auf Performance)

@melone: Darüber denke ich auch nach, aber es kann ja sein, dass eine angrenzende Stelle später auch eine 10 bekommt, aber die müsste man dann überschreiben, das könnte klappen. Wobei es ja so oder so sehr viele Iterationen sind. Der Haken an der Sache ist, wenn ich ein sehr großes Feld voller 10 habe, so wird für jeden seine Umgebung geprüft, obwohl die Umgebung so oder so eine 10 ist, da wären die Iterationen umsonst. Ich denke zwei Durchläufe der Karte wären wohl evtl besser,oder ich prüfe, wie oft dieses Szenario eintreffen kann und mache es doch in einer

07.12.2007 - 12:57 Uhr

Ich versuche ein Array zu bepflanzen.

Das ist dann quasi eine Karte, und die Werte kann man als Höhen sehen, dann kann man zum Beispiel die 10 als Spitze sehen und drum herum is der wert nur noch halb so groß, zwei Schritte weiter nur noch 1/4 usw.

07.12.2007 - 12:40 Uhr

Ich hab ein int[][] array, welches bei einer Iteration durch beide Dimemsionen zufällig die Zahl "10" mehrmals plaziert. Nun würd ich gerne effektiv ebenfalls noch die Streuung der 10 haben. Dh die 8 umgebenden Arraystellen sollen eine 5 haben. Dies ist nun ja bei einer zweiten Iteration nicht soo schwierig, aber kennt jemand einen geheimen, elitären, viel besseren Weg, der nur Abonenten von irgendeiner geheimen Zeitschrift bekannt ist 😁
Mir fällt nämlich keiner ein. Theoretisch gibts keinen Weg, weil ich ja bis dato noch nicht alle 10er gesetzt habe.

Interessant ist in dem Zusammenhang auch, wie ich bei einer zweiten Iteration n Felder der 10 belegen kann.
Ich müsste ja quasi jedes Feld auf die euklidische Distanz aller vorhandenen 10er checken. Das wäre bei nem 50 x 60 Feld mit 100 10ern ja mal n lustiger Aufwand...

26.11.2007 - 10:03 Uhr

Nun hab ich es, wusste nicht dass in Groups noch Captures sind, ich ging davon aus, dass Captures alle Gruppen sind, die kein ❔ vorangestellt bekommen haben und deswegen "gecaptured" werden 😁

Vielen Dank
und danke für den Link, hab den schon vor langer Zeit entdeckt 🙂

26.11.2007 - 09:50 Uhr

Ich hätte wohl das d.h. spezifizieren sollen 🙂
Ich weiß was lookaheads sind (hab nochmal gerade zur Sicherheit nachgelesen), ich verstehe nur nicht exakt, wie sie mir helfen können.
Und was meinst du mit "bis runter zu den Captures"? Lookaheads in den Captures?
Ich dachte mein Problem ist, dass für mein Pattern " and BB and CC" ein Match ist und dort nur die Gruppe CC gecaptured wird (was mich verwirrt, da nach meinem Verständnis BB auch in einer Gruppe sein müsste, weil \w+ ja in Klammern steht)

26.11.2007 - 09:07 Uhr

D.h.?
Ich hab auch überlegt, ob ich die Ergebnisse einzeln holen kann und mit m.nextResult() den nächsten Match hole, aber dafür hab ich kein richtiges Pattern finden können, da ja dieses Pattern hier schon die Zeile komplett matched.

Dann müsste das Pattern komplexer sein und quasi drei Fälle abfangen, oder? Also einmach Wort nach if, (Wort nach and und nicht then) und wort vor then

25.11.2007 - 15:56 Uhr

Ich hab den Code:

String s = "if AA and BB and CC then DD";
            Regex r = new Regex("if\\s+(\\w+)\\s+(:question:and\\s+(\\w+)\\s+)*?then\\s+\\w+");
            Match m = r.Match(s);

Mein Ziel ist es Gruppen für AA, BB und CC zu bekommen, also für if + Text + (and Text)* then Text.

Nun hab ich wohl ein Greedy problem, denn ich bekomme im Match bei den Gruppen nur AA und CC, alles dazwischen, also BB wird nicht gematched, obwohl ich mit *? das Muster doch ungreedy gemacht habe

23.11.2007 - 15:09 Uhr

Danke.
Ich teste es mal.
Ferne frag ich mich, ob man irgendwie lernen oder verstehen kann, wann new und wann ein Pool besser ist. Ich mein wenn etwas mit new mehr kostet als ein Pool, dann ist ein Pool besser, aber wann ist dies der Fall?
Kostet diese Pair Klasse mit new mehr, als das holen der Referenz aus einem Pool? Ich könnte nichtmal raten.

23.11.2007 - 14:53 Uhr

Also während des ganzen durchlaufs werden die 1.3 Mio objekte nur so lange am leben gehalten, bis die Rekursion endet.
Sind structs soviel schneller?

23.11.2007 - 14:13 Uhr

Naja, ich nutze eigentlich Pair<int,int> und da ist eigentlich nichts anderes mit drin, vielleicht 9 byte insgesammt? 4 pro int und 1 byte luxus?

Ich hab ein Programm, was n Sekunden rechnen soll und je weiter es kommt, desto besser für mich, in dieser Zeit werden 1.300.000 mal ein Pair Objekt mit new erzeugt und ich wollte gucken, ob ich mit nem Object Pool besser dran bin.

Da war ich mal neugierig, wieviel Speicher ich durch den Pool einkalkulieren muss.

Aber ich frag mich, ob bei solchen Objekten ein Pool überhaupt lohnenswert ist

23.11.2007 - 13:34 Uhr

Ich hab ein paar Probleme mit sizeof und zwar habe ich eine Klasse Pair<T1,T2> und brauche dessen Größe, diese ist jedoch generisch, ich krieg jedoch weder mit sizeof im unsafe noch mit der Marshall.SizeOf Methode irgendwas raus...

22.11.2007 - 08:14 Uhr

Ok, gut zu wissen.
Vielen Dank

21.11.2007 - 21:48 Uhr

Wenn ich mit BeginInvoke einen hintergrundthread starte, kann ich diesen irgendwie von außen abbrechen ohne in den Thread selbst zu müssen?

21.11.2007 - 17:42 Uhr

Ich meine das Dev Team von VS

21.11.2007 - 17:08 Uhr

Ist irgendwie seltsam, so etwas zu übersehen, hmmmmmm

21.11.2007 - 12:00 Uhr

Höchst merkwürdig.
Ich entwickel mit der C# Express Edition und hab ein #if TEST drin, mit #define TEST klappt es, aber wo muss denn dann das /define:TEST hin?
Unter Erstellen-> "Symbole für bedingte Kompilierung", dachte ich, aber es passiert nichts, mehr Felder hab ich auch nicht zum eingeben...

Edit: Schon gut, als ich es in VS 05 geöffnet habe, sagte es mir, dass /define:/define:TEST ungültig ist, dass hat mir die Express Version nicht erzählt... und konnt ja keiner ahnen, dass die Argumente alle per default /define: voranstehen haben.

Sollte wohl komplett weg von der Express...

21.11.2007 - 11:37 Uhr

Wo ist svens Beitrag hin?

Kann man #define irgendwie auf oberster Ebene einmal schreiben, so dass es überall gültig ist?
Wenn ich in n Klassen jedesmal #define an und #define auskommentieren muss, so führt das nur zu Fehlern, schöner wäre es, wenn es irgendwo eine oberste Ebene gebe oder so

20.11.2007 - 19:00 Uhr

#line hidden ist ja so was von das Gegenteil 🙂 Das Ding wird im Debugger nicht angezeigt, aber zur Laufzeit schon 😁
(Ich kann mir kein gescheites Szenario dafür denken)

Aber die verlinkte Referenz ist nützlich 🙂

Danke

20.11.2007 - 18:55 Uhr

Ah, geht doch 😁

Danke 🙂

Übrigens frag ich mich, ob ein if(flag) im Code wohl viel ausmacht.
An sich ja nicht, aber wenn man zum Beispiel eine komplette Diagnose Umgebung im Code mitschleppt, so dass Nicht-entwickler daran arbeiten, ohne diese jedes mal neu kompilieren zu müssen, so stell ich mir das schon auf die Dauer als Last für die Performance dar.

Sagen wir mal, man hat eine Rendermethode, die hat als Option 10 verschiedene Diagnose-Darstellungen, so kann man natürlich den flag als Int und Bitoperationen nutzen, die sind ja recht flink 🙂, aber dennoch hätte ich 10 verschiedene if(flag1){tuwas;}
if(flag2){tuwas anderes;}

Da frag ich mich, wie signifikant wären diese Checks wenn die flags alle false wären, man aber diese Rendermethode unheimlich oft aufrufen müsste.

Kann man pauschal nicht sagen, richtig?

(Das ist keine optimierungsfrage)

20.11.2007 - 18:43 Uhr

Ich glaub ich hab den Namen vergessen, oder ich hab nicht gewusst, wie es mit C# und VS 05 geht 😁
Gibts einen Weg in Methoden Zeilen von Code zu definieren und zu bestimmen, ob diese bei dem Build mitkompiliert werden oder nicht?

Das müsste eigentlich gehen, wäre ärgerlich wenn nicht.
Was ich meine (falls nicht klar) ist dass ich eine Zeile im Build nur dann mitkompiliere wenn ein Flag gesetzt ist.
Ich meine dabei nicht so was wie ein if(flag), weil dieses Zeug dann auch im finalen build drin wäre, was ich nicht will.
Erinnert stark an #ifdef konstrukte aus C++ 😁

Ein Begriff würd mir helfen 🙂

19.11.2007 - 17:33 Uhr

Achso, gut zu wissen, danke 🙂

19.11.2007 - 17:12 Uhr

Das mit GC wusste ich, hab ich bereits gelesen, aber ich wollte testen, ob es was bringt.
Und das mit der Thread Prio: Der rechenthread braucht für seine Arbeit maximale Leistung, egal wenn nichts anderes mehr geht, der Thread soll maximale Kapazität haben

19.11.2007 - 15:59 Uhr

Ich weiß was es bedeutet, aber ich dachte wenn man GC.Collect() exlizit aufruft, dass dieser dann doch arbeitet, aber ich habs auch auf anderen Prioritäten probiert, so is das nicht 🙂

19.11.2007 - 13:45 Uhr

Hallo Herbivore,
immer 🙂, sonst würden die Zeiten ja immer mindestens doppelt so lang sein, was sie ja nicht sind

19.11.2007 - 13:01 Uhr

Nun, ich hab es getestet, die Objekte existieren nicht mehr, nachdem ich explizit auf null verweise und GC.Collect(); rufe
Aber es wird dennoch immer langsamer.
Was mich total verwirrt, ich hab den Programm Echtzeitpriorität gegeben (merkt man...:D), Speicher konsant, VSpeicher konstant, kein Handle zuwachs, keine extra Threads, CPU 99%, alles konstant, das Programm wird jedoch immer langsamer.

Langsam glaub ich dass Stopwatch einfach nur Müll ist.

Edit: Argh: Code Analyse sagt mir, dass die innere Klasse im ersten Lauf 22968750 units braucht, im zweiten 46093750 und im dritten 70156250.

Zeiteinheiten sind doch absolut, oder? Das bedeutet es wächst linear, was ok ist wenn das Tool immer den Lauf davor addiert.

Ich glaub almählich dass Stopwatch einfach nur ungenau ist?

19.11.2007 - 12:53 Uhr

Mein Ausprobieren basiert ja auf der Zeitmessung, ohne diese kann ich nicht sagen,ob das Programm langsamer oder schneller läuft, da die Differenz bei 1/10 sec liegt, aber das schwankt, wenn ich das Ding 5 mal durchlaufen lasse, so hat sich das ganze um eine Sekunde verlangsamt und dies obwohl im ersten Durchlauf noch "Lazy-Alles mögliche" im Spiel ist...

Edit: Das mit den Referenzen test ich nochmal ohne Uhr

19.11.2007 - 12:47 Uhr

ja aber wie soll ich denn dann die Zeit messen? Hehe

Außerdem sagt mir ja der Profiler dass der Object Count der Klasse größer wird, wo die Stopwatch nicht drin ist

19.11.2007 - 12:40 Uhr

Das glaub ich und ich will auch keinen Code posten, damit jemand anderes Zeit darein investiert.

Ich hab geguckt, alle Objekte sind Objekt Generation 2. Hilft mir nur nichts 🙂

Die Klasse habe ich Zeile für Zeile gecheckt, es werden nur drei Typen benutzt, List<int>, List<Pair<int,int> und Pair<int,int>,
kein IO, keine anderen Klassen, nur ifs und fors.

Die Klasse Pair besteht nur

    public class Pair<T1,T2>
    {
        public Pair(){}
        
        public Pair(T1 first, T2 second)
        {
            this.first = first;
            this.second = second;
        }
        
        public T1 first;
        public T2 second;
    }

An der wird es nicht liegen...

Außerhalb der Klasse nutz ich noch die Stopwatch Klasse, aber die kanns ja auch nicht sein

19.11.2007 - 12:25 Uhr

Hi,
ne, die For-Schleife macht keine Probleme.
Das objekt, was mit new erzeugt wird, macht eine Baumsuche, also wirklich nur triviale Operationen wie zuweisungen und Bedingungen prüfen und dort sind wirklich keinerlei unmanaged code oder nicht freigegebene Ressourcen.

Ich hab mal den GC.Collect() getestet um zu sehen, ob es was bringt, aber nein, die Abarbeitungszeit nimmt immer mehr zu 😠

19.11.2007 - 11:24 Uhr

Mein Testprogramm initialisiert eine Klasse mit new, dies insgesammt drei mal. Dort werden triviale Operationen durchgeführt, aber davon eine ganze Menge 🙂
Was mir aufgefallen ist, dass mir der Profiler sagt, dass dieses Objekt nach dem dritten Lauf einen ObjectCount von 3 hat und die kollektive Größe 3 mal so groß ist (96?) und in der Tat ist beim Benchmark der drei Tests, die jedesmal 10 mal durchgeführt werden eine stetige Verlangsamung bemerkbar.

Nun lebt jedes Objekt mit den 10 Tests ca 12 Sekunden und ich wundere mich, ob der Garbage collector die Objekte, die mit dem neuen new befreit werden noch nicht löscht?
Ich meine reichen 12 sekunden um in ein höheres Level für den GC zu kommen um länger im Speicher zu verbleiben? Ich dachte nur Objekte des Level 3 bleiben bis zum Ende des Programms im Speicher, aber so schnell auf dem Level?

18.11.2007 - 18:55 Uhr

Ok 🙂
Ich dachte mir nur, vielleicht übersehe ich da was kluges 🙂

Edit: Er meinte, wir sollen ein paar Tiefen ausprobieren, was irgendwie keinen Sinn ergibt, vor allem, weil es nur auf der einen Machine mit einer bestimmten Auslastung klappt.
Naja... da wird die Geschwindigkeit der Suche mit der von iterativen Tiefensuche messen sollen, macht iterative Suche hier nicht sooooo viel Sinn...

Irgendwie sind hier alle Kurse so gut "durchdacht"

18.11.2007 - 18:25 Uhr

ACK,
aber ich hab hier eine Aufgabe dies bezüglich

How deep can your program search in the tree if max search time is 3 seconds
per move, using

  • depth-first search (with 4 different depth limits of your choice).

... das verwirrt mich schon seit einiger Zeit, weil ich da keinen Sinn drin sehe

18.11.2007 - 18:07 Uhr

Nein, will ich nicht, Breitensuche sucht Ebene für Ebene, eigentlich is das wurscht, da der Baum in n Sekunden ja bis Tiefe X gesucht werden soll und da ist Breite oder Tiefe ja wurscht...

18.11.2007 - 17:49 Uhr

Ehm naja, ich muss die Zeit begrenzen, also so was wie "Wie tief kommt die Suche in 10 Sekunden", aber wie misst man dies bei Depth First?

18.11.2007 - 17:09 Uhr

Vielleicht ist dies etwas schwieriger als die Tiefen Frage 😁

Aber wenn ich die Depth-first Suche auf eine bestimmte Zeit begrenzen will, wie stellt man dies am klügsten an?

Man würde den TiefenCheck durch einen Zeitcheck austauschen, wo man mit Stopwatch oder ähnlichem guckt ob die vorgegebene Zeit abgelaufen ist.

Nun ist die Suche ja Depth-first(Tiefensuche) und nicht Breadth-first(Breitensuche), dass bedeutet also dass die Zeit abgelaufen sein kann, ohne dass man man auch nur den ersten Zweig bis nach unten hin abgesucht hat.
Beschränkt man die maximale Suchtiefe und nutzt die Zeit, so besteht die Gefahr, dass man die Tiefe wieder zu groß wählt, oder zu klein, wobei die Suche vor der Zeit fertig ist, aber noch Zeit gehabt hätte.

Gibt es da eine Lösung?
Das Problem kann gelöst werden, in dem man die maximale Tiefe auf 1 setzt und iterativ vergrößert, das wäre aber bereits das Iterative-deepening ( iterative Tiefensuche), was hier nicht verwendet werden soll 🙂

Verflucht, wenn mal alles auf Englisch gelernt hat, ist das konfus.

18.11.2007 - 12:21 Uhr

Definier Ärger 🙂
Ich brauch ja Leistung en masse.
Und wenn der Subthread als BG und normaler Priorität läuft, so wird die GUI verarbeitet, wenn der Subthread als nicht BG und mit maximaler Priorität läuft, so ist die GUI nicht mehr klickbar, aber was solls, alle Macht dem Subthread 😁

17.11.2007 - 13:56 Uhr

So, habs begriffen.

Seltsam, dass ich noch solche Fehler mache, Rekursion ist eigentlich nicht neu für mich. Muss wohl diese nervende Umgebung sein.

Danke euch für eure Hilfe

17.11.2007 - 13:26 Uhr

Oh, entschuldigung, ging davon aus, dass ihr dies gemeint habt. (Erst lesen, dann...)
Mein Fehler, werd mich nach dem Essen der Sache annehmen

17.11.2007 - 13:17 Uhr

Ich weiß immer noch nicht, was ihr mir sagen wollt.
Ich hab mein Beispiel Code mal in C# umgesetzt:

Es kommt 11 bei raus... also genau das was ich nicht will

(Fertiges Programm)

class Program
    {
        static void Main(string[] args)
        {
            new Program();
        }

       
        int depth = 0;

        public Program(){

            Suche(1);
            Console.WriteLine(depth);
        }

        public void Suche(int s)
        {
            ++depth;
            int[] vals = gibNachfolger(s);

            foreach (int var in vals)
            {
                Suche(var);
            }
        }

        public int[] gibNachfolger(int s)
        {
            Dictionary<int, int[]> m = new Dictionary<int, int[]>();

            m.Add(1, new int[] { 2, 3 });
            m.Add(2, new int[] { 4, 5 });
            m.Add(3, new int[] { 6, 7 });

            m.Add(4, new int[] { 8});
            m.Add(5, new int[] { 9});
            m.Add(6, new int[] { 10});
            m.Add(7, new int[] { 11 });

            if (m.ContainsKey(s))
            {
                return m[s];
            }
            else
            {
                return new int[] { };
            }
            
        }
    }
17.11.2007 - 13:03 Uhr

Was willst du mir damit sagen? Dass die Variable immer wieder aufgerufen wird?

17.11.2007 - 10:27 Uhr

Ich erzeuge den thread dann ja nicht mehr, mein Vorgehen war ja

ThreadStart s = new ThreadStart(obj.methode);
            t = new Thread(s);
            t.Priority = ThreadPriority.Highest;
            t.Start();

Und nun ist es nur noch

ThreadStart s = new ThreadStart(obj.methode);
         s.BeginInvoke(...);

Ich dachte mir, da ich schon ThreadStart habe und das Ding BeginInvoke hat, könnt ich es ja nutzen