Hi!

Hi,

Dafür kann man andere tolle Dinge mit .NET tun.

Tschüss

ich weiss, ich verwende es auch schon seit Jahren uns ist bei mir stets 1. Wahl. Für interessierte: Unter Raw disc Access für C++ steht wunderbar beschrieben, wie man unter C++ das ganze zu machen hat. Da ist ne VS Solution dabei, wenn man mag, kann man das ganze mit Managed C++ koppeln bzw. in die selbe Applikation packen. Funktioniert auch unter Vista!

Die Variante über Invoke CreateFile(...) hat unter C# auch noch funktioniert, allerdings nur bis Windows XP.

Grüße Casiopaya

Hallo!

danke für die Antwort. Wirklich schade, welche Sprache wäre denn da die richtige? Ich vermute mal mit C++ geht sowas, nicht wahr? Leider kann ich dann wohl aus den selben Gründen nicht managed C++ verwenden...

Grüße Casiopaya

Hallo!

hat jemand schon einmal ein Image eines Datenträgers (Also ein Byteimage, so wie es Programme wie Acronis True Image, Driveimage XML oder R-linux erstellen) unter C# erstellt bzw. weis jemand vlt. wie dies gehen könnte?

Es wäre toll, wenn mir da jemand helfen könnte.

Grüße Casiopaya

Hi!

Danke, ich werd den Link erstmal gründlich durchlesen und weitergoogeln, vielen Dank soweit.

Hi liebe community!

für eine Studienarbeit muss ich verschiedene Ressourcenkonzepte (z.B. win32, mono, ELF, QT etc) vergleichen.

Kennt jemand einen Link, der sehr ausführlich beschreibt wie Ressourcen unter .Net verarbeitet werden? Man kann beim Kompilieren Ressourcendateien verwenden, mich interessiert die Technik dahinter. Wie wird nachher in der Exe auf die Ressourcen zugegriffen etc?

Für Hilfe bin ich dankbar

Hi !

genau um dieses Runterbrechen geht es ja. Wie würdest du das machen? Bei z.B. 2000 auf 1000 könnte man zwar jeden 2. Wert nehmen, trotzdem wäre das keine gute Annäherung, da jeder 2. Wert völlig verloren geht.

Nimmt man bei 2000 auf 1000 jeweils den Schnitt der zwei benachbarten Werten wäre das optimal, nur wie macht man das dann bei 1344 auf 1000 ?

Andersrum: Wie Rechne ich 800 Werte auf 1000 Werte hoch? Leider kann man hier nicht so einfach (z.B. linear) interpolieren, da man auf einem diskreten Signalbereich arbeitet.

Grüße Vasi

Hallo zusammen!

Kennt jemand einen effizienten Alogrithmus, mit dem man ein diskretes Signal (z.B. Zahlen in einem 1D-Integer-Array) auf eine bestimmte Anzahl an Samples stretchen bzw. drücken kann?

Ein Beispiel:

Ich habe ein Array mit 1576 Werten, möchte dies auf ein Array mit 1000 herunterbrechen. -> Skalierung, Extrapolation, Glättung.

Oder: Ich habe ein Array mit 233 Werten und möchte dieses auf ein Array mit 1000 hochrechnen. -> Skalierung, Interpolation.

Die Größen der Eingangarrays sind natürlich jeweils variabel. Natürlich kann ich selbst die Algos schreiben, nur vllt gibt es schon welche, die schneller und besser bezüglich Glättung etc sind.

Für Hilfe bin ich sehr dankbar,

Casiopaya

Hallo!

ich geb zu, dass ich mich anfangs vermutlich etwas unglücklich ausgedrückt habe. Ich möchte eine Permutation wie gesagt **nicht **in einem Baum speichern. Der Baum dient nur zur Abbildung einer gespeicherten DS in eine Permutation.

Andersherum, wenn kann man im Array eben so wie im Baum ungültige Pfade bilden. Die Datenstruktur verhindert das nicht.

eben nicht 🙂 ich denke das ganze problem liegt in der Verständigung. eine Permutation ist bei mir letztlich ein Bit-String, der in Segmente aufgeteilt ist.

| 1. Teil | 2. Teil | 3. Teil1 |

Der 1. Teil ist so groß (binär betrachtet), dass er 3 verschiedene Zustände darstellen kann. Der zweite Teil ist kleiner, er kann nur noch 2 Zustände darstellen. Der letzte kann nur noch einen Zustand darstellen, wird aber aus einfachheit drangelassen.

Folgende DS:

|2 | 2 | 1| oder binär |01|1|0|

wird über den Abbildungsbaum

.          Start 
    /        |       \
    1        2       3
   /\       /\       /\
   2 3     1 3      1 2
  |  |     |  |     |  |
  3  2     3  1     2  1 

in die Permutation 2-3-1 Abgebildet.

Das einzige Problem, dass man dabei vielleicht noch hat ist, dass man gar keinen String - Teil definieren kann, der GENAU 3 Zustände haben kann. (Die minimale Variante wären 2 Bits, welche bereits 4 Zustände darstellen können). Dieses Problem kann man aber wie gesagt dadurch umgehen, dass man den Baum in einen Binärbaum umwandelt.

Es geht also darum, dass meine DS NUR gültige Punkte im Suchraum darstellen KANN.

Grüße

Casiopaya

Hallo herbivore!

Zitat:

Der Suchraum entsteht ja ebenfalls nicht durch die Datenstruktur, sondern durch den Algorithmus.

ok hast recht. der Suchraum indem ich suche wird natürlich durch den Algo bestimmt. Trotzdem ist es wünschenswert, wenn meine Datenstruktur NUR punkte aus diesem Suchraum zulässt.

hmm, aber wie du siehst kommt der Pfad 1-1-1 nicht in meinem Baum vor. Ich möchte ja nicht den Pfad direkt als Folge von "Zahlen" zwischen 1 und 3 darstellen sondern als "Wegbeschreibung". Ein Beispiel:

Beim 1. Knoten habe ich die Wahl zwischen 1, 2 und 3. Angenommen ich wähle "2".

Beim 2. Knoten habe ich nun die Wahl zwischen 1 und 3. Angenommen ich wähle "3".

Beim 3. Knoten kann ich nur noch "1" wählen.

Also wär eine Datenstruktur denkbar, die folgendermaßen aufgebaut ist:

| 3 | 2 | 1 |

Dabei bedeuten die Zahlen die Anzahl der darstellbaren Zahlen in einem Segment. Am Anfang muss ich 3 Zahlen darstellen können, dann zwei, dann nur noch eine.
(Ok hier komme ich mit primitiven Datentypen nicht mehr weiter, aber so eine darstellung kann man sich ja selbst binär basteln)

Dies unterscheidet sich zu eine Array, das nach obiger Beschreibung so aussehen würde:
| 3 | 3 | 3 |

Die erste Datenstruktur führt nämlich dazu, das egal welches "Element" ich aus dem Suchraum aller Datenstrukturen nehmen, die DS immer eine gültige Permutation darstellt. und letztlich ist es genau DAS was ich will, denn nun kann ich fein Individuen dieser DS genetisch manipulieren.

Da jeder Baum bijektv in einen Binärbaum umwandelbar ist wär hier auch möglich den BAum in einen Binärbaum umzuwandeln. Dann wäre jede PErmutation eine gleichlange Folge von Nullen und Einsen. Und jede Folge von Nullen und Einsen wäre eine gültige Permutation! Juppie !

GRüße
Casiopaya

Morgen zusammen,

danke für eure Antworte! Dazu fällt mir folgendes ein:
Das Verwenden eines (10! x 10) - langen Arrays wollte ich eben gerade verhindern, da in dieser Datenstruktur auch Suchpunkte darstellbar sind, die gar nicht in meinen Suchraum gehören. Oder besser gesagt: Ich WILL ja gerade, dass mein Suchraum der Raum aller Permutationen ist und nicht der Raum aller Tupel!

Bei einem Array der Lönge n (ich betrachte hier nur eine Permutation) ist es doch so, dass lediglich der (n! / n^n) -te Anteil aller durch das Array darstellbaren Punkte auch Punkte meines Suchraums darstellen. Bsp n = 3: (1,1,1) gehört nicht dazu, (2,1,3) gehört dazu etc.

Die Idee mit dem Baum finde ich toll. Angenommen ich halte einen Baum vor, der so aussieht:

.          Start 
    /        |       \
    1        2       3
   /\       /\       /\
   2 3     1 3      1 2
  |  |     |  |     |  |
  3  2     3  1     2  1

Dann genügt es eine Permutation als Pfad des Baumes darzustellen? Hast du das so gemeint?

Grüße

Casiopaya