BruteForce Ansatz implementieren

Bitte aktiviere JavaScript!
Hi Leute,

ich habe elektrische Lastprofile (Zeitreihen) von 10 verschiedenen Haushalten. Zu jedem Haushalt gibt es 5 verschiedene Profile. Ich würde jetzt gerne all diese Profile miteinander kombinieren (d.h. die Werte für jeden Zeitpunkt von allen Profilen addieren), sodass ich insgesammt 5^10 verschiedene zusammengesetzte Profile habe, die ich dann bewerten will.

Meine Frage ist jetzt, wie man soetwas "elegant" programmiern kann. Man könnte natürlich 10 verschachtelte for-Schleifen benutzten. Jedoch wollte ich mal fragen, ob das auch etwas schöner geht. Hat jemand von euch eine Idee? Ich würde mich über eine Antwort sehr freuen.
 
Ich komm grad erst von der Arbeit und bin noch nicht wieder ganz aufnahmefähig ;), aber willst du ein kartesisches Produkt der Profile habe? Das würde mit Guava ziemlich leicht gehen:

Java:
Set<String> s1 = Set.of("a", "b", "c");
Set<String> s2 = Set.of("d", "e", "f");
Set<String> s3 = Set.of("g", "h", "i");

Set<List<String>> combinations = Sets.cartesianProduct(s1, s2, s3);
System.out.println(combinations);
 
Danke Tarrew für deine Antwort. Wie kann ich denn Guava integrieren? Ich habe auf https://github.com/google/guava eine Zip-Datei heruntergeladen. Ich benötige doch ein .jar Datei, wenn ich externe Bibliotheken einbinden will (Sorry für die Frage, aber ich kenne mich mit dem Einbinden von externen Bibliotheken nicht aus).
 
Wie muß man sich denn so ein Profil vorstellen?

Und du hast nicht 5^10 Profile, sondern 5*10. Das ist ein kleiner, feiner Unterschied. Und du brauchst nicht 10 verschachtelte For-Schleifen, sondern nur zwei. Drei, wenn du nochmal in einer Schleife über ein Profil iterieren willst.

Was die elefanteste Methode ist...das kommt auf deine restliche Implementierung an, drei for-Schleifen finde ich jetzt aber auch nicht verwerflich.
 
Danke Tarrew für deine Antwort. Wie kann ich denn Guava integrieren? Ich habe auf https://github.com/google/guava eine Zip-Datei heruntergeladen. Ich benötige doch ein .jar Datei, wenn ich externe Bibliotheken einbinden will (Sorry für die Frage, aber ich kenne mich mit dem Einbinden von externen Bibliotheken nicht aus).
Wenn du du bspw. ein Maven-Projekt hast, kannst du die Dependency einfach zur pom.xml hinzufügen:
<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>28.0-jre</version>
</dependency>
Ansonsten kannst du hier auch die .jar runterladen, die kannst du dann manuell zum Build-Path hinzufügen. Das sollte mit jeder IDE relativ leicht möglich sein.
 
Java:
import java.util.Arrays;
import java.util.Random;

public class Test {

    public static void main(String[] args) {
        Random rand = new Random(1L);
        int haushalte = 10;
        int profile = 5;
        int werte = 24;

        int[][][] zeitreihen = new int[haushalte][profile][werte];
        
        // fiktive Ausgangsdaten generieren
        for (int h = 0; h < haushalte; h++) {
            System.out.println("Haushalt " + h);
            for (int p = 0; p < profile; p++) {
                for (int w = 0; w < werte; w++) { 
                    zeitreihen[h][p][w] = rand.nextInt(20);
                }
                System.out.println("    Profil " + p + ": " + Arrays.toString(zeitreihen[h][p]));
            }
        }

        int[][] aggregation = new int[haushalte][werte];
        for (int h = 0; h < haushalte; h++) {
            System.out.println("Haushalt " + h);
            for (int p = 0; p < profile; p++) {
                for (int w = 0; w < werte; w++) { 
                    aggregation[h][w] += zeitreihen[h][p][w];
                }
            }
            System.out.println("    Werte (aggregiert) " + Arrays.toString(aggregation[h]));
        }
    }
}
 
Noch keine Ahnung, was du vor hast... aber
<dependency>
<groupId>com.github.dpaukov</groupId>
<artifactId>combinatoricslib3</artifactId>
<version>3.3.0</version>
</dependency>
Java:
	public static void main(String[] args) {
		int[] haushalte = new int[10];
		int[] profile = new int[5];
		int[] werte = new int[24];
		for (int i = 0; i < haushalte.length; i++) {
			haushalte[i] = (i + 1) * 10;
		}
		for (int i = 0; i < profile.length; i++) {
			profile[i] = (i + 1) * 2;
		}
		for (int i = 0; i < werte.length; i++) {
			werte[i] = (i + 1);
		}
		ArrayList<Integer> la = new ArrayList<Integer>();
		ArrayList<Integer> lb = new ArrayList<Integer>();
		ArrayList<Integer> lc = new ArrayList<Integer>();
		for (int i : haushalte) {
			la.add(i);
		}
		for (int i : profile) {
			lb.add(i);
		}
		for (int i : werte) {
			lc.add(i);
		}
		Generator.cartesianProduct(la, lb, lc).stream().forEach(System.out::println);
		System.out.println( Generator.cartesianProduct(la, lb, lc).stream().count());
	}

