Bandbreitenoptimierung für Matrizen

[Bjoerk]

Ich habe eine Indextabelle (IndexOfU), die folgendermaßen aufgebaut wird:

Delphi-Quellcode:

procedure TFrame.GrowNU(const Index: integer); // Anzahl Unbekannte;
begin
  Inc(FNU);
  FIndexOfU[Index] := FNU;
end;

procedure TFrame.GrowNV(const Index: integer); // Anzahl Auflagergleichungen;
begin
  FIndexOfU[Index] := FN - FNV; // N = DG * Nodes.Count;
  Inc(FNV);
end;

procedure TFrame.CalcIndexOfU;
var
  I, J, Index: integer;
begin
  for I := 1 to FNodes.Count do
    for J := 1 to FDG do // Ebenes Stabwerk 3, Räumliches 6, Ebenes Fachwerk 2, Räumliches 3;
    begin
      Index := FDG * (I - 1) + J;
      if J = 1 then
        if not FNodes.Item[I].Fest.vX then
          GrowNU(Index)
        else
          GrowNV(Index);
      if J = 2 then
        if not FNodes.Item[I].Fest.vY then
          GrowNU(Index)
        else
          GrowNV(Index);
      if FD = 3 then // Räumlich;
      begin
        if J = 3 then
          if not FNodes.Item[I].Fest.vZ then
            GrowNU(Index)
          else
            GrowNV(Index);
        if not FSyst then // Stabwerk;
        begin
          if J = 4 then
            if not FNodes.Item[I].Fest.pX then
              GrowNU(Index)
            else
              GrowNV(Index);
          if J = 5 then
            if not FNodes.Item[I].Fest.pY then
              GrowNU(Index)
            else
              GrowNV(Index);
          if J = 6 then
            if not FNodes.Item[I].Fest.pZ then
              GrowNU(Index)
            else
              GrowNV(Index);
        end;
      end
      else
        if not FSyst and (J = 3) then // Ebenes StabwerK;
        begin
          if not FNodes.Item[I].Fest.pZ then
            GrowNU(Index)
          else
            GrowNV(Index);
        end;
    end;
end;

Nun soll IndexOfU im Bereich 1..NU so "gemischt" werden, so daß NB möglichst klein wird.

Delphi-Quellcode:

procedure TFrame.SimulateLoad(const T1, T2: integer);
var
  k1, k2, i1, i2, Row, Col: integer;
begin
  i1 := FDG * (T1 - 1);
  i2 := FDG * (T2 - 1);
  for k1 := 1 to FDG do
  begin
    Row := FIndexOfU[i1 + k1];
    if Row <= FNU then
      for k2 := 1 to FDG do
      begin
        Col := FIndexOfU[i2 + k2];
        if (Col >= Row) and (Col <= FNU) then
          FNB := Max(FNB, Col - Row + 1);
      end;
  end;
end;

procedure TFrame.CalcNB; // Bandbreite;
var
  I: integer;
begin
  FNB := 0;
  repeat ***
    FIndexOfU := ..
    for I := 1 to FElements.Count do
    begin
      SimulateLoad(FElements.Item[I].Left, FElements.Item[I].Left);
      SimulateLoad(FElements.Item[I].Right, FElements.Item[I].Right);
      SimulateLoad(FElements.Item[I].Left, FElements.Item[I].Right);
      SimulateLoad(FElements.Item[I].Right, FElements.Item[I].Left);
    end;
  until FB möglichst klein; ***
end;

Verstanden was ich meine? Kennt jemand ein Prinzip, nach welchem man NB iterieren könnte (außer Zufallslisten)? BTW, bitte nicht wundern, ist alles 1 basiert.