Moin,

ich muss für ein Projekt 9bit zu 8bit oder 17bit zu 16bit umrechnen , sodass ich jedoch wieder auf das fehlende bit zurückführen kann. Das "Muster" soll dann in einem bzw zwei Byte gespeicher werden. Dazu muss sich das Muster mind. 8 mal reproduzieren lassen , bevor die resultate nicht mehr darstellbar sind.

Versucht habe ich schon:

Ziffernweise darstellung (unnutz weil zu schnell zu groß)
Faktordarstellung (nicht genügend platz)
Bitmatrix (nicht genügend platz / zuviel zusätzlicher speicher)
Anderes Dratsellungssystem (keinen unterschied)

Bin dankbar für konstruktieve Vorschläge.

Schau mal bei OpenTK vorbei , die haben ein Tutorial , wie mann mit OpenGL in Silverligth rendert.

Die kann ich dir gleich beantworten: Nein.

Lies dir einfach noch einmal die verlinkten Beiträge durch. Du wirst gleich feststellen, dass es schon an der Definition von Bewusstsein scheitert.

Bewusstsein (lat. conscientia „Mitwissen“ und agr. ÃŽµ¯´·Ã¹Â syneidesis „Miterscheinung“, „Mitbild“, „Mitwissen“, ÃŽ±¯Ã¸·Ã¹Â Mitwahrnehmung und ÆÁ̽·Ã¹Â von ÆÁ¿½µÖ½ bei Sinnen sein, denken) ist der Besitz und die Empfindung mentaler Zustände wie Wahrnehmungen, Emotionen, Erinnerungen und anderer Vorstellungen, Gedanken aller Art und Formen wie Überlegungen, Beurteilungen, Einschätzungen und Bewertungen, Planungen oder Konzeptbildungen einschließlich der dazu nötigen Aufmerksamkeit oder Achtsamkeit.

Eine "Maschine" kann sowohl Wahrnehmen , Erinnern , Beurteilen , Einschätzen , Bewerten als auch Planen , sofern es die beschaffenheit zulässt. Also sind einige Kriterien grundsätzlich schonmal erfüllt! Was und vor allem wie man es macht hängt dann eben vom Einsatzgebiet ab.

Wikipedia

(Zur Erinnerung, bereits das Abbilden der Neuronen einer Ratte füllt einen ganzen Unikeller mit Rechnern)

Die Ratte hat auch noch Zahlreiche synaptische Systeme , wie etwa ein Unterbewusstsein , Sensorische und Motorische steuersysteme etc , die meine Einheit nicht benötigt und ich bin mir sehr wohl bewusst , was das für einen Rechnerrischen auffwand bedeutet!

Deine Antworten sagen nichts darüber aus , wie du an soetwas heran gehen würdest , ohne auf die bekannte methodik der Gewichtungsänderung zu setzen.

Ich erinnere nochmal , ich würde gern ein in sich wandelbares Netz abbilden , dass durch verknüpfen und trennen lernt.

<-------------------------------------------------->

Nochmal , es handelt sich um ein Experiment und deshalb ignoriere ich ab hier jeden , der schon von vornherein sagt: "Das klappt eh nicht".

Moin,

nahcdem ich vor ein Paar Tagen eine Sendung zum Thema Entwicklung des Menschlichen Organismus vom Kleinkind bis ins hohe Alter gesehen habe , habe ich Lust bekommen , ein kleines Experiment zu wagen.

Dabei geht es um ein künstliches Gehirn, genauer um eine Einheit von Neuronen , die ohne Testmuster einen kleinkindähnlichen Entwicklungszyklus durchlaufen.

Die Frage , die ich mir dabei Stelle , die auch ausführlich hier diskutiert wurde , kann sich die Einheit soweit entwickeln , dass sie eine Art "Bewustsein" entwickelt?

Es soll sich dabei nicht um die Gehirnleistung eines Menschen handeln , sondern ersteinmal um generelle Merkmale von Beuwstsein.

Ich definiere es ersteinmal als diese 3 Punkte:
*Ausbildung eines assoziativen Gedächtnisses (Deklarativ,Prozedural,Sensorisch) *Eine geeignete Interaktion mit der Umgebung und Reaktion auf Einflüsse *Bildung einer "Persönlichkeit" durch Entfaltung freier Gedankenbildung

Dammit meine ich folgende Realisierung:
*Konkrete erinnerung an Ereignisse und Tatsachen: Die Enheit erinnert sich an den verbleib eines gewissen Objektes auf einem Bild (Bsp.) *Interaktion ducrch Kommunikation: Die Einheit ist als gegenüber einer realen Person ind der Lage mit dieser Textuell zu kommunizieren *Persöhnlichkeit und Meinung: Die Einheit ist in der Lage kommunikativ sich selbst und eventuelle Gedanken zu vertreten. Dies könnte etwa mit dem Behalten eines Namens oder erinnerung an Gesagte sätze assoziiert werden

Dazu ist zuersteinmal das Speichern von Erinnerungen wie etwa Worte notwendig.
Im zweiten Schritt ist es erforderlich , dass gespeicherte Erinnerungen miteinander zu einer Art verständniss verknüpft werden (Assoziativgedächtnis). Der letzte Schritt ist dann die assoziation und der gebrauch von Gelerntem durch kommunikation und dem Versuch und Fehlschlag - Prinzip , die Richtigkeit dessen zu überprüfen.

Worauf ich gerne hinaus möchte ist , dass man sich über ein Chatfenster mit ABI (Artifacial Brain Instance) auf einem geringen Niveau unterhalten kann und sie , wenn sie die Bedeutung eines Wortes nicht versteht , danach fragt.

Meine Frage dazu währe ersteinmal, welchen Algorithmus zur Reizverarbeitung soll ich eurer Meinung nach verwenden , kann ich verwenden?

