Methoden Formel besser implementieren

[Shizmo]

Hallo, ich versuche die Formel die im Anhang ist zu implementieren.
Das habe ich auch bereits gemacht, allerdings extrem ineffizient. Hat jemand eine Idee wie ich die doppelte-Schleife loswerde? Ideal wäre so effizient wie möglich, weights ist eine Hashmap, als Key ein Integer und Value ein Double (das Gewicht, zwischen 0 und 1) und x eine Integer-ArrayList.

private int length(List<Integer> x) {
    double totalWeight = sigma(x);
    double subWeight;

    for (int j = 1; j < x.size(); j++) {
      subWeight = 0;
      for (int i = 0; i < j; i++)
        subWeight = weights.containsKey(x.get(i)) ? weights.get(x.get(i)) : 1;

      if ((totalWeight - subWeight) / (totalWeight + subWeight) < threshold)
        return j;
    }
    return x.size();
  }

private double sigma(List<Integer> x) {
    double weight = 0;
    for (Integer t : x)
      weight += weights.containsKey(x) ? weights.get(x) : 1;

    return weight;
  }

 

[JCODA]

subWeight wird immer überschrieben. Sollte hier addiert werden?
Speichere die Teilsumme außerhalb der forschleife, so musst du innerhalb nur einen Wert addieren um die Überprüfung zu machen.

 

[truesoul]

Hallo.

Diese Zeile stimmt so nicht :

weight += weights.containsKey(x) ? weights.get(x) : 1;

Da solltest du t verwenden anstatt x.

 

[Shizmo]

Danke für eure Tipps, ja das stimmt.
Aber kann man sich nicht irgendwie die Schleifen sparen? Eventuell mit einer Minimums-Funktion oder sonstiges?

 

[JCODA]

Vielleicht so?

private int length(List<Integer> x) {
    double totalWeight = sigma(x);
    double subWeight = 0;

    for (int j = 1; j < x.size(); j++) {
      subWeight += weights.containsKey(x.get(j)) ? weights.get(x.get(j)) : 1;

      if ((totalWeight - subWeight) / (totalWeight + subWeight) < threshold){
        return j;
      }
    }
    return x.size();
  }

 

[Shizmo]

Vielen Dank, sollte passen oder? Da ich ja sowieso das kleinste j suche, muss ich ja nicht alle durchprobieren (wie vorher), richtig? Ich hab die Formel vorher falsch verstanden, ich dachte ich brauch den kleinsten Wert und von diesem dann das j. Aber richtig ist das kleinste j für einen Wert < t, stimmts? Oder habe ich mich jetzt selbst verwirrt?

 

[Shizmo]

Hmm nein, ich glaub das stimmt doch nicht, so wie ich das geschrieben habe wäre es ja das kleinste i, ich suche aber das kleinste j und das kann ja von 0 bis x.size()-1 sein und dann muss man schon alles durchgehen oder?

 

[fhoffmann]

und dann muss man schon alles durchgehen oder?

Nein; das kleinste j ist das erste j, das die Bedingung erfüllt.

 

[Shizmo]

Ahhh ja, dann sollte die Implementierung von JCODA passen, richtig?