Forenbeiträge von NeuroCoder Ingesamt 335 Beiträge
Hallo,
ich betreibe bei http://www.netcup.de einen V-Server. Guter Support und gute Preise. Definitiv weiterzuempfehlen.
Webhosting Pakete gibts dort auch (geeignet z.B. für eine Wordpress Installation).
Viele Grüße,
NeuroCoder
Hallo zusammen,
ein statistischer Test scheint mir hier die passende Methode zu sein.
Wenn ich das Problem richtig verstanden habe, geht es um Folgendes Problem:
Jede Person kann sich zwischen A und B entscheiden. Dies definiert eine Zufallsvariable X:
X: Omega -> {A,B}
Angenommen, die Mehrheit stimmt für A. Dann ist X Bernoulli-verteilt mit
P( X = A ) = p > 1 / 2 und P(X = B ) = 1 - p.
Jetzt werden n Realisierungen von X beobachtet (also n Personen befragt). Es ergibt sich die (Null-)Hypothese, ob p ≤ 1 / 2. Die Gegenhypothese, welche statistisch gesichert wird (Signifikanzniveau alpha), lautet demnach p > 1 / 2.
Lehnt der Test ab, so ist die Wahrscheinlichkeit sich falsch zu entscheiden (also fälschlicherweise für die Gegenhypothese der absoluten Mehrheit zu entscheiden) höchstens alpha. Der Test lehnt dabei die Nullhypothese ab, wenn der p-Wert unter das Signifikanzniveau alpha fällt.
Der passende Test für dieses Modell wäre ein Binomialtest.
Der p-Wert ist aber NICHT die Wahrscheinlichkeit dafür, dass die Null-Hypothese wahr ist. Ebenso lassen sich generell keine Wahrscheinlichkeiten an Hypothesen heften, sondern nur an die (Fehl-)Entscheidung für eine Hypothese.
Ich glaube daher, dass sich herbivores Frage höchstens näherungsweise beantworten lässt, wenn man z.B. den p-Wert trotzdem auf diese Weise interpretiert - auch wenn es falsch ist.
Viele Grüße,
NeuroCoder
Hallo ck123,
wenn du deinen Polygonzug vereinfachen willst, klingt das nach Douglas-Peucker:
Douglas-Peucker-Algorithmus
Polyline Simplification
Andererseits schlägst du mit deinem Histogramm-Ansatz einen Dichteschätzer vor.
Wenn du deine Messwerte auch noch glätten willst (Messrauschen verringern) könntest du Kerndichteschätzer, Glättungssplines, Moving Least Squares, Wavelets etc. einsetzen.
Viele Grüße,
NeuroCoder
Hallo ReneS,
auf dem Matlab File Exchange habe ich diese Submission gefunden:
CSMatIO: MAT-file I/O API for .NET 2.0
Alternativ kannst du auch mit der Spezifikation des Dateiformats deine eigenen Klassen schreiben:
MAT File Format (PDF)
Die Spezifikation reicht aber nur bis Version 5, soweit ich gesehen habe (es müsste bereits Version 7 geben).
Mfg NeuroCoder
Hallo Oliver!
A) Ich kenne deinen Hintergrund nicht. Abhängig davon könntest du z.B. in
Engel: Anwendungsorientierte Mathematik: Von Daten zur Funktion
oder
Fahrmeir, Kneib, Lang: Regression
schauen.
Das Erste ist ein Buch für Mathematik Lehramt und das Zweite ein "normales" Fachbuch. Falls du Zugriff auf SpringerLink hast, findest du beide Bücher dort.
Die meisten Statistik-Bücher behandeln aber auch gewöhnliche Regression.
B) In den Büchern steht beschrieben, was es auszurechnen gilt:
Im einfachsten Fall sowas wie (XT * X)(-1) * X^T * Y, wobei X die Design-Matrix und Y der Datenvektor ist.
Das musst du dann nur in deinem Programm umsetzen. Mit entsprechenden Mathe-Libraries ist das (fast) nur Formel abtippen. Oder du suchst dir direkt eine Library, die die Regression für dich übernimmt.
Für geeignete Libraries: Im Forum und mit Suchmaschine suchen.
Viele Grüße,
NeuroCoder
Hallo Oliver,
was für ein Ansatz geeignet sein könnte, kannst du z.B. in Plots des Fehlers e erahnen.
Zunächst würde ich (falls möglich) eine gleichverteilte Punktmenge einmessen und so die g-Werte besorgen (z.B. Punkte auf einem Gitter). Es empfiehlt sich oft dort noch genauer aufzulösen, wo "viel passiert".
Wenn du dann einen Ansatz ausgewählt hast (z.B. ein polynomieller bis zu einem gewissen Grad) kannst du die Regression mit den e-Werten an den gemessenen Punkten (x,y) durchführen.
Hier würde sich gewichtete Regression anbieten, denn du hast auch die Fehler deiner Messungen (nehm ich an).
Du bekommst dann eine geschätzte Funktion e(x,y) deren Schätzung ebenfalls fehlerbehaftet ist (siehe Verteilung des Regressionsschätzers).
Die Fehler der Schätzung müssen dann bei der kalibrierten Messung mit in die normalen Messfehler einbezogen werden.
Wenn du nun wissen willst, wie man eine Regression durchführt, dann verweise ich dich an dieser Stelle auf einschlägige Literatur bzw. Statistik-Bücher.
Im Wesentlichen geht es darum ein Norm-Minimierungsproblem zu lösen:
min || e(x,y) - X*Beta||^2
wobei Beta der Regressions-Schätzer ist und X deine Design-Matrix mit den Datenpunkten. Hierbei wird das Modell
Y = X * Beta + Epsilon
unterstellt, bei dem Epsilon die Fehler sind (Erwartungswert = 0) und Y der Datenvektor mit den e-Werten. Ein derartiges Modell kannst du z.B. bei polynomieller Regression erreichen, wenn du X entsprechend wählst.
Mehr dazu aber in der Fachliteratur, im Detail erklären werde ich dir die Regression nämlich nicht. Wenn du dich eingelesen hast und dann noch Fragen auftauchen, gucke ich gerne nochmal drauf.
EDIT: Übrigens könnten sich auch ganz andere Verfahren als polynomielle Regression für deine Problemstellung eignen: Zum Beispiel (Glättungs-)Splines oder nichtparametrische Methoden (Kernel-Regression, Kriging u.a.).
Welche Methode geeignet ist, kannst aber nur du entscheiden.
Außerdem drängt sich mir die Frage auf: Wenn du doch für jeden beliebigen Punkt Soll-Werte hast oder errechnen kannst, warum brauchst du das alles dann?
Viele Grüße,
NeuroCoder
Hallo Oliver,
mit deiner Beschreibung kann ich immer noch nichts anfangen. Ich versuche mich mal an einer Interpretation.
Du hast ein Modell:
f: R^2 -> R
Das repräsentiert deine Sollwerte. Zu jedem Koordinatenpunkt (x,y) gibts einen Wert.
Dann hast du die Realität, also deine Apparatur / Versuchsaufbau, die dir Daten liefert:
g: R^2 -> R
Im besten Fall würde g = f gelten (Realität = Modell). Da du aber von Kalibrierung sprichst, wird das nicht der Fall sein.
Du suchst also eine Approximation des Fehlers e(x,y) = f(x,y) - g(x,y), damit du bei gemessenen g-Werten auf die korrekten f-Werte schließen kannst durch f(x,y) = g(x,y) + e(x,y), also Messung + Korrektur.
Wenn das der Fall ist, dann willst du eigentlich eine Approximation von e(x,y) machen. Wenn du nun einen polynomiellen Ansatz für e machst und auch noch Messunsicherheit (die du ja kennen solltest?) dazu nimmst, kommst du zur Polynom-Regression.
Stimmt meine Interpretation?
Viele Grüße,
NeuroCoder
Hallo Oliver,
was weißt oder vermutest du denn über den Zusammenhang deiner Punkte?
Handelt es sich um einen linearen, nach Transformation linearen oder nichtlinearen Zusammenhang? Weißt du das überhaupt oder möchtest du das (explorativ) feststellen?
Erst wenn du diese Fragen beantwortet hast, kannst du ein Modell (das ist eben jener Zusammenhang) aufstellen und dann Regression betreiben.
Was meinst du mit 4. Ordnung? Polynomielle Regression bis zum Grad 4?
Viele Grüße,
NeuroCoder
Hallo dr4g0n76,
die "bepunkteten" Operatoren bedeuten elementweise:
rand(2) .* rand(2)
multipliziert z.B. die beiden Zufallsmatrizen elementweise.
Der Doppelpunkt indiziert alle Indizes in dieser Dimension:
A = [1, 2, 3; 4, 5,6];
A(:, 2) % Liefert die 2. Spalte (alle Zeilen)
A(1,:) % Liefert die 1. Zeile (alle Spalten)
A(:) % Liefert die Matrix als Vektor (alle Spalten aneinander hängen)
A(:,:) % Liefert die Matrix selbst
Ich nehme an, dass col_img(:,:, k) eine Matrix liefert (Pixel des Bildes) und k den Farbkanal angibt.
In Zeile 0047 werden die Matrizen elementweise zu einer Matrix in der Größe des Bildes addiert.
Viele Grüße,
NeuroCoder
Hallo DerPapenberg,
suchst du vielleicht sowas:
internal class Helper
{
public event EventDelegate MyEvent;
}
public class MainClass
{
private Helper _helper;
public event EventDelegate MyEvent
{
add { _helper.MyEvent += value; }
remove { _helper.MyEvent -= value; }
}
}
Mfg NeuroCoder
Hallo ProgrammierTroll,
vielleicht ist auch das XMLRepository-Projekt von Golo Roden und Peter Bucher was für dich:
http://www.xmlrepository.ch/
Mfg NeuroCoder
Hallo Axxus,
alternativ zu den Pseudo-RNGs aus dem Framework kannst du deine Simulation auch mit echten Zufallszahlen laufen lassen, die du z.B. von random.org beziehen kannst.
Dazu siehe:1.http://www.random.org/clients/http/ 1.http://www.random.org/clients/http/archive/
Normalerweise sollte aber auch die Qualität der Pseudo-RNGs ausreichen, wenn du sie denn richtig benutzt (siehe meine beiden Vorposter).
Mfg NeuroCoder
Hallo Gruwe,
du kannst gerne mal hier hinein schauen: Generic Manipulator Tool
Je nach Anforderung deiner Anwendung kann es sinnvoll sein, das komplette Schaltbild selbst zu zeichen (Stichwort OnPaint).
Ansonsten geht es nur darum, sich die Verbindungen und Positionen der Bauteile zu merken und dann zu zeichnen. Das Verschieben (MouseMove, MouseDown, MouseUp) und Verbinden sollte nicht weiter schwierig sein.
Mfg NeuroCoder
Hallo fr4gme,
da es sich hier um eine gleichförmige Bewegung (also konstante Geschwindigkeit) handelt, ist das ein linearer Zusammenhang.
Du berechnest aus deinen Referenzwerten die Geschwindigkeit: v = Weg / Zeit.
Dann kannst du durch Umstellen dieser Formel nach Zeit die Dauer für eine beliebige Strecke ermitteln.
Die Geschwindigkeit sollte übrigens bei deinen Werten etwa v = 12.0898666 pixel / sec betragen.
Mfg NeuroCoder
Hallo stes,
mir sind spontan folgende Verbesserungsvorschläge für dein Projekt eingefallen (ohne dass ich mir den Code angeschaut habe):*Lagere die Verhaltenssteuerung in ein Interface aus und gib dem Jäger und Wolf eine Instanz davon. Die entsprechenden Events können dann die Funktionen aus dem Interface aufrufen.
So vermeidest du, dass Programmierer an der Programmbasis und den EventHandlern "herumpfuschen" können. Das hast du zwar in Textform in deinem Post verboten, kann aber auch über solches Design erzwungen werden.
*Damit man den Basiscode gar nicht anfassen braucht, kannst du ein Plugin-System implementieren. Jeder Duellant braucht dann nur seine Assembly mit dem Verhalten zur Verfügung zu stellen. Das Hauptprogramm (dein Simulator) kann diese DLLs laden und das Duell simulieren.
Wenn du das Verhalten sowieso schon in Interfaces ausgelagert hast, ist ein Plugin-System nicht mehr weit weg.
*Ich habe deinen Code nicht gesehen, aber für den Einstieg ist es sicherlich nützlich, wenn du Beispiel-Verhaltensmuster dazu legst, mit denen man direkt auch testen kann. *Halte die Einstiegshürden so gering wie möglich. D.h. biete schon vorgefertigte Solutions / Projekte zum Erstellen seines Verhaltens an, damit der geneigte Programmierer nur noch den Code für das Verhalten in die Funktionsrümpfe gießen muss.
Zu diesem Punkt zählt auch (vielleicht sogar vor allem) ein sinnvoll gewähltes Interface-Design.
Mfg NeuroCoder
Hallo Ahrimaan,
suchst du vielleicht einer der beiden Möglichkeiten?
public interface IModule<T> where T : class
{
void StartModule(bla, IRepository<T> repo);
}
Oder
public interface IModule
{
void StartModule<T>(bla, IRepository<T> repo) where T : class;
}
Mfg NeuroCoder
Hallo webco,
wenn es sowieso schon Schwarz / Weiß ist, sind die Graustufen natürlich nicht nötig. Da habe ich geschlafen, sorry.
inputB[index] = (B.GetPixel(x, y).B * A.GetPixel(x, y).B * B.GetPixel(x, y).G == 255 * 255 * 255) ? 0.0 : 1.0;
Das A in A.GetPixel(x, y).B sollte sicher ein B sein. Überhaupt frage ich mich, warum du den Alpha-Kanal an der Stelle eingehen lässt und nicht den Rot-Kanal?
Die Überprüfung lässt sich bestimmt auch noch weiter vereinfachen. Wenn du immer nur Schwarz / Weiss hast, genügt auch:
inputB[index] = (B.GetPixel(x, y).B > 0 ? 0.0 : 1.0;
Du kannst dir zur Sicherheit die Werte in den beiden Arrays im Debugger mal anschauen, oder auf die Konsole ausgeben lassen.
Mfg NeuroCoder
Hallo webco,
wofür die Parameter stehen, erfährst du in der Dokumentation 😉
Im Fall von ActivationNetwork stehen die Zahlen nach inputA.Length für die Anzahl an Neuronen in den Schichten (jede Zahl ist eine Schicht).
Dein Netzwerk hat also inputA.Length Eingabe-Neuronen, 2 Neuronen in einem Hidden-Layer und 1 Neuron in der Ausgabeschicht.
Ich bezweifle stark, dass du damit brauchbare Ergebnisse erreichst, insbesondere wenn die restlichen Buchstaben auch mal später hinzu kommen sollen.
Wieviele du brauchst, kann man nicht genau sagen. Das muss man häufig ausprobieren oder schätzen.
Oftmals funktionieren neuronale Netze besser, wenn man binäre Aktivierungen ({0, 1} oder {-1, 1} als Wertebereich der Neuronen) nimmt. Das heißt, es könnte helfen, wenn du dein Bild nach Graustufen konvertierst und auf eines der beiden Intervalle normierst.
Sicherlich ist es auch sinnvoll so viele Ausgabeneuronen zu haben wie die Anzahl an zu unterscheidenden Klassen (z.B. hier 26 fürs Alphabet).
Die Zwischenschicht sollte dann zwischen Anzahl Eingabe- und Anzahl Ausgabeneuronen liegen, damit eine Reduktion vorgenommen wird. Hier ist aber Vorsicht geboten, da zu groß dimensionierte Schichten das Auswendiglernen begünstigen und damit die Generalisierung verhindern können.
Mfg NeuroCoder
Hallo winSharp93,
Eine Methode ohne evolutionäre Algorithmen wäre jetzt z.B. das ganze wie in einem Fussballturnier zu machen: Man stellt ein paar hundert mögliche Kombinationen auf, lässt alle gegen alle antreten, kombiniert die höchstplatzierten neu und lässt das ganze erneut ablaufen.
Aber bin ich damit nicht schon wieder bei einer primitiven Form eines evolutionären Algorithmusses?
Im Wesentlichen schon (soweit ich mich mit diesen Dingern auskenne).
Im Grunde muss ein evolutionärer / genetischer Algorithmus die Individuen bezüglich ihrer Fitness ordnen. Ob dies nun über eine Fitness-Funktion oder eine selbst definierte totale Ordnungsrelation geschieht, sollte egal sein.
Falls du in deiner Library während der Bewertung an alle Individuen der Generation dran kommst, kann die Bewertung auch so erfolgen, dass du - wie du schon sagtest - das zu bewertende Individuum gegen alle restlichen antreten lässt und die Anzahl an Siegen / Niederlagen / Unentschieden gewichtet eingehen lässt. Dazu könntest du noch die benötigte Anzahl an Zügen addieren.
Ich kenne mich bei verfügbaren Libraries in dem Punkt nicht aus (besonders nicht bei Java). Habe mir bislang immer selbst etwas gebaut.
Wichtig ist, wie du die Kreuzung und Mutation gestaltest und welche Wahrscheinlichkeiten du dafür ansetzt. Spontan würde ich ein zufällig gewichtetes Mittel der Konstanten für die Kreuzung und Addieren einer beschränkten Zufallszahl für die Mutation wählen.
Kann ein evolutionärer Algorithmus überhaupt mein Problem lösen? Ja, das kann er. Für solche diskreten Probleme sind die oft geeignet.
Mfg NeuroCoder
Hallo blr,
es gibt mehrere Möglichkeiten. Du könntest dich zum Beispiel mit Color Keying beschäftigen. Der Color Key gibt an, welche Farbe als transparent betrachtet werden soll.
Eine andere Möglichkeit wäre es, die Texturen mit Alpha-Kanal (also echter Transparenz) zu speichern und ein entsprechendes Texturformat zu benutzen.
Zumindest bei Direct3D 9 musst du noch schauen, dass die Renderstates korrekt gesetzt sind.
Mit freundlichen Grüßen,
NeuroCoder
Hallo myCSharpler,
Nach nun mehr als 3 Jahren rücke ich endlich mit dem Source raus. 😉
Der Code der letzten / aktuellsten Version befindet sich im Anhang.
Das Projekt ist unter einer BSD-Style-Lizenz veröffentlicht.
Bei produktivem Einsatz, Weiterentwicklung oder Ähnlichem würde ich mich aus reinem Interesse sehr über eine PN oder E-Mail freuen.
Der Code ist qualitativ nicht in einer Form, in der ich ihn gerne veröffentliche. Er hat viel Refactoring nötig und ist an einigen Stellen nicht besonders elegant. Aus Zeitmangel war es mir jedoch nicht möglich, ihn in eine brauchbare Form zu bringen, obwohl dieses Vorhaben schon seit etwa 3 Jahren besteht. Interessenten mögen an dieser Stelle ein Nachsehen mit mir haben.
Mfg NeuroCoder
Hallo,
ich suche ein Tool, welches mir einen Lizenz-Header meiner Wahl (oder einfach irgendeinen Text) in jedes Source-File schreibt.
Lieb wäre mir, wenn es auch XML-Files korrekt behandelt.
Ich brauche keine GUI dafür. Ein gutes Shell Skript (bash) würde es auch tun.
Viele Grüße,
NeuroCoder
Hallo computer_case,
wie schon zuvor bemerkt, liegt dir hier eine gewöhnliche lineare Differentialgleichung vor.
d^2 s(t) / dt^2 = a(t)
bzw. das System
d s(t) / dt = v(t)
d v(t) / dt = a(t)
Genauer: Da dir die Position s(0) und die Geschwindigkeit v(0) zum Zeitpunkt t = 0 bekannt sind, handelt es sich um ein Anfangswertproblem.
Als einfaches Verfahren zur numerischen Lösung könntest du z.B. das Eulersche Polygonzug-Verfahren heranziehen: Eulersches Polygonzugverfahren
Um das Verfahren auf dein Problem anzuwenden, muss das y aus dem Artikel der Vektor y = [s; v] = [y_1; y_2] sein und das f(t,y) ist gegeben als Abbildung f(t,y) = [y_2; a(t)]. Durch diese Setzung ergibt sich genau obiges System.
Nun wählst du eine Schrittweite h (je genauer, desto kleiner) und berechnest dann iterativ die Iterierten y_(k), wobei du mit y_(0) = [s(0), v(0)] startest.
Runge-Kutta-Verfahren (z.B. das klassische) bieten dir aber eine schnellere Konvergenz und höhere Stabilität (sind aber auch etwas schwieriger zu implementieren).
Viele Grüße,
NeuroCoder
PS: Für sowas wären LaTeX-Tags nützlich.
Hallo partyboy,
was du möchtest, nennt sich Overlay. Suche danach im Forum.
Mit hoher Wahrscheinlichkeit wirst du bei diesem Vorhaben mit Managed Code wenig Erfolg haben. Meist wird das mit DLL Injection oder Hooken von Funktionen des Direct3D-Device gelöst.
Suche auch in Spieleentwicklungsforen, wie z.B. zfx.info oder gamedev.net und natürlich mit einer (oder mehreren) Suchmaschine(n) deiner Wahl.
Mfg NeuroCoder
Hallo baer99,
mir fallen da folgende Threads / Projekte im Forum ein:
updateSystem.NET
AppDater (ehemals K_Updater)
Mfg NeuroCoder
Hallo Hirnhamster,
hast du dir schonmal NoSQL Datenbanken angesehen? Möglicherweise passt eine DocumentDB besser auf deine Anwendung.
Schau dir doch z.B. mal Raven DB an: http://ravendb.net/
Mfg NeuroCoder
Hallo marcom,
ich bin mir zwar nicht sicher, aber ich vermute, dass JACK das kann, möglicherweise auch EsounD (esd).
Das ist jedoch Linux-Software.
Falls du das nicht einsetzen möchtest, könntest du vielleicht mit irgendeinem VoIP-Programm eine Verbindung aufbauen und die entsprechenden Streams als Ein- und Ausgabe verwenden.
Mfg NeuroCoder
Hallo lord-maricek,
du kannst ja direkt schonmal über die Anzahl der Zeilen die Größe deines Arrays herausfinden.
Wenn jeder Eintrag 3 doubles für die Koordinaten speichert, kommen bei einer Million Einträgen ungefähr 23 MB zusammen. Das ist auf heutiger Hardware unbedenklich.
Ich würde die Zwischenpunkte, mit denen du z.B. Strecken rasterst, on the fly generieren.
Wenn du das mit einem genügend großen Buffer koppelst, sollte das gut funktionieren.
Ich würde mir das ungefähr so vorstellen:
public static IEnumerable<Point3> CreateRasterList(IEnumerable<GItem> items)
{
GItem last = items.First();
foreach(GItem item in items)
{
// Bestimme Anzahl Zwischenpunkte
int nSteps = DetermineSteps(last, item);
for (int i = 0; i < nSteps; ++i) {
// Interpoliere
yield return CalculatePosition(last, item, nSteps, i);
}
last = item;
}
}
public static IEnumerable<Point3> BufferRaster(IEnumerable<Point3> source, int bufferSize)
{
// Liste erstellen um Lazy-Evaluation von Take() zu verhindern
List<Point3> buffer = source.Take(bufferSize).ToList();
while (buffer.Count > 0)
{
for(int i = 0; i < buffer.Count; ++i)
{
yield return buffer[i];
}
buffer = source.Take(bufferSize).ToList();
}
}
public static IEnumerable<Point3> ProcessGList(IEnumerable<GItem> items)
{
// Buffer-Größe z.B. 80 Punkte
return BufferRaster(CreaterRasterList(items), 80);
}
Die DetermineSteps() und CalculatePosition() Funktionen müssen natürlich entsprechend implementiert werden.
Bei letzterer kann die Interpolation auch ganz unterschiedlich ausfallen (linear, kubisch etc.).
Die Buffer-Größe hängt von der Bandbreite deiner Hardware-Schnittstelle und der Verarbeitungsgeschwindigkeit deiner Fräse ab. Primär vermutlich von letzterer.
Mfg NeuroCoder
PS: Der obige Code hat sicher noch viel Verbesserungspotential. Insbesondere werden keine Fehler abgefangen.
Und mein C# ist wegen dem vielen Matlab in letzter Zeit etwas eingerostet.
EDIT: Code etwas verbessert.
Hi,
meine Uni ist neuerdings Mitglied im MSDN AA.
Über selbiges habe ich mir jetzt Windows 7 und Visual Studio 2010 besorgt.
Auf wievielen Maschinen darf ich das nun als Student installieren?
Aus der EULA lese ich genau eine Maschine heraus.
Besonders interessiert mich hier: Zählt eine Virtual Machine da auch?
Ich würde gern mein Windows 7 mit BootCamp und unter Mac OSX in einer VM benutzen. Dabei werden sich die Hardwareprofile natürlich signifikant unterscheiden, sodass vermutlich eine neue Aktivierung bei jedem Wechsel nötig ist.
Lässt sich das vermeiden?
Viele Grüße,
NeuroCoder
Hallo maaka,
die Forumssuche liefert folgende Startpunkte für weitere Recherchen:
Erweiterungssystem realisieren
[gelöst] Getrennte AppDomain ohne CreateInstance*
Mfg NeuroCoder
Hallo St_W,
dann schlage ich mal [Tutorial] Das neue Konfigurationsmodell im .NET Framework 2.0 vor.
Mfg NeuroCoder
Hallo michlG,
ich habe es zwar noch nicht auf Windows probiert, aber für Mac funktioniert Unison ziemlich gut:
http://www.cis.upenn.edu/~bcpierce/unison/
Mfg NeuroCoder
Hallo blutiger_anfänger,
wie wäre es mit Moodle?
Mfg NeuroCoder
Hallo Lan,
das sind eigentlich Basics: 🛈 und 📗
Aber kurz und schmerzlos:
public class Node
{
public int Value { get; set; }
public Node(int value)
{
Value = value;
}
}
Mfg NeuroCoder
Hallo herbivore,
das meinte ich auch nicht so. Ich hatte schon eine Schleife im Sinn.
Oder eine LINQ-Query wie:
form.Controls.Where(x => x.Top > 100).ToList().ForEach(x => x.Visible = false);
Die Panel Lösung ist natürlich der sauberste Weg.
Mfg NeuroCoder
Hallo luislombriz,
du musst jedes einzeln ansprechen. Eventuell geht auch eine Lösung mit LINQ (damit kenne ich mich nicht aus).
Benutze die Controls Collection deines Formulars / Containers.
Mfg NeuroCoder
Aus Königsberger - Analysis II:
Die Kettenregel ergibt die Abschätzung:
Hallo winSharp93,
natürlich darfst du: Das war auf einem Gymnasium (NRW) in den Jgst. 11-13.
EDIT: Umfang vergessen: 3 Stunden pro Woche - (Doppel- & Einzelstunde).
Bei uns (ich weiß nicht, ob das Allgemein so üblich ist), gibt es einmal den Info Unterricht als Differenzierungs-Kurs ab der 8. bis zur 10. Klasse (glaube ich, ist schon so lang her).
Da haben wir tatsächlich die halbe MS Office Suite durchgenommen (Menüs für Klausur auswendig lernen [Halte ich für Quatsch]). Aber auch ein wenig Visual Basic programmiert und mit LEGO Mindstorms Roboter gebaut (Das war super!).
In der Oberstufe ist Informatik bei uns ein normal wählbarer Kurs, wie jeder andere auch.
Soweit ich mich erinnern kann, nimmt er aber im Abitur eine Sonderstellung ein, da er nicht als Naturwissenschaft zählt.
Ich würde es nicht schlimm finden, wenn auf dem Abschlusszeugnis keine Informatik-Note steht.
Wenn sich ein Studium anschließt, ist das Zeugnis sowieso nicht mehr so wichtig. Am meisten Wert wird IMHO immer noch auf den zuletzt gemachten Abschluss gelegt.
Viele Grüße,
NeuroCoder
Hallo winSharp93,
ich behaupte mal von mir, sehr guten Informatik Unterricht genossen zu haben.
Und erstmal muss ich hier noch loswerden: Informatik (als Fach) besteht nicht nur aus Programmieren und Programmier-Paradigmen (OO, Funktional, Imperativ etc.).
Tatsächlich hat die Informatik einen großen theoretischen Anteil (als aus der Mathematik hervorgegangenes Fach, ist das nicht verwunderlich).
Wir haben viel Theorie gemacht (Datenstrukturen, Formale Sprachen, Turing Maschine, Endliche Automaten, Komplexitätsanalyse, P != NP (?) ) und mussten beim praktischen Teil auch immer ein Struktogramm des Algorithmus anfertigen (später bei den OO Projekten ein UML-Diagramm).
Ich muss hier vielleicht dazu sagen: Mein Lehrer war eigentlich primär Mathelehrer und hat (AFAIK) sich später zusätzlich für Info-Unterricht in einem Seminar / Kurs qualifiziert.
Wir haben ebenfalls mit Delphi gearbeitet. Mit einem Framework (Stifte Und Mäuse) die ersten Anwendungen geschrieben (Formen malen, Rotkäppchen und der Böse Wolf etc.). Dann haben wir auf dieses Framework (durch Ableiten von der Hauptklasse) ein System geschrieben, was Events erzeugt und in virtual Methoden verarbeiten lässt.
Gruppenarbeiten haben wir auch gemacht und dabei per UML zuerst die Anwendung designed und dann die einzelnen Klassen und Units auf die Gruppenmitglieder aufgeteilt und später zusammengefügt. (Wichtiger Punkt: Designdokument, Absprachen)
Viele Projekte und Beispiele haben wir zu Konzepten erstellt:*Rekursion und Pointer: Zug, an den Wagen angehangen werden, der dann fährt (Fahr-Befehl wird von der Lok immer weiter durchgegeben) *Komplexitätsanalyse: Sortieralgorithmen in Gruppenarbeit. *Rekursion: Türme von Hanoi *Backtracking: 8-Damen Problem *Verschlüsselung: Einfaches RSA Verfahren mit kleinen Zahlen
Wir haben uns im Zuge der Datenstrukturen auch intensiv mit dem Pointer-Konzept befasst und die elementaren Kontrollstrukturen ( Schleifen, If) nacheinander eingeführt.
Auch auf Feinheiten sind wir eingeganen, z.B. Short-Circuit Operatoren.
An der Uni hat mir der Info-Unterricht (oder die Vorkenntnisse?) so die ersten Basis-Vorlesungen erspart.
Soweit die Beschreibung. Vorkenntnisse hatte ich auch und der Unterricht bestand zu einem Großteil aus dem Helfen nach dem man die Aufgabe beendet hatte.
Mein Fazit bleibt also: Es liegt am Lehrer (wie bei jedem Unterricht). Und da spielt man leider Lotterie.
Richtig qualifiziert und kompetent sind leider kaum Leute und das Tempo muss sich sowieso immer den Schwächsten im Kurs anpassen. Wenn man dann noch Vorkenntnisse hat, ist Langeweile vorprogrammiert.
Besonders Lehrer vom älteren Schlag haben häufig Probleme sich von Schülern etwas sagen zu lassen (grob von einer Schule verallgemeinert).
Just my 2 cents,
NeuroCoder
Hallo calabrese,
public class MeinControl : UserControl
{
// ...
// Event, das von außen abonniert werden kann
public event TextChangedHandler TextChanged;
// Behandelt das von der TextBox geworfene Event
protected void TextBox_TextChanged(object sender, TextChangedEventArgs e) {
// Mache was
// Löse unser eigenes Event aus
OnTextChanged(e);
}
// Auslösefunktion für das Event
protected virtual void OnTextChanged(TextChangedEventArgs e) {
TextChangedHandler handler = TextChanged;
if (handler != null) {
handler(this, e);
}
}
}
Code ohne Gewähr - mein C# ist durch das viele Java Programmieren in letzter Zeit etwas eingerostet.
Viele Grüße,
NeuroCoder
Hallo Floschi,
ein TabControl wäre schon eine gute Lösung.
Wenn du allerdings wirklich einen Assistenten möchtest, was hier wohl Overkill wäre, dann such im Forum nach "Wizard".
Mit meiner Wizard-Library sollte das ohne großen Aufwand realisierbar sein:
WizardOfOz - Wizard Library für .NET 2.0
Mfg NeuroCoder
"Könnte" - sollte nur eine Idee sein, was man testen könnte.
Da hilft nur ausprobieren und profilen - oder Glück haben, dass jemand hat das gleiche Szenario schonmal gehabt hat und hier berichtet.
Die Idee bezieht sich übrigens nur auf das Szenario, wenn du Texte von Benutzern "zensieren" möchtest.
Ansonsten würde ich mal eine Liste oder Array ausprobieren, durch das iteriert wird.
Ich vermute nämlich (nicht wissen 😉 ), dass die Query im Typsystem vergleichsweise teuer ist.
Außerdem matchst du dann mit einem geeigneten String.Equals auch verschiedene Groß- / Kleinschreibungen, die du mit dem case-sensitiven Enum nicht erschlägst (nur mit mehr Einträgen im Enum).
Übrigens finde ich ein Enum als Speichermethode dafür ungeeignet.
Lieber eine Liste oder String als Ressource oder XML- / Text-Datei auslagern.
Sonst musst du recompilen wenn Wörter hinzukommen oder wegfallen.
Hallo Backstein,
ich könnte mir vorstellen, dass ein RegEx (einmal kompiliert) schneller ist als die Abfrage im Typsystem.
Mfg NeuroCoder
Hallo Alphawolf1988,
typeof(Test1).IsAssignableFrom(testObjekt.GetType())
Mfg NeuroCoder
Hallo,
ich habe bis jetzt Erfahrungen mit Drupal und Wordpress als CMS gemacht.
Für kleinere Seiten lohnt es sich, ein Wordpress als CMS einzusetzen - man deaktiviert einfach die Blogging Funktionen. Zur Anpassung gibt es auch Plugins.
Mit Drupal bin ich im Grunde bis jetzt sehr zufrieden und betreibe auch 2 Installationen.
Was allerdings nervt ist die fehlende Auto-Update Funktion (oder ich hab noch kein Module gefunden, was das adäquat erledigt). Bei einem Update muss man das Modul manuell per FTP uploaden und das Update anstoßen.
Hat man Shell-Zugriff, erleichtert Drush einem diese Arbeit ungemein. Den habe ich aber leider auf einer Installation nicht.
Ansonsten hat es eine schöne, stabile Codebase und man kann sehr leicht eigene Modules schreiben, was ich auch schon 2x gemacht hab.
In der Regel ist das aber nicht erforderlich, weil eben die Community so groß ist und dementsprechend viele Modules und Themes schon zur Verfügung stehen.
Die (für mich) wichtigsten Module sind: CCK, Views (sollen beide AFAIK in Drupal 7 zum Core gehören), ImageCache, Zen, Textile / Markdown (Für einfache Eingabe - ich mag keine JavaScript WYSIWYG Editoren, die schlechtes XHTML produzieren).
Man kann sich übrigens mit ImageCache, FileFieldPaths, Filefield, Imagefield, Image_FUpload sehr schnell eine Galerie zusammenbauen.
Viele Grüße,
NeuroCoder
Hallo Barbara,
das ist richtig - WinForms funktionieren nicht über AppDomain Grenzen hinweg.
Folgendes müsste eigentlich funktionieren:
Definiere Interfaces für deinen Plugin-Host und lagere diese in eine eigene Assembly aus.
Host Anwendung und Plugins referenzieren dann die gleiche Host-Interface Library. Jetzt kannst du die Implementierung im Host beliebig ändern, ohne dass die Plugins rekompiliert werden müssten oder etwas davon mitbekämen (sofern sich das Interface nicht ändert).
Durch diese Entkopplung müsstest du auch bei signed Assemblies keine Probleme bekommen.
Viele Grüße,
NeuroCoder
Hallo TripleX,
was spricht dagegen, das DataSet einfach an die Plugins zu übergeben, bzw. es von diesen von der Host-Anwendung anfordern zu lassen?
Alternativ könntest du auch einen QueryService in deiner Host-Anwendung einbauen, über den die Plugins Queries absetzen können. So kannst du dann zB auch den Schreibzugriff auf Daten verbieten, oder den Lese-Zugriff einschränken.
Hast du denn nun eine Datenbank oder nur ein selbst befülltes DataSet zur Datenhaltung?
Mfg NeuroCoder
Hallo GetChar,
soll es wirklich nur ein rotierbarer Würfel sein und mehr nicht? Beleuchtung, etc. sind egal?
Dann sollte das noch relativ leicht mit GDI Mitteln und ein bißchen Matrizenrechnung machbar sein.
Dafür WPF, Direct3D oder OpenGL zu benutzen, ist meiner Meinung nach mit Kanonen auf Spatzen geschossen.
Mfg NeuroCoder