Ich möchte NICHT auf die üblichen Modelle der Gewichtungsmodifikation und starren IO-Netze zurückgreifen , sondern so nah wie möglich am Vorbild der Natur bleiben. Dazu möchte ich das Prinzip des Lernens durch Neuverknüpfen und löschen inaktiver Verknüpfungen zurückgreifen.

Das bedeutet , dass ich ein sich selbst wandelndes Netz ohne klassifizierte IO-Schichten habe!

Mein klassenmodell ist bereits folgendermaßen Aufgebaut:

    /*
     *       0,2 - 0,3
     *       /\
     *      /  \
     *     /    \
     *____/______\_______ Threshold -0.5
     *   /        \
     * _/__________\_____ Rest -0.9 - -0.7
     *              \  /
     *               \/
     *               -0.9
     * Der Ruhezustand eines neurons beträgt zwischen -0,9 und -0,7
     * Der Schwellenwert eines Neurons beträgt -0,5
     * Das Aktionspotential eines aktiven Neurons beträgt zwischen 0,2 und 0,3
     * Dannach fällt das Aktionspotential auf -0,9 ab und regeneriert sich langsam wieder
     * (Alle angaben siehe Wikipedia)
    */

1. Jedes Neuron kann mehrere Dendrite haben.
2. Jedes Neuron hat ein Axon
3. Jedes Neuron hat einen gewissen Zustand (siehe Codekommentar)
4. Jedes Axon kann mehrere Synapsen haben
5. Jede Synapse kann an genau ein Dendrit anknüpfen

Wäre um Vorschläge und Anregung sehr Dankbar.

Ich hätte übrigens gerne dass man das mit meinen Assemblies nicht macht 🙂
Klingt nicht sehr stabil, was du da vor hast. Was solls denn so etwa werden?

Ja doch , jenachdem was dein Script bei mir alles kaputt hauen soll 😜
Es soll eine Sandbox für unsere ScriptEngine werden. Wer den Beitrag CSIPL hier im Forum gelesen hat , weiß in etwa worums geht.
Ich erweitere die Bibliothek gerade um ein Paar dutzend Funktionen um das ganze für eine breitere Palette von Scripts und InstantProgramming-Sprachen zu erweitern und noch komfortabler zu machen.
Es sollen die Codeabschnitte vom laufenden Assembly analysiert und bei bedarf geblockt , bzw. Erlaubnis vom Anwender eingeholt werden.
Da es auch bereits konpilierte Scripts sein können , ist den Quellcode zu verändern KEINE Option!

<--------------------------------------------------------->

Habt ihr mal ein Beispiel oder Tutoriallinks?

Moin,

giebt es eine möglichkeit ähnlich wie Visual Studio ein ausgeführtes Assembly an einem bestimmten Punkt zu unterberchen , um den Benutzer etwa zu fragen , ob er die Opperation zulassen möchte und dannach wieder fortzusetzen?

MfG

Eine Publiceigenschaft mit dem Typ des Events in jeder Schicht einbauen , sodass das Eventobject bis ganz nach oben durchgereicht werden kann. (Ungetestet)

Oder einfach in jeder Schicht das Event implementieren

Alles klar , danke!

Was auch eine (nicht ganz unkomplizierte) möglichkeit wäre , wäre über IPC (Interprocess Communication) mit der jeweils anderen Komponente zu kommunizieren , oder du löst es gleich über ein loopback TCP-Socket

Es handelt sich um ein/mehrere .NET Assemblies.

Das extern für den Unmanaged Code war nur ein Prinzipbeispiel.

Moin,

ich benötige für eine Anwendung eine Sandboxkomponente , die nicht nur die Zugriffsrechte für den Code setzt , wie es in den vielen Googleergebnissen beschrieben wird , sondern ich möchte Systemzugriffe wie etwa eine Datei Lesen/Schrein , daten über das Netzwerk senden ... in dieser Sandbox abfangen und dann ersteinmal von meinem Programm analysieren lassen , bevor es diesen zugriff dann weiterleitet/selbst ausführt und das ergebniss an die Anwendung in der Sandbox weitergiebt.

Die Anwendungen sind .NET assemblies und werden von meienr Sandboxkomponente gehostet.

Die Anwendungen sind vom Code her aber leider Usercode , d.h. ich kann dem User nicht sagen , benutze bitte die Sandboxfunktion DateiLesen , statt der .NET Funktion.

Wie wäre euer ansatz so etwas zu realisieren?
Ist es Möglich die Codeaufrufe so umzuleiten und wenn nicht , was giebt es für alternativen?

[EDIT] Glaubt Ihr es ist möglich im Memory der CLR rumzukramen , und die Zieleigenschaft z.b. des Streams oder Sockets zu ändern?

Moin,

gibt es in C# eine Möglichekti ähnlich den extern deklerationen eine Referenz auf ein Assembly zu erstellen , dass aber zur laufzeit nicht existieren muss , solange man die referenz nicht aktiv benutzt?

Bsp.

Ich habe eine Klasse GLBitmap , diese Benutzt OpenGL als extern-verweis.
Nun kann es aber sein , dass ich die Klasse nicht benutze , folglich muss auch die OpenGL-Bibliothek nicht existieren und das Programm läuft trotzdem.
Anders als wenn ich die Klasse benutze , dann crasht es.

Kennt jemand eine Lösung ohne AppDomänen oder explizite Interfaces?

Kann es sein , dass eine Transformation mit glTranslate nicht funktioniert?
Wenn ich das Mesh an der Position 0,0,0 rendere , zeigt meine Textur die Frabe des Meshes an , sobald ich aber Transformiere , ist das Mesh nicht mehr zu sehen.

Bin jetzt auf den Texturrenderingteil umgestiegen und hab jetzt ein Problem , ich habe diesen Code (abgeändert) aus einem Tutorial übernommen.

Nun habe ich aber das Problem , dass meine Textur immer leer ist , also nichts zu sehen ist. Weiß jemand woran das liegen kann?