Und es sind nur 10*5*24 = 1200 kombinationen/kartesische Produkte!
 
Hi Leute,

ich habe elektrische Lastprofile (Zeitreihen) von 10 verschiedenen Haushalten. Zu jedem Haushalt gibt es 5 verschiedene Profile. Ich würde jetzt gerne all diese Profile miteinander kombinieren (d.h. die Werte für jeden Zeitpunkt von allen Profilen addieren), sodass ich insgesammt 5^10 verschiedene zusammengesetzte Profile habe, die ich dann bewerten will.
Was meinst du mit kombinieren? Da scheint ja ein gewisses Unverständnis zu herrschen:
Und es sind nur 10*5*24 = 1200 kombinationen/kartesische Produkte!
Und du hast nicht 5^10 Profile, sondern 5*10. Das ist ein kleiner, feiner Unterschied.
So wie ich das verstehe, geht es dir um die Kombination der 5 Profile je Haushalt für alle 10 Haushalte.
Für zwei Haushalte wäre das sowas wie {(P_1_1, P_2_1), (P_1_1, P_2_2), (P_1_1, P_2_3), (P_1_1, P_2_4), (P_1_1, P_2_5), (P_1_2, P_2_1), ...}, was am Ende wirklich auf 5^10 hinauslaufen würde
 
Du kommst doch aus der Ecke - was macht man mit solchen Lastprofilen?
Z.B. den Energiebedarf im vorraus abschätzen und Kraftwerke entsprechend regeln. Wenn du weißt das zur Mittagszeit alle ihre Mikrowelle/Herd/Wasserkocher/... anwerfen um sich was zu Futtern zu machen, dann kannst du schon Stunden vorher ordentlich Kohle in den Ofen schaufeln, damit pünktlich genug Dampf auf dem Kessel ist.
Wenn du das nicht weißt gibt es Ärger: Nicht genug Dampf -> nicht genug Drehmoment am Turbogeneratorsatz -> Generator dreht langsamer -> Netzfrequenz sinkt -> Kraftwerk wird notabgeschaltet -> in Deutschland wirds dunkel. (Stark verkürzzt geschrieben.)

Das errechnet man aber aus den Lastprofilen ganzer Regionen, die Daten kommen dann nicht von den einzelnen Haushalten, sondern zentral vom Umspannwerk oder so.

Mit den Lastprofilen einzelner Haushalte kann man andere Dinge machen, z.B. auf bestimmte Lebensumstände oder Gewohnheiten schließen:
-Wieviele Persone leben etwa im Haushalt
-Wieviele Personen davon gehen arbeiten
-Waren die Bewohner im Urlaub
-Ein oder mehrere Bewohner sehen gerade Film XYZ. (Kein Witz: https://www.heise.de/security/meldung/Smart-Meter-verraten-Fernsehprogramm-1346166.html )

Aber was PetBe damit anfangen will, würde mich auch mal sehr interessieren. :)


Aber auch für die Summe bräuchte man doch erstmal alle Möglichkeiten von Profilen zum Zeitpunkt X?
Ich hab im ersten Moment an etwas Arrayartiges gedacht, und diese addieren will, so etwa:
Code:
 a[0] a[1] a[2] ...
+b[0] b[1] b[2] ...
-------------------
 c[0] c[1] c[2] ...
Aber wie gesagt - nur geraten.
 
Licht ist ja nicht daß Einzige im Haushalt, was elektrische Energie verkonsumiert. Wenn z.B. den ganzen Tag der Fernseher oder Rechner läuft ergibt sich schon ein anderes Bild, als wenn tatsächlich niemand da ist. Auch eine Waschmaschine läßt sich von solchen Geräten ganz gut unterscheiden.
 
Hi zusammen und vielen Dank für die vielen Antworten,
also es geht tatsächlich darum alle möglichen Profile von den haushalten miteinander zu kombinieren, was 5^10 Kombinationen sind. Jeder Haushalt hat 5 verschiedene mögliche Profile, je nachdem wann bestimmte elektrische Vebraucher benutzt werden. Ich würde jetzt gerne alle möglichen Kombinationen bilden und dann für jeder Kombination die gesamte Last der 10 Haushalte berechnen (das meinte ich mit addieren). Die Lastprofile sind Zeitreichen mit einer Auflösung von 5 minuten. Pro Tag gibt es somit 288 Einträge. Für jeden dieser 288 Einträge sollen die Lastwerte der einzelnen Haushalte addiert werden, je nachdem welches Profil verwendet wird. Am Ende habe ich tatsächlich 5^10 verschiedene Gesamtlastprofile und will analysieren, wann die maximale Last am kleinsten ist.
 
Ich habe sie von einer CSV Datei eingelesen und in einem 3-dim Array gespeichert:
Code:
double [][][] loadProfiles = new double [numberOfBuildings] [numberOfDiverseProfiles] [numberOfTimeSlots];
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben