Problem: code too large - bitte um Hilfe

[mzm]

Hallo,

ich arbeite an meiner Abschlussarbeit und soll eine Tourenplanung erstellen, also kein Programm, sondern nur einen Plan. Da der Umfang aber zu groß ist um es händisch zu "optimieren", wollte ich eine Software nutzen, aber da ist kein rankommen.

Durch Zufall bin ich auf eine Programmbibliothek zur Optimierung von VR Problemen gestossen.

Nun habe ich eine Testversion der Programmbibliothek und Beispiele für Java und komme damit soweit zurecht, bin aber kein Java Programmierer.

Nun aber mein Problem.
Durch die Erweiterung der Daten, ich habe die Distanzmatrix und die Zeitmatrix auf jetzt 83 Zeilen und 83 Spalten vergrößert, tritt nun folgendes Problem auf.

C:\>javac JOpt/SDK/Tests/Test_2_07b.java
JOpt\SDK\Tests\Test_2_07b.java:1082: code too large for try statement
     } catch (Exception ex)
       ^
JOpt\SDK\Tests\Test_2_07b.java:16: code too large
  public Test_2_07b()
         ^
2 errors

Kann mir dabei jemand helfen, ich wäre euch sehr dankbar. Ich komme damit leider nicht weiter.
Ich habe auch schon google und die Forensuche genutzt, bin aber nicht schlau daraus geworden, bzw. weiß nciht genau wie ich das Problem beheben kann.

Bitte um Antworten.
Ich kann dann auch Code posten, wollte jetzt nur nicht den gesammten Datei Inhalt posten.

Gruß
Marcus

 

[Murray]

In Java gibt es bestimte Beschränkungen bzgl. des Umfangs, den eine Methode haben kann. Diese sind bei halbwegs vernünftiger Programmierung aber kaum zu überschreiten.

Ich gehe mal davon aus, dass Du einen Code-Generator verwendest. Dieser scheint in Deinem Fall zu großen Code zu produzieren, was man wohl als Fehler werten könne. Insoferm solltest Du Dich an den
Hersteller des Generators wenden.

 

[mzm]

Hi,

also einen Code Generator verwende ich nicht.
Ich habe Dateien im .java Format bekommen und diese bearbeite ich mit dem Editor, danach nutze ich die Windows Console um die Datei zu kompilieren und dann auszuführen. Als Ausgabe erhalte ich im cmd Fenster nur eine Textausgabe der Tourenberechnung.

package JOpt.SDK.Tests;

import JOpt.SDK.*;
import JOpt.SDK.Implementation.*;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.GregorianCalendar;
import java.util.Calendar;
import java.util.Properties;