Wenn ich die Texturparameter nicht setze , sondern direkt von bind auf teximage springe , bekomme ich eine FramebufferUnsupported-Exception. kann das daran liegen?

public Texture CreateTexture()
        {
            LibCore.Enable(EnableCap.Texture2D);

            uint[] texture = new uint[1];

            LibCore.Enable(EnableCap.Texture2D);
            LibCore.GenTexturesa(1, texture);
            LibCore.BindTexture(TextureTarget.Texture2D, texture[0]);
            LibCore.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, size.Width, size.Height, 0, PixelFormat.Rgba, PixelType.UnsignedByte, IntPtr.Zero);
            LibCore.TexParameteri(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureFilter.Linear);
            LibCore.TexParameteri(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureFilter.Linear);

            ErrorCode code = LibCore.GetError();
            if (code != ErrorCode.NoError)
                throw new U3EException.ExtensionException(code.ToString());

            return new Texture(texture);
        }

public void Prepare()
        {
            if (!base.AvilableExtensions.Contains("EXT_framebuffer_object"))
                throw new U3EException.ExtensionException("Diese Extension wird nicht unterstütz");

            ExtensionProvider.GenRenderbuffersEXT(1, renderbuffer);
            ExtensionProvider.GenFramebuffersEXT(1, framebuffer);

            ExtensionProvider.BindFramebufferEXT(FramebufferTarget.FramebufferExt, framebuffer[0]);
            ExtensionProvider.BindRenderbufferEXT(RenderbufferTarget.RenderbufferExt, renderbuffer[0]);

            ExtensionProvider.RenderbufferStorageEXT(RenderbufferTarget.RenderbufferExt, (U3E.OpenGL.RenderbufferStorage)All.DepthComponent, size.Width, size.Height);
            ExtensionProvider.FramebufferRenderbufferEXT(FramebufferTarget.FramebufferExt, FramebufferAttachment.DepthAttachmentExt, RenderbufferTarget.RenderbufferExt, renderbuffer[0]);

            ExtensionProvider.framebufferTexture2DEXT(FramebufferTarget.FramebufferExt, FramebufferAttachment.ColorAttachment0, TextureTarget.Texture2D, texture.Side[0], 0);

            FramebufferErrorCode fbcode = ExtensionProvider.CheckFramebufferStatus(FramebufferTarget.FramebufferExt);
            if (fbcode != FramebufferErrorCode.FramebufferCompleteExt)
                throw new U3EException.ExtensionException(fbcode.ToString());
        }

        public void Generate(Camera view)
        {
            if (!base.AvilableExtensions.Contains("EXT_framebuffer_object"))
                throw new U3EException.ExtensionException("Diese Extension wird nicht unterstütz");

            ExtensionProvider.BindFramebufferEXT(FramebufferTarget.FramebufferExt,framebuffer[0]);

            LibCore.PushAttrib(AttribMask.ViewportBit); // stores GL.Viewport() parameters
            LibCore.Viewport(0, 0, size.Width, size.Height);

            LibCore.ClearColor(1.0f, 0.0f, 0.0f, 0.0f);
            LibCore.Clear(ClearBufferMask.DepthBufferBit | ClearBufferMask.ColorBufferBit);
            LibCore.LoadIdentity();

            ErrorCode code = LibCore.GetError();
            if (code != ErrorCode.NoError)
                throw new U3EException.ExtensionException(code.ToString());

            LibCore.Translatef(0.0f, 0.0f, 2.0f);

            LibCore.Color3f(1.0f, 1.0f, 1.0f);
            LibCore.Color3f(0.0f, 1.0f, 1.0f);

            LibCore.Begin(BeginMode.Quads);
            // Front Face
            LibCore.Vertex3f(-1.0f, -1.0f, 1.0f);	// Bottom Left Of The Texture and Quad
            LibCore.Vertex3f(1.0f, -1.0f, 1.0f);	// Bottom Right Of The Texture and Quad
            LibCore.Vertex3f(1.0f, 1.0f, 1.0f);	// Top Right Of The Texture and Quad
            LibCore.Vertex3f(-1.0f, 1.0f, 1.0f);	// Top Left Of The Texture and Quad
            // Back Face
            LibCore.Vertex3f(-1.0f, -1.0f, -1.0f);	// Bottom Right Of The Texture and Quad
            LibCore.Vertex3f(-1.0f, 1.0f, -1.0f);	// Top Right Of The Texture and Quad
            LibCore.Vertex3f(1.0f, 1.0f, -1.0f);	// Top Left Of The Texture and Quad
            LibCore.Vertex3f(1.0f, -1.0f, -1.0f);	// Bottom Left Of The Texture and Quad
            // Top Face
            LibCore.Vertex3f(-1.0f, 1.0f, -1.0f);	// Top Left Of The Texture and Quad
            LibCore.Vertex3f(-1.0f, 1.0f, 1.0f);	// Bottom Left Of The Texture and Quad
            LibCore.Vertex3f(1.0f, 1.0f, 1.0f);	// Bottom Right Of The Texture and Quad
            LibCore.Vertex3f(1.0f, 1.0f, -1.0f);	// Top Right Of The Texture and Quad
            // Bottom Face
            LibCore.Vertex3f(-1.0f, -1.0f, -1.0f);	// Top Right Of The Texture and Quad
            LibCore.Vertex3f(1.0f, -1.0f, -1.0f);	// Top Left Of The Texture and Quad
            LibCore.Vertex3f(1.0f, -1.0f, 1.0f);	// Bottom Left Of The Texture and Quad
            LibCore.Vertex3f(-1.0f, -1.0f, 1.0f);	// Bottom Right Of The Texture and Quad
            // Right face
            LibCore.Vertex3f(1.0f, -1.0f, -1.0f);	// Bottom Right Of The Texture and Quad
            LibCore.Vertex3f(1.0f, 1.0f, -1.0f);	// Top Right Of The Texture and Quad
            LibCore.Vertex3f(1.0f, 1.0f, 1.0f);	// Top Left Of The Texture and Quad
            LibCore.Vertex3f(1.0f, -1.0f, 1.0f);	// Bottom Left Of The Texture and Quad
            // Left Face
            LibCore.Vertex3f(-1.0f, -1.0f, -1.0f);	// Bottom Left Of The Texture and Quad
            LibCore.Vertex3f(-1.0f, -1.0f, 1.0f);	// Bottom Right Of The Texture and Quad
            LibCore.Vertex3f(-1.0f, 1.0f, 1.0f);	// Top Right Of The Texture and Quad
            LibCore.Vertex3f(-1.0f, 1.0f, -1.0f);	// Top Left Of The Texture and Quad
            LibCore.End();

            code = LibCore.GetError();
            if (code != ErrorCode.NoError)
                throw new U3EException.ExtensionException(code.ToString());

            LibCore.Flush();
            LibCore.SwapBuffers(Device.Devices[0]._hDC);

            LibCore.ClearColor(0.0f, 0.0f, 0.0f, 0.5f);

            LibCore.PopAttrib(); // restores GL.Viewport() parameters
            ExtensionProvider.BindFramebufferEXT(FramebufferTarget.FramebufferExt, 0); // return to visible framebuffer
        }

Das mit der Textur ist ja einfach (übrigens guter Tipp, danke 😄) , wann aber muss ich das beim StencilBuffer machen?

Wenn ich habe

public override void Prepare()
        {
            LibCore.ColorMask(false, false, false, false);

            LibCore.Enable(EnableCap.StencilTest);
            LibCore.StencilFunc(StencilFunction.Always, 1, 1);
            LibCore.StencilOp(StencilOp.Keep, StencilOp.Keep, StencilOp.Replace);

            LibCore.Disable(EnableCap.DepthTest);
        }

//Mesh rendern , dass reflektieren soll

        public override void CleanUp()
        {
            LibCore.Enable(EnableCap.DepthTest);
            LibCore.Disable(EnableCap.Blend);
            LibCore.ColorMask(true, true, true, true);
            LibCore.StencilFunc(StencilFunction.Equal, 1, 1);
            LibCore.StencilOp(StencilOp.Keep, StencilOp.Keep, StencilOp.Keep);

            LibCore.Enable(EnableCap.ClipPlane0);
            LibCore.ClipPlane(ClipPlaneName.ClipPlane0, new double[] { -exertionVector.X, -exertionVector.Y, -exertionVector.Z, 0.0 });					// Equation For Reflected Objects
            LibCore.PushMatrix();
            LibCore.Scalef(1.0f, -1.0f, 1.0f);

            //meshes rendern , die reflektiert werden sollen
            for (int i = 0; i < exertionObjects.Count; i++)
                if (exertionObjects[i] is Meshes.Mesh)
                    ((Meshes.Mesh)exertionObjects[i]).Render();
                else
                    if (exertionObjects[i] is Sprites.Sprite)
                        ((Sprites.Sprite)exertionObjects[i]).Render();

            LibCore.PopMatrix();
            LibCore.Disable(EnableCap.ClipPlane0);
            LibCore.Disable(EnableCap.StencilTest);
        }

Wenn ich das Mesh render , sind die Eigenschaften über Position und drehung bereits festgelegt.

Moin,

wie kann ich in OpenGL ein oder mehrere Portale erzeugen?
Ich habe bereits mit dem Stencilbuffer gearbeitet , um Reflektionen zu erzeugen , weiß aber nicht , wie ich das eventuell einsetzen kann , um den Kontext aus eienm anderen Blickwinkel zu rendern.

Ich würde gerne Portale wie in Portal erstellen.

Vielen Dank für Hilfe.

lediglich bestätigung erlangen 😁

Mal noch ne Frage , um ganz sicher zu gehen:

Shader berechnen nicht nur die Helligkeit eienr Textur wenn licht darauf fällt , sondern auch z.b. den Schatten , den eine Figur auf eine Ebene wirft oder sehe ich das falsch?

@JAck30lena

Es geht darum den Pfad für die Spielfigur zu verfeinern , dammit sie sich nicht so sprunghaft fortbewegt.

Das ist jetzt aber nicht Dein ernst oder Augenzwinkern

Mahtmeatik war noch nie meine Stärke

Moin,

wie kann ich zwischen 2 im Raum stehenden Punkten eine bestimmte anzahl an Wegpunkten errechnen?

Ich benötige das für die Bewegung einer Spielereinheit über ein Spielfeld.
Ich suche mir anhand eines Quadratmusters an Punkten und dem dazugehörigen Pathfinder-Algo den kürzesten weg , weiß aber nicht wie ich die Figur dann dorhin bewegen lassen kann , sodass es dynamisch aussieht.

Wegen der diagonalen habe ich schon an eine Bezierkurve gedacht , aber

1. funktioniert das auch bei geraden abschnitten?
2. wie könnte solch ein Bezieralgo aussehen?

MfG

Hallo Pria,

Edit: Verlustfrei würde ich das nicht nennen, s. Anhang.

m0rius

Ist unter anderem noch ein Problem mit den Zufallszahlen.
Klappt in unserem Beispiel aber zu 100% korrekt , weiß nicht was das bei dir ist 🤔

Moin,

ich stelle hier unser neuestes Prototype-Projekt vor. Es handelt sich dabei um ein Verfahren zur Datenkomprimierung in hohem maße.

Aus der Physik , insbesondere der Elektrotechnick ist bekannt , dass auf eine Welle , eine andere Welle aufaddiert werden kann, um deren Schwingung zu verändern.
Das selbe Prinzip haben wir für die Komprimierung von digitalen Daten verwendet.

Als Testobjekt diente ein Bilderordner von etwa 3,6 GB , den wir verlustfrei auf eine Gesammtgröße von etwa 3 kb zusammenkomprimiert haben.

Dann stellten wir uns die Frage , wie nun die Daten wieder dekomprimieren , da es sich ja nicht um eine wirkliche Wellenkurve handelte , kahm also auch nicht die übliche Zerlegung in Frage.

Durch Zufall sind wir auf den Asynchrone Quersummen Umverteilungs Algorithmus gekommen , der es ermöglicht anhand der asynchronen Quersumme und der tatsächlichen Quersumme die beiden jeweils aufaddierten Ströme zu rekonstroieren.

Wir haben zur Zeit noch mit ein paar kleinen Fehlern beim übertragen der handschriftlich erfassten Prozedur in eine digitale .NET-Anwendung , da unter anderem die Zufallszahlen des Framework ärgste Probleme bereiten.

Auch , da das ganze Verlustfrei von statten gehen muss , ist der Zeitaufwand zum Dekomprimieren mommentan noch 20x höher als die Komprimierung.

Wir sind uns aber sicher , dass es in den nächsten Tagen schnell vorran gehen wird.

Im anhang findet Ihr schonmal ein kleiens Beispielprogramm , welches eine Testdatenreihe Komprimiert und dannach die ersten beiden Zahlen der Ursprungsdatenreihen wiedererstellt.

Mann kann also sagen , dass wir bewiesen haben , dass es möglicht ist , aus einer Addition , die beiden Summanden wiederzuerstellen.

Abgesehen davon, daß es wirklich schwierig ist, deinen Ausführungen zu folgen, lese ich nur Konjunktiv. Normalerweise geht man bei der Suche nach einem geeigneten Algorithmus so vor, daß man ersteinmal schaut, was es bereits gibt und an was zur Zeit geforscht wird. Was deine ursprüngliche Frage betrifft, hast du mehrfach eine eindeutige Antwort erhalten.

Einerseits finde ich es nicht gut zu "Kopieren" , wenn etwas existiert , dann gibt es genug leute , die daran arbeiten , zum anderen habe ich mit den gegebenen Lösungsansätzen nicht wirklich das erreichen können , was ich mir vorgestellt hatte.

Wenn du der Meinung bist, mit "antisymmetrischen Quersummen" die Lösung gefunden zu haben, wären wir alle sicherlich sehr interessiert daran. Aber 40% Erfolgsquote bei einem nicht nachvollziehbaren, "verlorengegangenen" Ansatz ist nichtmal fiftyfifty 🙂

Aus 50-50 lässt sich sicher mit etwas herumprobieren und nachdenken noch 99,99 machen 😁

Ich hab jetzt aber auch keine Lust mehr darüber nachzudenken , 2 Wochen wohlverdienter Urlaub stehen an.

Nemen wir mal an es funktioniert was ich versuche, nehmen wir mal an , dieses Prinzip ließe sich auf Dateien anwenden, nehmen wir mal an wir haben einen Ordner mit 1000 Bildern zu je 1KB.

Inklusieve der Headerdaten würde sich das dann etwa auf 3KB für den gesammten gepackten Ordner belaufen. Macht eine ersprarniss von etwa 90%.

Die Datenmenge wird durch das aufaddieren nicht erhöht , sondern die Speicherbelegung believe sich dann auf die Größe der größten Datei + Headerdaten.

Kann sein , dass ich da noch jede Menge Hinrschmalz reinstecken muss , aber ich glaube , dass es möglich wäre.

Ja , der Zeitaufwand spielt auch eine Rolle.

Die Signale sind eben wie vorweg schon beschrieben Positiv,eine Ansammlung von Messwerten. Frequenz ist unbekannt , Wellenlänge ist unbekannt.
Die Messwerte sind immer alle gleich lang (von der anzahl) und werden falls notwendig mit 0en auf die richtige Länge gestreckt.

Es muss aber unbedingt verlustfrei bleiben.

Ich habe mal diesen Algorithmus zum Packen fabriziert.
Er erzeugt auch gleich die Quersumme , sowie die antisymetrische Quersumme (messreihe 1 jeden 2ten wert,messreihe 2 jeden ersten wert), sowie die Quersummendifferenz der beiden Messreihen.
Ausserdem erzeugt er ebenfalls diese Werte von der Differenz von Xerg zu Xmess1 - Xmess2 als 6ten - 9ten Kontrollwert.

div = values1[0] * 2;
            foreach (int i in values1)
            {
                div -= i;
                qs += i;
            }
            int zähler = 0;
            while (div < qs)
            {
                div++;
                zähler++;
            }
            div = zähler;

            for (int i = 0; i < values1.Length; i += 2)
                qs2 += values1[i];

            div_1 = values2[0] * 2;
            foreach (int i in values2)
            {
                div_1 -= i;
                qs_1 += i;
            }
            zähler = 0;
            while (div_1 < qs_1)
            {
                div_1++;
                zähler++;
            }
            div_1 = zähler;

            for (int i = 1; i < values2.Length; i +=2)
                qs2_1 += values2[i];


            values3 = new int[values1.Length];
            for (int i = 0; i < values1.Length; i ++)
                values3[i] = values1[i] + values2[i];

            int[] tmpVals = new int[values1.Length];
            for (int i = 0; i < values1.Length; i++)
            {
                tmpVals[i] = values1[i] - values2[i];
                zähler = 0;
                while (tmpVals[i] < values3[i])
                {
                    tmpVals[i]++;
                    zähler++;
                }
                tmpVals[i] = zähler;
            }

            div_2 = tmpVals[0] * 2;
            foreach (int i in tmpVals)
            {
                div_2 -= i;
                qs_2 += i;
            }
            zähler = 0;
            while (div_2 < qs_2)
            {
                div_2++;
                zähler++;
            }
            div_2 = zähler;

            for (int i = 0; i < tmpVals.Length; i += 2)
                qs2_2 += tmpVals[i];

Ich habe auch schon and er Dekodierung etwas rumgebastelt , habe aber leider das Ergebnis verloren , dass mir immerhin schoneinmal 40% der Messreihen richtig entschlüsselt hatte. (Sprich die Werte glichen den Originalwerten)