public class Test_2_07b extends Optimization
{
  public Test_2_07b()
  {    
    // set up the matrix    
    double[][] matrix = {{ ... 83 zeilen und 83 spalten ... },

    double[][] timematrix = {{ ... 83 zeilen und 83 spalten ...},

this.addDistanceMatrix(matrix); // Einbinden der Distazmatrix 
this.addTimeMatrix(timematrix); // Einbinden der Zeitmatrix 

...

Wenn ich die Distanz und Zeitmatrix mit weniger Werten fülle ist alles ok, aber wenn ich mehr Daten eingebe, kommt es zu der Fehlemeldung aus dem ersten Beitrag.

Hoffe es ist verständlich.

Kann mir jemand helfen wie ich die Matrix vielleicht ausgliedern kann, oder so. Weiß nicht wie ich vorgehen soll um das Problem mit der Beschränkung zu beseitigen.

 

[Purgator]

Vorweg, ich habe keine Ahnung von der Fehlermeldung, da ich sie selber noch nie erlebt habe - oder zuvor von ihr hörte.
Aber nachdem was bisher geschrieben wurde sieht es ja danach aus, als wäre das Problem "nur" das zu viel Text im Konstruktor steht. Dieses Problem kommt zustande, weil dort 2 große Matrizen mit festen Werten initialisiert werden.
Sollte dies der Grund sein, sollte es ja möglich sein die Werte der Matrizen in eine Textdatei zu schreiben.
Die Matrizen selbst werden dann im Konstruktor zuerst mit der Entsprechenden Größe erstellt.
Gefüllt werden sie, indem man mit Schleifen aus der Textdatei die Werte ausliest und in die entsprechende Position in den Arrays setzt.
Denke so könnte man das Problem umgehen, wenn denn wirklich die Anzahl der Zeichen im Konstruktor schuld ist.

 

[musiKk]

Die JVMS bestätigt die bisherigen Vermutungen. Der kompilierte Code einer Methode darf maximal 64k groß sein. Das wird hier wohl überschritten.

 

[tfa]

Das Problem ist wirklich die Definition der Matrizen. In Java werden Array-Initialisierungen in eine Folge "Byte-Code Befehle" übersetzt, d.h. für jeden Wert im Array werden 2 oder 3 Bytecodes benötigt. Ist das Array zu groß, passt der Code nicht mehr in eine Methode. Die Obergrenze ist soweit ich weiß 64kB.

 

[mzm]

Vielen Dank für die schnelle Reaktion auf meine Frage / mein Problem.

Es ist auf jeden Fall diese Beschränkung, das habe ich auch über google zu meiner Fehlermeldung erfahren.

Kann mir jemand dabei helfen wie ich eine Textdatei einbinden kann, also das die Daten ausgelesen werden.
Muss diese Textdatei die Daten wie im java Code enthalten, oder dürfen dort dann keine Klammern "{ }," verwendet werden.
Wie kann ich die Datei auslesen, so dass der vorhandene Java Code damit zurecht kommt, ich habe das nämlich nciht selbst programmiert, sondern nur mit Daten gefüllt und erweitert.
Von der Firma bekomme ich aber leider keinen Support.

Dieses Problem kommt zustande, weil dort 2 große Matrizen mit festen Werten initialisiert werden.
Sollte dies der Grund sein, sollte es ja möglich sein die Werte der Matrizen in eine Textdatei zu schreiben.
Die Matrizen selbst werden dann im Konstruktor zuerst mit der Entsprechenden Größe erstellt.
Gefüllt werden sie, indem man mit Schleifen aus der Textdatei die Werte ausliest und in die entsprechende Position in den Arrays setzt.

Purgator hat wohl die Lösung schon verbal formuliert, jedoch komme ich als nicht "Javaianer" dabei nicht weiter.

Gruß
marcus

 

[VfL_Freak]

Moin,

Grundlagen zum Einlesen von Textdateien gibt es doch im Web zuhauf - einfach mal nach "Java Textdatei lesen" googlen .....
Bspw. dies hier:
Java I/O

Einlesen kannst Du im Prinzip alles, was Du/Dein Programm mit dem eingelesenen Text machst, hängt im Wesentlichen davon ab, was damit konkret passieren soll .....

Gruß
Klaus

 

[Purgator]

Also ich dachte mir das ungefähr so (nur theoretisch durchdacht, nichts ausprobiert):
hast z.b. die Matrix
a = { {3.1, 2.2, 1.3}, {6.4, 5.5, 4.6}, {9.7, 8.8, 7.9}}
diese musst du zuerst in eine Textdatei schreiben (geht ja auch theoretisch per hand, musst dafür also kein Java-Programm schreiben).
Dafür musst du dir natürlich ein Format überlegen, z.B. das eine Zeile in der Textdatei eine Zeile aus der Matrix darstellt und die einzelnen Elemente dort durch ein Trennsymbol getrennt werden.
Wenn du das Semikolon als Trennsymbol nimmst könnte das dann so aussehen:
3,1;2,2;1,3
6,4;5,5;4,6
9,7;8,8;7,9
Deinen Konstruktor musst du nun anpassen:
[Java]
double[][] matrix = new double[83][83];
double[][] timematrix = new double[83][83];
[/code]
somit gibst du den Matrizen erstmal nur eine feste Größe - sie haben jedoch noch nicht den Inhalt.
Damit sie diesen aus der Textdatei erhalten musst du noch folgendes einfügen:
[Java]
try {
BufferedReader in = new BufferedReader(new FileReader("pfad/dateiname"));
String zeile = null;
int i=0;
while ((zeile = in.readLine()) != null) {
String[] zeilenelemente = zeile.split(";");
for(int j=0; j<zeilenelemente.length; j++) {
matrix[j] = zeilenelemente[j];
}
i++;
}
} catch (IOException e) {
e.printStackTrace();
}
[/code]
Das ganze kann noch syntaktische oder andere kleinere Fehler enthalten, ausserdem ist da natürlich die timeMatrix nicht befüllt - aber hoffe vom Prinzip her ist das richtig.
Wichtig dazu ist jedenfalls dass die while-Schleife die Zeilen der Textdatei einzeln ausliest. In i steht immer die aktuelle Zeile.
zeile.split(";") trennt die Zeile in einzelne elemente auf, wobei immer am Semikolon getrennt wird und in der for-Schleife werden die elemente dann dem Array hinzugefügt.

 

[mzm]

Wenn ich das einbaue kommt folgende Meldung:

C:\>javac JOpt/SDK/Tests/Example_tm.java
JOpt\SDK\Tests\Example_tm.java:44: incompatible types
found   : java.lang.String
required: double
                       matrix[i][j] = zeilenelemente[j];
                                                    ^
1 error

Das ist der Code der Datei, aber die Matrizen habe ich verkleinert, sonst wäre das bei 83 zeilen viel zu viel Code. Die Anpassung von Purgator ist auch nicht drinnen.

package JOpt.SDK.Tests;

/*
 * TimeMatrixExample
 *  
 * */

import JOpt.SDK.*;
import JOpt.SDK.Implementation.*;
import java.text.SimpleDateFormat;
import java.util.GregorianCalendar;
import java.util.Calendar;
import java.util.Properties;

public class Example_tm extends Optimization
{
  public Example_tm()
  {
    
    // set up the matrix    
    double[][] matrix = {{0.0,70.0,90.0,45.0,240.0,580.0,440.0,300.0,380.0,40.0,260.0},
                         {70.0,0.0,25.0,65.0,300.0,640.0,500.0,360.0,440.0,35.0,280.0}, 
                         {90.0,25.0,0.0,80.0,305.0,650.0,510.0,370.0,460.0,25.0,270.0},
                         {45.0, 65.0,80.0,0.0,275.0,615.0,475.0,330.0,405.0,80.0,300.0},
                         {240.0,300.0,305.0,275.0,0.0,330.0,300.0,70.0,170.0,280.0,50.0},
                         {580.0,640.0,650.0,615.0,330.0,0.0,140.0,320.0,230.0,620.0,340.0},
                         {440.0,500.0,510.0,475.0,300.0,140.0,0.0,200.0,240.0,480.0,200.0},
                         {300.0,360.0,370.0,330.0,70.0,320.0,200.0,0.0,80.0,330.0,110.0},
                         {380.0,440.0,460.0,405.0,170.0,230.0,240.0,80.0,0.0,405.0,200.0},
                         {40.0,35.0,25.0,80.0,280.0,620.0,480.0,330.0,405.0,0.0,285.0},
                         {260.0,280.0,270.0,300.0,50.0,340.0,200.0,110.0,200.0,285.0,0.0}};

   
    // Zeitmatrix in Sekunden
    double[][] timematrix = {{0,3877,4985,2492,24686,32123,24369,16615,21046,2215,14400},
                         {3877,0,1385,3600,16615,35446,27692,19938,24369,1938,15508},
                         {4985,1385,0,4431,16892,36000,28246,20492,25477,1385,14954},
                         {2492,3600,4431,0,15231,34062,26308,18277,22431,4431,16615},
                         {13292,16615,16892,15231,0,18277,16615,3877,9415,15508,2769},
                         {32123,35446,36000,34062,18277,0,7754,17723,12738,34338,18831},
                         {24369,27692,28246,26308,16615,7754,0,11077,13292,26585,11077},
                         {16615,19938,20492,18277,3877,17723,11077,0,4431,18277,6092},
                         {21046,24369,25477,22431,9415,12738,13292,4431,0,22431,11077},
                         {2215,1938,1385,4431,15508,34338,26585,18277,22431,0,15785},
                         {14400,15508,14954,16615,2769,18831,11077,6092,11077,15785,0}};

     
     this.addDistanceMatrix(matrix);
     this.addTimeMatrix(timematrix);   
    
    
     // 0.) define the weekly opening hours for the nodes we want to visit    
     OpeningHours[] weeklyOpeningHours= new OpeningHours[1];
     weeklyOpeningHours[0] = new OpeningHours(new GregorianCalendar(2007,Calendar.MARCH,6,8,0,0),new GregorianCalendar(2007,Calendar.MARCH,6,18,0,0));
 
     OpeningHours[] weeklyOpeningHoursOberhausen= new OpeningHours[1];
     weeklyOpeningHoursOberhausen[0] = new OpeningHours(new GregorianCalendar(2007,Calendar.MARCH,6,15,0,0),new GregorianCalendar(2007,Calendar.MARCH,6,16,0,0));

    // 1.) add the nodes to be visited 
     TimeWindowGeoNode koeln    = new TimeWindowGeoNode("Koeln", 50.9333,6.95,weeklyOpeningHours,1200,1);
     koeln.setDistMatrixId(0);
     this.addElement(koeln);

     TimeWindowGeoNode oberhausen = new TimeWindowGeoNode("Oberhausen", 51.4667,6.85,weeklyOpeningHoursOberhausen,1200,1);
     oberhausen.setDistMatrixId(1);
     this.addElement(oberhausen);

     TimeWindowGeoNode essen = new TimeWindowGeoNode("Essen",51.45,7.01667,weeklyOpeningHours,1200,1);
     essen.setDistMatrixId(2);
     this.addElement(essen);
         
     TimeWindowGeoNode dueren =  new TimeWindowGeoNode("Dueren",50.8,6.48333,weeklyOpeningHours,1200,1);
     dueren.setOpeningHours(weeklyOpeningHours);   
     dueren.setDistMatrixId(3);
     this.addElement(dueren);

     TimeWindowGeoNode mannheim =  new TimeWindowGeoNode("Mannheim",49.4883,8.46472,weeklyOpeningHours,1200,1);
     mannheim.setOpeningHours(weeklyOpeningHours);   
     mannheim.setDistMatrixId(4);
     this.addElement(mannheim);

     TimeWindowGeoNode muenchen = new TimeWindowGeoNode("Muenchen",48.15,11.5833,weeklyOpeningHours,1200,1);
     muenchen.setDistMatrixId(5);
     this.addElement(muenchen);

     TimeWindowGeoNode nuernberg = new TimeWindowGeoNode("Nuernberg",49.4478,11.0683,weeklyOpeningHours,1200,100);
     nuernberg.setDistMatrixId(6);
     this.addElement(nuernberg);

     TimeWindowGeoNode heilbronn = new TimeWindowGeoNode("Heilbronn",49.1403,9.22,weeklyOpeningHours,1200,1);
     heilbronn.setDistMatrixId(7);
     this.addElement(heilbronn);

     TimeWindowGeoNode stuttgart = new TimeWindowGeoNode("Stuttgart", 48.7667,9.18333,weeklyOpeningHours,1200,1);
     stuttgart.setDistMatrixId(8);
     this.addElement(stuttgart);

     TimeWindowGeoNode wuppertal = new TimeWindowGeoNode("Wuppertal",51.2667,7.18333,weeklyOpeningHours,1200,1);
     wuppertal.setDistMatrixId(9);
     this.addElement(wuppertal);

     // 2.) add the resources 
     WorkingHours[] workingHours= new WorkingHours[1];
     workingHours[0] = new WorkingHours(new GregorianCalendar(2007,Calendar.MARCH,6,8,0,0),new GregorianCalendar(2007,Calendar.MARCH,6,20,0,0));
     
     CapacityResource rep1 = new CapacityResource("Jack",50.1167,7.68333,12.0,1200.0,workingHours);
     rep1.setCost(1000,1,1);
     rep1.setDistMatrixId(10);    
     rep1.setTimeMatrixFactor(1.0); // use a different value to set up individual driving times
     this.addElement(rep1); 

     CapacityResource rep2 = new CapacityResource("John",50.1167,7.68333,12.0,1200.0,workingHours);
     rep2.setCost(1000,1,1);
     rep2.setDistMatrixId(10);    
     rep2.setTimeMatrixFactor(1.0); // use a different value to set up individual driving times
     this.addElement(rep2); 
          
     Properties props = new Properties();
     props.setProperty("JOpt.RouteType","CLOSED");
     props.setProperty("JOptExitCondition.JOptGenerationCount","1000"); // 
     props.setProperty("JOptExitCondition.Type","JOptCostConvergency"); // 
     props.setProperty("JOptExitCondition.JOptConvergencyCount","300");
     props.setProperty("JOptWeight.TotalDistance","100.0"); // 100 = most important
     props.setProperty("JOptWeight.RouteDistance","1.0");
     props.setProperty("JOptWeight.ResourceActive","0.0");
     props.setProperty("JOptWeight.NodeType","1.0");
     props.setProperty("JOptWeight.TimeWindow","100.0"); // 100 = also very important. 
   
     this.addElement(props);     
      // 3.) start the optimization
     try{
      this.startAsynchronousOptimizationRun();    
     } catch (Exception ex)
     {
       System.out.println(ex.getMessage());
     }
  }
  
  public void onAsynchronousOptimizationResult(IOptimizationResult result) 
  {
    if(result == null) 
    {
      return;
    }
    // 4.) read the header
    System.out.println("\n##########################################################");
    System.out.println("NEW OPTIMIZATION RESULT");
    System.out.println("##########################################################");
    System.out.println("costfunction       : " + result.getTotalCost());
    System.out.println("total route time   : " + result.getTimeTotal()/3600.0 + " [h]");
    System.out.println("total driving time : " + result.getTimeTrip()/3600.0 + " [h]");
    System.out.println("total service time : " + result.getTimeStop()/3600.0 + " [h]");
    System.out.println("total idle time    : " + result.getTimeIdle()/3600.0 + " [h]");
    System.out.println("total break time   : " + result.getTimeBreak()/3600.0 + " [h]");
    System.out.println("total distance     : " + result.getTotalDistance()/1000.0 + " [km]");
    
    // 5.) iterate through each tour
    for(int i = 0; i < result.getRoutes().length; i++){
     System.out.println("\n-----------------------------------------------------------");
     System.out.println("Route information");
     System.out.println("Route:" + result.getRoutes()[i].getRouteId() + " resource scheduled: " + 

result.getRoutes()[i].getResourceId());
     System.out.println("-----------------------------------------------------------");
     System.out.println("route time   : " + result.getRoutes()[i].getTimeTotal()/3600.0 + " [h]");
     System.out.println("driving time : " + result.getRoutes()[i].getTimeTrip()/3600.0 + " [h]");
     System.out.println("service time : " + result.getRoutes()[i].getTimeStop()/3600.0 + " [h]");
     System.out.println("idle time    : " + result.getRoutes()[i].getTimeIdle()/3600.0 + " [h]");
     System.out.println("break time   : " + result.getRoutes()[i].getTimeBreak()/3600.0 + " [h]");
     System.out.println("distance     : " + result.getRoutes()[i].getTotalDistance()/1000.0 + " 

[km]");
      for (int k = 0; k < result.getRoutes()[i].getViolations().length; k++)
      {
          IViolation violation = result.getRoutes()[i].getViolations()[k];
          IAttributeValuePair avp = (IAttributeValuePair)violation;
          System.out.println(" [" + avp.getCategory() + "/" + avp.getAttribute() + "/" + 

avp.getValue() + "]");
      }
     
     SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss");    
     for(int j = 0; j < result.getRoutes()[i].getRouteNodes().length; j++){
        IScheduledNode scheduledNode = result.getRoutes()[i].getRouteNodes()[j];
 
        System.out.print("\n" 
          + result.getRoutes()[i].getRouteId() + "." 
          + scheduledNode.getSequenceNumber() + " " 
          + scheduledNode.getNodeId() 
          + " arrival time: " 
          + sdf.format(scheduledNode.getArrivalTime().getTime())
          + " driving time: " + scheduledNode.getTimeDrive()/3600.0 +" [h]");
          
          for(int k = 0; k < scheduledNode.getViolations().length; k++){
            IViolation violation = scheduledNode.getViolations()[k];
            if(violation instanceof IAttributeValuePair)
            {
             IAttributeValuePair avp = (IAttributeValuePair) violation;
             System.out.print(" [" + avp.getCategory() + "/" + avp.getAttribute() + "/" + 

avp.getValue() + "]");             
            }
          }    
      }
      System.out.println("\n\n"); 

    }
  }
  
  public void onProgress(double progress, double totalDistance, double cost)
  {
    System.out.println("Progress: " + progress + "% Total Distance: " + totalDistance/1000 + "km 

Cost: " + cost);
  } 

  /**
   * 
   * @param args
   */
  public static void main(String[] args)
  {
    Example_tm Example_tm = new Example_tm();
  }
}

 

[Landei]

Da du double-Matrizen hast, musst du die Strings aus der Textdatei noch umwandeln, etwa [c]matrix[j] = Double.parseDouble(zeilenelemente[j]);[/c]

 

[Purgator]

Das ist eines der kleineren möglichen Probleme die ich gemeint habe .
Aber die Fehlermeldung zeigt ja auch schon wo das Problem ist.
Ich kenne deine allgemeine Programmiererfahrung nicht, aber in Java kann man z.B. einer Zahl nicht einfach eine Zeichenkette zuweisen... auch wenn diese nur aus Zahlen besteht.
Nun zum Fehler:
C:\>javac JOpt/SDK/Tests/Example_tm.java
--> sagt in welcher Datei der Fehler auftritt
JOpt\SDK\Tests\Example_tm.java:44: incompatible types
--> sagt dir das der Fehler in Zeile 44 gefunden wird und das er ein Problem mit inkompatiblen Typen hat
found : java.lang.String
required: double
--> sagt dir das er einen String (Zeichenkette) hat und eigentlich ein double (Fließkommazahl) braucht

Wir müssen also versuchen die Zeichenkette in eine Fließkommazahl umzuwandeln, dazu:

try {
matrix[i][j] = Double.parseDouble(zeilenelemente[j]);
} catch(NumberFormatException e) {
//hier schreiben was du tun willst, wenn du einen String findest den du nicht in einen Double umwandeln kannst
}

 

[mzm]

Hi Purgator,

nachdem ich das von Landei genannte

Da du double-Matrizen hast, musst du die Strings aus der Textdatei noch umwandeln, etwa [c]matrix[j] = Double.parseDouble(zeilenelemente[j]);[/c]

in deinen Code integriert habe

double[][] timematrix = new double[11][11];

try {
        BufferedReader in = new BufferedReader(new FileReader("C:/JOpt/SDK/Tests/zeitmatrix.txt"));
        String zeile = null;
        int i=0;
        while ((zeile = in.readLine()) != null) {
                   String[] zeilenelemente = zeile.split(";");
                   for(int j=0; j<zeilenelemente.length; j++) {
                       timematrix[i][j] = Double.parseDouble(zeilenelemente[j]);
                   }
                   i++;
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

funktionierte es ohne Fehlermeldung.

Habe gerade einen Test mit einer kleinen Matrix gemacht und mit dem vorherigen Ergebnis verglichen. So wie es aussieht rechnet er genau das gleiche.
Also sollte doch das Auslesen der Datei nun richtig funktionieren.

Hoff ich doch

Auf jeden Fall schon mal vielen vielen Dank für die schnelle und gute Hilfe.