Ich hab allerdings grad n echtes Brett vorm Kopf , da ich nicht in der lage bin , die Zahlen der Quersumme richtig hin und her zuschieben , dass dort ein vernünftiges ergebniss rauskommt.
Die 40% waren wohl bloß glück

Ich will die Signal zu einem Klumpen zusammenmanschen , dammit ich sie in einem Rutsch über das Netzwerk übertragen kann.

Mal ne andere Frage , glaubt ihr es reichen 10 eindeutige Werte wie etwa die Quersummen der beiden ausgangssignale und der des resultatsignals und noch ein paar andere Werte , um einen Rekonstrucktionsalgorithmus zu realisieren?

Nehmen wir an ich hätte 2 Signale der Länge X wobei X = X1 = X2 und ein aufaddiertes Resultat Xa = X. Ich berechne daraus die Quersumme , die Quersubtraktion und den Differenzwert , sowie die Quersumme von allen 2^N Werten.

Dann habe ich die Werte jeweils für die beiden Ursprungssignale und das Resultat.
Dann wäre ich doch in der Lage mit "Rumprobieren" die beiden Signale aus dem Resultat und den Sicherungswerten wieder zu rekonstruieren oder?

Jede kurve kann ich durch eine beliebige Überlagerung beliebig vieler "Ausgangs-Signale" darstellen.
Solange du nicht die Art der Ausgangs-Signale einschränkst, gibts keinen Weg.
(Einschränkung auf Sin/Cos liefert DFT, ...)
Und wenn, dann evtl. keinen eindeutigen.

Aber du musst etwas über die Beschaffenheit deiner Ausgangssignale aussagen. Nur deren Beschaffenheit / Zusammenhänge kann man eventuell ausnutzen um sie zu rekonstruieren.

In diesem Dokument , dass ich gefunden habe , ist die DFT beschrieben.

Darunter ist ebenfalls ein Signal (erste abbildung) , dass meinen durcheinandergewürfelten Werten entspricht.

Da Problem daran ist , dass ich nur solche Signale habe.
Mir ist immernochnicht ganz klar , wieich diese zusammenlegen soll , um sie im nachhinein wieder zu trennen.

Was auch möglich wäre, wäre die Werte als Rechteckssignale darzustellen, wenn das hilft.

Edit: Die Signale haben alle die gleiche Abtastfrequenz und die Abtastwerte werden (mit nullen) alle auf die gleiche Länge gestreckt, was ich auch nicht ändern kann.

Wenn ich hätte meine hausaufgaben von euch gelöst haben wollen , würde ich einfach ein opensourceprojekt nehmen und es als meins in ein neues projekt einbauen und als eigene arbeit ausgeben.

Das signal varriert , ist immer positiv (ohne negative amplitude) und in der Wertefolge äusserst inkonsistent.

Dazu warriert die dauer es Signals (das messfenster) und die länge der zu addierenden Signale ist ebenfalls untrschiedlich.

Darüberhinaus gibt es keine spezifische Frequenz (da dies für meine Zwecke unwichtig ist)

Ich habe zudem nichts davon gesagt , dass ich die fourieranalyse verwende. Ich habe leidiglich nach einer verarbeitungsmethode gerfagt.

ich habe einen satz von (positiven) werten, diese werte können z.b. die amplitudenwerte eines abgetasteten signals darstellen.

diese werte sind dann etwa 1,2,3...
(die negativen werte kann ich ja hinzudichten)

wie muss ich diese werte auf ein oder mehrere signale aufaddieren , um später wieder genau diese werte zu erhalten (und die der anderen signale)?

Die Frage war doch lediglich , wenn ich ein Signal mit den Werten bsp. 1,2,3,4,5,6,7,8 habe , das aus 2 schwingungen besteht , wie kann ich die beiden grundsignale wieder herausfinden?

Hat einer zu dem FFT bzw DFT ein Beispiel für mich?

Was möchtest du enn machen (nur mal so aus Interesse) ?

Einen 4Dimensionalen hochleistungs Kompressionsalgorithmus für Datenmengen ab 1GB

Funktioniert das nur bei linearen Kurven oder geht das auch mit Kurven , deren Amplituden stätig wechseln?

Wie etwa ein Audio-Signal

Moin,

es ist ja bekannt , dass man Signale addieren kann und daraus ein neues Signal erhält.
Ist es möglich (wie auch immer) ein Signal , etwa eine Sinuskurve in ihre ursprünglichen Signale zu zerlegen?

Ich wäre um eine Antwort und eventuell ein Beeispiel sehr dankbar.

Mit dem Schalenmodell kann man nur sehr begrenzt die physikalische und chemischen Eigenschaften der verschiedenen Elemente und daraus entstehender Verbindungen erklären. Warum Quecksilber flüssig ist und Gold goldfarbend und nicht silberfarbend ist kann man damit nicht erklären.

Ich sagte ja auch "das Resultat einer Reaktion".
Natürlich gibts es noch hunderte Faktoren , allerdings ist das Schalenmodell für die Bindung , die Reaktionsfreudigkeit , Die Wechselwirkung ... verantwortlich

Moin,

ist im grunde genommen eigentlich auch ganz einfach , da die eigenschaft der Elemente aus der Wechselwirkung (Bindungsenergie, Bewegungsenergie ...) der einzelnen unterlemente (Protonen,Elektronen etc.) ausgeht.

Das Resultat einer Reaktion hängt dann z.b. unter anderem von den elektronen auf den schalen ab.

Wir beschäftigen uns gerade unter anderem auch mit einer ChemieEngine

Wenn er z.b. mit der Energie , die der Geist bei einem Puls "verliet" , etwas anfangen möchte , kann e eine Klasse davon ableiten.

Für unsere Zwecke ist es zu 80% unrelevant

Jo , mag sein , dass noch n paar fehler drinn sind , muss ich noch n bissel dran arbeiten.

Ausserdem wird die energie nie in nicts umgewandelt , sondern lediglich in eine für uns nicht mehr relevante form!

Der Physiker den ich kenne , hat es als ultrahocherhitzes Gas bezeichnet, kann man sich drüber streiten.

Hattest du denn ein konkretes Spiel im Hinterkopf?

KA , irgendwas , was man halt machen kann.

Sonst is die Idee nich schlecht obwohl ich nich wüsste was ich damit anfangen sollte.

Wir wollen es für unsere Spiele verwenden , da die integration und verwendung doch relativ einfach und mit wenig aufwand und zeit zu realisieren ist.

Moin,

hier ein Projekt , über dessen nutzen schon vorab hier diskutiert wurde.

Ich habs allen vorwürfen , dass es ja unrealistisch sei , trotzdem mal gemacht 😭

Es handelt sich dabei im groben um eine Sammlung von physikalischen Regeln zum Thema Energie.

Energie ist nahtlos übertragbar, d.h. aus Elektrischer kann die selbe Menge thermische Energie gewonnen werden.
Das Problem an unserer Welt ist nur , dass bei verrichteter Arbeit fast immer auch eine andere Umwandlung geschieht , sei es die Wärme bei der Glühbirne etc.

Ich gehe allerdings davon aus , dass die Umwandlung zu 100% effektiv ist, was nicht gegen irgendwelche physikalischen Regeln verstößt.

Gehen wir davon aus , dass ein höheres Wesen wie z.b. ein Geist , nichts anderes als eine Sammlung von Energie ist, dann lassen sich die (unbestätigten) beobachtungen von heimgesuchten Personen und Geisterjägern ganz einfach erklären.
1.Der Geist ist ein messbares Ereignis 1.Der Geist entzieht der umwelt Energie (Wärme,Elektrizität ...) um sein Energiefeld aufrechtzuerhalten 1.Der Geist stört aufgrund 2. elektrische Geräte 1.Wir fühlen uns von einem Geist bedrückt , weil auch wir ein Energiesystem darstellen

Gehen wir ebenfalls davon aus , das Zauberei nichts anderes ist , als eine Übertragung und Umwandlung von Energie aus dem eigenen System in selbiges und/oder ein anderes System ist, dann können wir auch die Zuaberei mit Energiephänomenen erklären.

Telekinese wäre dann die Übertragung von Energie auf ein Objekt und die umwandlung in Lage bzw. Bewegungsenergie.

Ein Feuerball ist demnach dann nichts anderes als Thermalenergie , die Luft zu Plasma erhitzt.

Aufgrund dieser Überlegungen habe ich zu der Engine auch einmal 2 Beispielprogramme entwickelt.

Das eine simuliert einen idealen Geist , der genausoviel oder mehr Energie aufnimmt , als er selbst abgiebt.

Das zweite simuliert einen kleinen Berührungszauber , der Papierschnipsel verglühen lässt.

Das ganze ist im endeffekt dazu da , um der Magie in Spielen ein paar Gesetzmäßigkeiten zu geben.

Nicht solange mit der Programmierung gegen chemische oder physikalische Prinzipien verstoßen werden kann oder man Schleifen programmieren kann, die eine (chemische) Aktion, die eigentlich nur einmal pro Zeiteinheit ablaufen kann, quasi beliebig oft durchführen kann.

Nochmal zu den physikalischen Gesetzen:
Physikalische Gesetze werden von Menschen gemacht und sind prinzipiell deshalb erstmal fehlerhaft, da wir nicht mal annähern das wissen haben , um alles zu verstehen.

Eine chemische Reaktion kann beliebig oft von statten gehen , solange genug Reaktionsmaterial vorhanden ist.

Deine Muskeln mein lieber herbivore , jeder deiner Herzschläge , ist eine Chemische Reaktion. Und du kannst ja nicht nur 5 mal den kleinen Finger krumm machen und dannach ist ende.

Und das mit der Energie hängt wie gesagt von der Menge der ausgangsmaterialien ab und von der Effizienz der umsetzung.

Diese Mengen kannst du feststellen , bzw festlegen.

Alles andere hängt vom realismus des jenigen ab. Du kannst niemanden hindern zu behaupten , dass 4 + 5 = 8 ist, du knnst ihn lediglich darauf hinweisen , dass es falsch ist.

Davon abgesehen sind deine Beschreibungen zur Funktionsweise so vage, dass man keine rechte Vorstellung bekommt, was genau man tun muss, um so eine Zelle zu programmieren. Was sind die Eingaben? Wie kann das Programm auf die Eingabewerte zugreifen? Was sind die Ausgabewerte. Wie kann das Programm die Werte ausgeben? Was bewirkt die Ausgabe? Wodurch bestimmt sich die Fittness der Zelle? Bzw. wie kann man ermitteln, ob ein bestimmtes Verhalten die Fittness erhöht oder vermindert hat?

Kommt im Tutorial

dann definier doch mal realismus. deine aussagen beißen sich....
wer definiert denn nun wieviel energie aus einem stoffwechsel gewonnen werden darf .. wo ist das maximum? welche gesetze soll man da bevolgen wenn keine existieren?

Ganz einfach , die energie , die eine Zelle tatsächlich aufnehmen kann , wird von Mitochondrien , genauergesagt , von deren Fähigkeit zu chemischen Reaktion bestimmt (Ich hab unseren MTLA gefragt 😁 )

Im klartext , je mehr Energie aus der Chemischen Reaktion der Ausgangsstoffe hervorgeht , desto mehr kann die Zelle mit einem Zyklus aufnehmen!

Wie bildet man mit OP-Codes den Aufbau der DNA nach?
Wie beeinflußt der Aufbau der DNA den Aufbau der Zelle?

DNA bildet aus 3 Baasenpaaren Aminosäuren , die wiederum die bildung von Proteinen beeinflussen, die wiederum den aufbau und das verhaltend er Zelle steuern , also ist das Grundprinzip des unseres OPCodes durchaus vertretbar.

Wie beeinflußt der Aufbau der Zelle die Überlebenschancen der "Lebensform"?

Indem die anpassung der Zelle an den entsprechenden Lebensraum , bzw die vorbereitung auf eventuelle schwankungen des Lebensraums , etwa Jahreszeitenwechsel oder eine beschädigung der Zelle durch äussere einflüsse so gut ist , dass die Zelle sich entsprechend verhalten kann.

Wenn keienr was dagegen hat erkläre ich die Diskusion bis hierhin als vorläufig abgeharkt

so funktioniert es aber nicht in der biologie.

In der Biologie wird der Stoff von der Zelle aufgenommen und verwertetd , weil die DNA es so vorschreibt!

Bestes beispiel , Bakterien die Zucker aufnehmen.

ganz einfach: die körpergröße hat mehr faktoren als nur die sichtbaren eigenschaften der mutter und des vaters. gerade bei der körpergröße spielen umweltfaktoren im laufe des lebens eine enorme rolle.

Mag sein , jedoch ist spontane Mutation bei allen Lebewesen vorhanden.
Jedoch werden die nichtüberlebensfähigen varianten ausselektiert.

der vergleich hinkt meiner ansicht nach. eine zelle hat nicht die möglichkeit (auch nciht durch mutation) die physikalischen gesetze zu brechen und das sollte deine zelle auch nicht können.

das hat nichts mit physikalischen Gesetzen zu tun sondern lediglich mit der effizienz der verarbeitung des verdauungssystems.

Einfach energie dazuerfinden fällt dann unter den Punkt Realismus.

Zudem hält sich die Natur in den seltensten fällen an ihre eigene Gesetzte , da diese von Menschen entwicklet wurden.
Es kommt nur zu oft vor , das wissenschaftler eienes besseren belehrt werden , weil neue erkenntnisse errungen wurden.

Mann kann auch sagen , mache aus 1,60m 1,90m , das hast du ja auch schon angemerkt.
Sowas nennt man spontane mutation , wie erklärst du dir sonst bei einem Vater von 1,89m und eienr Mutter von 1,71m einen Sohn von ganzen 2,20m?
(Der größte Mensch der Welt ist glaub ich 2,30m)

Bei der energie könnte sich z.b. der Wirkungsgrad der Verarbeitung des Ausgangsmaterials ändern.

Tatsache ist jedoch und das habe ich gaaaaanz oben auch schon gesagt , dass man eben realistisch bleiben muss.

Nur weil du mit C# dein Betriebssystem schrotten könntest , würdest du es doch nicht tun oder?

Die Zelle kommuniziert über chemische Stoffsignaturen mit der Aussenwelt. Dammit hat das Programm oder gar die Register nichts zu tun , als lediglich zu sagen "Liebe Zelle , schick doch mal den Botenstoff XY an die Umgebung".

Daran arbeite ich noch und wenn du dir die Bibliothek bei dem Minieditor mal angeschaut hast , wirst du feststellen , dass sich zu der Klasse Cell eine weitere Klasse GeneticCell gesellt hat.

In ihr kannst du per jump auf basisfunktionen wie eben diese Botenstoffe zugreifen.

In der Natur wird der Botenstoff ja auch nicht von der DNA , sondern der Zelle erzeugt , bzw Wahrgenommen. Die DNA regelt lediglich , wie die Zelle darauf reagiert.

Der unterschied zwischen Programm a und b ist beispielsweise , dass eine Programm reagiert auf das sonnenlicht und erhöht die energie der zelle um 1 , weil eine art photosynthese getätigt wurde , und das andere programm sagt der zelle z.b. sie soll doch bitte mal gucken , ob in der umgebung der stoff xy vorhanden ist und wenn das der fall ist , soll sie ihn bitte in der menge z aufnehmen.

Und um schonmal dem vorzubeugen , das ist realistisch , da die dna die Proteine bildet , durch die die Zelle überhaupt erst in der Lage ist Photosynthese zu betreiben.

Die zelle ist halt nunmal wie ein kleienr Prozessor aufgebaut , es gibt einlagerung von stoffen , das entspricht den registern , dann gibt es die dna , das ist der befehlssatz und die zelle kann auf bestimmte gegebenheiten , z.b. lichtarmut reagieren , das entspricht den interrupts.

Natürlich hat eine Zelle keinen Stack , und bestimmt auch keine Register , wie wir sie kennen , diese dienen nur dazu das ganze etwas einfacher zu gestalten.

Man könnte das entfernt mit chemischen einlagerungen vergleichen.

Ich hab nicht gesagt , dass jetzt sofort alle darauf umsteigen sollen

Wir werden es warscheinlich für unsere Projekte benutzen

Was mich nicht davon abhält weiter über das ganze nachzudenken, bzw zu programmieren.

Ihr braucht es ja nicht zu benutzen 😛

Für die , dies interessiert

Jemand der an sowas glaubt, glaubt nicht an die eigene Welt in der sie leben

Das haben die Menschen , insbesondere die Kirche vor nicht alt zu langer Zeit auch behauptet , als jemand gesagt hat , dass er nicht denkt , dass die Welt eine scheibe ist.

Luft (in der Zusammensetzung wie sie in der unteren Atmosphäre vorkommt) zu entzünden, ist unmöglich da kein Brennstoff vorhanden ist. Man kann Luft ionisieren und sicherlich zum leuchten bringen, aber unter keinen Umständen entzünden.

Kommt drauf an was sich in der Luft befindet.

Ausserdem kann man Gas soweit erhitzen , dass es zu sichtbarem Plasma wird, das ist zwar kein Feuer , aber verhält sich ähnlich , wenn nicht sogar gleich.

Dennoch wird es heutzutage , nicht zuletzt dank den Spielemachern , mit Zaubersprüchen u.ä. assoziiert.

Ich denke aber ,d as das Modell der Energie(umverteilung) ein guter Ánsatz ist , um ein Paar Regeln aufzustellen.