algorythmus für den Zuschnitt von Dachplatten

[sanktusm]

Hallo,
ich habe Platten von 3000, 4000, 5000 und 6000 mm, deren Zuschnitt berechnet werden soll, um minimalen Verschnitt zu garantieren:

Folgendes Script funktioniert bei Anzahl von Längen unter 2500 mm bis zu 3 - 4 Stück:

Wenn ich also 3 - 1600 mm Platten aus den Standardlängen erhalten will, brauche ich für insgesamt 4800 mm als eine Platte von 5000 mm. Nun will ich errechnen, dass wenn ein Kunde 6 x 1600 mm haben will 2 x 5000 mm herauskommt und bei 9 x 1600 mm 3 x 5000.

Ein anderes Zenario ist: 3 x 900 mm. Dann brauche ich eine 3000 mm Platte. bei 6 x 900 mm 2 x 3000 usw. Kann mir jemand einen Tipp geben, wie ich das hinbekomme?

$z_ass_sheets ist Array(3000' => '30', 4000' => '40',5000' => '50', 6000' => '60')

$chosenArr[$key] = 900 bwz. 1600

foreach($z_ass_sheets as $length => $price) {

    if($length > ($data['anzahl_z_ass'][$key] * $chosenArr[$key])) {


      $anzahl_sheets =  1;

      $schnitt_temp = 0;

      $schnitt_temp = $data['anzahl_z_ass'][$key];


      $out_collect = "<tr><td>".$length." mm - 12y (für ".$data['anzahl_z_ass'][$key]." x ".$chosenArr[$key]. " mm, ".$schnitt_temp." Schn.)</td><td>".$anzahl_sheets."</td><td>".$chosenArr[$key]." mm</td><td>€ ".number_format($priceArr[$length], 2)."</td><td>€ ".number_format(($priceArr[$length] * $anzahl_sheets), 2)."</td></tr>";






      break;



      }

    }

  }



      }

    }

  } 

[kaminbausatz]

Das ist nicht so trivial, wie es sich anhört.

Ausführlich wird es hier beschreiben... https://de.wikipedia.org/wiki/Eindim...schnittproblem

[tomBuilder]

Da dies (Schul-) Aufgabe, sondern ein reales Problem eines Dachdeckers ist, und es so viel mehr zu bedenken gibt:
https://www.profilbleche.net/dachplaner

[sanktusm]

Hallo,
ein Freund hat mir dieses python script geschrieben, das ich nun in php realisieren will. Leider funktioniert es noch nicht richtig, kann mir jemand weiterhelfen?

//python ist

# -*- coding: utf-8 -*-
"""
Created on Wed Apr  1 09:52:19 2020
Hier wird sicher nicht die global beste Lösung gefunden, aber eine die  
wahrschienlich auch ganz OK ist. Die optimale Lösung aus dem Skript "cutting_stock.py"  
mittels mip modul  
aus https://python-mip.readthedocs.io/en/latest/examples.html  
ist sicher besser (mit nur einer Vorratslänge), aber nicht selber geschwind zu implementieren.
Hier wird Platte für Platte geprüft wie man sie zerlegen kann, um möglichst wenig Verschnitt  
in der platte zu haben. Es werden alle zur Verfügung stehenden Vorrats-Platten
im Auge behalten. Es wird also jeweils pro Platte das Optimum gesucht, insgesamt ergibt sich aber
ein gutes Ergebnis. Die Beste Zerlegung pro Platte wird dabei durch Probieren aller Varianten erreicht.
Bei großen Zahlen kann das hohe Refchenzeiten erfordern -> sollte abgefangen werden.  
Das durchprobieren aller möglicher Zerlegungen geschieht durch Rekusive Programmierung  
"""
import numpy as np
import sys


gw_L  = np.array([1.6, 1.2, 2.5, 2.7]) #vom Kunden gewuenschte Laengen, Beispielzahlen
gw_NL = np.array([6,4,7,11],dtype=int)      #vom Kunden gewuenschte Anzahl der Laengen, Beispielzahlen
st_L  = np.array([3, 4, 5, 6])       #Vorrat an vorhandenen Laengen in theoretisch unbegrentzter Anzahl, Beispielzahlen

n_rekursiv = len(gw_L)-1    
rest=10
kombination=np.zeros(n_rekursiv+1)
k_glob=np.copy(kombination)
r_glob=rest

orig_stdout = sys.stdout
f = open('out.txt', 'w')
sys.stdout = f

#erst prüfen ob alle vom Kunden gewuenschten Laengen kleiner sind als die maximal verfügbare  
#Laenge im Vorrat, sonst Fehlermeldung und Abbruch des Programms:
if max(gw_L)>max(st_L):
    print("Es kann keine Platte der Breite:",max(gw_L), "bestellt werden")
    quit()


def eine_gewuenschte_Laenge_dazufuegen_und_pruefen(index,delta,L,gw_NL,gw_L,n_rekursiv): #definition der rekursiven Funktion  
#    print("hallo")
    global rest          #aktueller rest bei aktueller Zerlegung der Vorratsplatte
    global kombination   #aktuelle Zerlegung der Vorratsplatte
    global r_glob        #derzeit bester/kleinster rest bei bester Zerlgung
    global k_glob        #derzeit beste Zerlegung  
    i=0                            #laufindex von 0 bis zur vom Kunden gewünschten Anzahl an platten gw_NL[index]  
    while i <= gw_NL[index] :
        kombination[index] = i
        # print(" ")
        # print("schleife startet")
        # print("index: ",index)
        # print("  i: ",i)
        # print("kombi: ", kombination, " k_glob: ",k_glob)
        if(index<n_rekursiv ):                   #Aufruf der rekursiven Funktion bis die "tiefste Ebene"(=Länge des Arrays gw_L/gw_NL) erreicht ist
#            print("eintauchen in tiefere index-Ebene")
            eine_gewuenschte_Laenge_dazufuegen_und_pruefen(index+1,delta,L,gw_NL,gw_L,n_rekursiv) #rufe rekursive Funktion auf
        else:                                    #wenn tiefste Ebene erreicht ist  (= die Anzahlen aller gewünschten Längen festgelegt ist) kann der verschnitt für diese Kombination berechnet werden  
            rest=10                              #Wähle irgendeine große Start Zahl  
            for s in delta:                      #Schleife über alle verschnitte, d.h für jede Verfüghbare Vorratsplattenlänge
                if s>=0 and rest>s:              # nur Verschnitte die positiv sind spielen mit negative Werte werden abgefangen  
                    rest = s                     #nimm den rest der Platte die den kleinsten Verschnitt hat      
#            print("rest: ",rest," r_glob: ",r_glob)
            if(rest<r_glob ):                   #wenn die aktuelle Kombination einen kleinen Verschnitt liefert als der bisherige Bestwert, nehme diese Kombination als neue Bestkonfiguration    
                # print("setze rest"," index: ", index, " i: ",i)
                # print("delta: ", delta)
                # print("rest, r_glob: ",rest,r_glob)
                # print("verbrauchte Länge " ,L)
                # print("Erste Platte so aufgeteilt:", kombination[0],"*",gw_L[0]," ", kombination[1],"*",gw_L[1]," ", kombination[2],"*",gw_L[2])
                k_glob = np.copy(kombination)
                r_glob = rest
#        print("k_glob: ",k_glob," r_glob: ", r_glob)
        L = L+gw_L[index]                                #versuche noch eine gewünschte Platte der Länge gw_L[index] "anzuhängen"->bisherige gesamtlänge
#        print(" L: ", L," index: ", index, " i: ",i)
        delta = delta - gw_L[index]                       #versuche noch eine gewünschte Platte der Länge gw_L[index] "anzuhängen"->bisherige verschnitt delta reduziert sich weiter
#        print(" delta: ",delta," rest ",rest)
        i = i + 1                                       #schleifenindex hochzählen
#    print("rückkehr zur höheren index-Ebene")
#    print()

#Nun wird Laenge für Laenge aus dem Vorrat geschaut was am  
#besten passen würde in eine 3m Laenge, 4m LAenge, 5m LAenge oder 6m Laenge
gw_NL_tmp = gw_NL

while(sum(gw_NL_tmp)>0):                                                  #schleife über alle benötigten Vorrats-Platten
    print('Noch benötigte Stücke: ',gw_NL_tmp, "der Längen: ",gw_L)
#    ist_fertig = False
    L = 0.0  #bisherige Länge der aneinander gehängten wunschplatten für diese Vorratsplatte
    delta = st_L    #bisheriger Verschnitt an dieser Vorratsplatte->array
    eine_gewuenschte_Laenge_dazufuegen_und_pruefen(0,delta,L,gw_NL_tmp,gw_L,n_rekursiv)#probiere alle Möglichkeiten aus und finde die beste Zerlegung der nächstzen Vorratsplatte
    print("gewählte Platte:",sum(k_glob*gw_L)+r_glob )                               #Nehme diese Vorratsplatte
    print("rest: ",r_glob," Zerlegung der Vorratsplatte: ", k_glob )                 #zerschniede sie auf diese Weise  
    print()
    gw_NL_tmp = gw_NL_tmp - k_glob                                                   #k_glob Teile konnten aus dieser Vorratsplatte ausgeschnitten werden, die noch offenen Platten reduzieren sich um diene Anteil
    rest=10                                                          #Setze beliebigen hohen Startwert
    kombination=np.zeros(n_rekursiv+1)                               #Neusetzen der Variabeln: null Teile jeder Länge für lokale Kombination
    k_glob=np.copy(kombination)                                      #Neusetzen der besten Kombination mit dem geringsten Verschnitt    
    r_glob=rest 

php mit Fehler :
Warning: Invalid argument supplied for foreach() in /opt/lampp/htdocs/to/index.php on line 6
ist

<?php


function arrayCopy($array) {
        $result = array();
        foreach( $array as $key => $val ) {
            if( is_array( $val ) ) {
                $result[$key] = arrayCopy( $val );
            } elseif ( is_object( $val ) ) {
                $result[$key] = clone $val;
            } else {
                $result[$key] = $val;
            }
        }
        return $result;
}

$gw_L  = Array(1.6, 1.2, 2.5, 2.7); #vom Kunden gewuenschte Laengen, Beispielzahlen
$gw_NL = Array(6,4,7,11);      #vom Kunden gewuenschte Anzahl der Laengen, Beispielzahlen
$st_L  = Array(3, 4, 5, 6);       #Vorrat an vorhandenen Laengen in theoretisch unbegrentzter Anzahl, Beispielzahlen

$n_rekursiv = count($gw_L)-1;
$rest = 10;
$kombination= sprintf($n_rekursiv+1);
$k_glob=arrayCopy($kombination);
$r_glob=$rest;

$index = 0;



#erst prüfen ob alle vom Kunden gewuenschten Laengen kleiner sind als die maximal verfügbare
#Laenge im Vorrat, sonst Fehlermeldung und Abbruch des Programms:
if (max($gw_L)>max($st_L)):
    print("Es kann keine Platte der Breite:".max($gw_L)."bestellt werden");
    quit();
endif;

function eine_gewuenschte_Laenge_dazufuegen_und_pruefen($index,$delta,$L,$gw_NL,$gw_L,$n_rekursiv) { #definition der rekursiven Funktion
#    print("hallo")
    global $rest;          #aktueller rest bei aktueller Zerlegung der Vorratsplatte
    global $kombination;   #aktuelle Zerlegung der Vorratsplatte
    global $r_glob;        #derzeit bester/kleinster rest bei bester Zerlgung
    global $k_glob;        #derzeit beste Zerlegung
    $i=0;                            #laufindex von 0 bis zur vom Kunden gewünschten Anzahl an platten gw_NL[index]
    while ($i <= $gw_NL[$index]):
        $kombination[$index] = $i;
        # print(" ")
        # print("schleife startet")
        # print("index: ",index)
        # print("  i: ",i)
        # print("kombi: ", kombination, " k_glob: ",k_glob)
        if($index<$n_rekursiv ):                   #Aufruf der rekursiven Funktion bis die "tiefste Ebene"(=Länge des Arrays gw_L/gw_NL) erreicht ist
#            print("eintauchen in tiefere index-Ebene")
            eine_gewuenschte_Laenge_dazufuegen_und_pruefen($index+1,$delta,$L,$gw_NL,$gw_L,$n_rekursiv); #rufe rekursive Funktion auf
        else:                                    #wenn tiefste Ebene erreicht ist  (= die Anzahlen aller gewünschten Längen festgelegt ist) kann der verschnitt für diese Kombination berechnet werden
            $rest=10;                              #Wähle irgendeine große Start Zahl
            foreach( $st_L as $delta):                      #Schleife über alle verschnitte, d.h für jede Verfüghbare Vorratsplattenlänge
                if($st_L>=0 AND $rest>$st_L):              # nur Verschnitte die positiv sind spielen mit negative Werte werden abgefangen
                    $rest = $st_L;
                endif;
            endforeach;                 #nimm den rest der Platte die den kleinsten Verschnitt hat
#            print("rest: ",rest," r_glob: ",r_glob)
            if($rest<$r_glob ):                   #wenn die aktuelle Kombination einen kleinen Verschnitt liefert als der bisherige Bestwert, nehme diese Kombination als neue Bestkonfiguration
                # print("setze rest"," index: ", index, " i: ",i)
                # print("delta: ", delta)
                # print("rest, r_glob: ",rest,r_glob)
                # print("verbrauchte Länge " ,L)
                # print("Erste Platte so aufgeteilt:", kombination[0],"*",gw_L[0]," ", kombination[1],"*",gw_L[1]," ", kombination[2],"*",gw_L[2])
                $k_glob = arrayCopy($kombination);
                $r_glob = $rest;
              endif;





#        print("k_glob: ",k_glob," r_glob: ", r_glob)
        $L = $L+$gw_L[$index];

        endif;                               #versuche noch eine gewünschte Platte der Länge gw_L[index] "anzuhängen"->bisherige gesamtlänge
#        print(" L: ", L," index: ", index, " i: ",i)
        $delta = $delta - $gw_L[$index];                       #versuche noch eine gewünschte Platte der Länge gw_L[index] "anzuhängen"->bisherige verschnitt delta reduziert sich weiter
#        print(" delta: ",delta," rest ",rest)
        $i = $i + 1;                                       #schleifenindex hochzählen
#    print("rückkehr zur höheren index-Ebene")
#    print()

#Nun wird Laenge für Laenge aus dem Vorrat geschaut was am
#besten passen würde in eine 3m Laenge, 4m LAenge, 5m LAenge oder 6m Laenge
$gw_NL_tmp = $gw_NL;

endwhile;



while(array_sum($gw_NL_tmp)>0):                                                  #schleife über alle benötigten Vorrats-Platten
    print('Noch benötigte Stücke: '.$gw_NL_tmp. "der Längen: ".$gw_L);
#    ist_fertig = False
    $L = 0.0;  #bisherige Länge der aneinander gehängten wunschplatten für diese Vorratsplatte
    $delta = $st_L;    #bisheriger Verschnitt an dieser Vorratsplatte->array
    eine_gewuenschte_Laenge_dazufuegen_und_pruefen(0,$delta,$L,$gw_NL_tmp,$gw_L,$n_rekursiv); #probiere alle Möglichkeiten aus und finde die beste Zerlegung der nächstzen Vorratsplatte
    print("gewählte Platte:".array_sum($k_glob*$gw_L)+$r_glob );                               #Nehme diese Vorratsplatte
    print("rest: ".$r_glob." Zerlegung der Vorratsplatte: ". $k_glob );                 #zerschniede sie auf diese Weise

    $gw_NL_tmp = $gw_NL_tmp - $k_glob;                                                   #k_glob Teile konnten aus dieser Vorratsplatte ausgeschnitten werden, die noch offenen Platten reduzieren sich um diene Anteil
    $rest=10;                                                          #Setze beliebigen hohen Startwert
    $kombination=sprintf($n_rekursiv+1);                               #Neusetzen der Variabeln: null Teile jeder Länge für lokale Kombination
    $k_glob=arrayCopy($kombination);                                      #Neusetzen der besten Kombination mit dem geringsten Verschnitt
    $r_glob=$rest;


endwhile;


}

[tomBuilder]

Warning: Invalid argument supplied for foreach() in /opt/lampp/htdocs/to/index.php on line 6

Jetzt das aber eindeuting nichts mehr fürs Forgeschritten Forum....

Und so nebenbei:

ich habe Platten von 3000, 4000, 5000 und 6000 mm, deren Zuschnitt berechnet werden soll, um minimalen Verschnitt zu garantieren:
(..)
ein Freund hat mir dieses python script geschrieben, das ich nun in php realisieren will.

Du hast keine Platten, sonst würde es auch in Python gehen, Du hast eine Schulaufgabe, und dafür ist ein porogrammiererforum -- jedenfalls mit der Eigenarbeit --
in meinen Augen sicher der falsche Platz.

[sanktusm]

Habe es jetzt fast geschafft:

<?php


function wert_von_array_werten_abziehen($delta, $abzuziehender_wert) {

$neues_delta = Array();

foreach($delta as $key => $value)
array_push($neues_delta, ($value - $abzuziehender_wert));


return $neues_delta;


}


function array_von_array_werten_multiplizieren($array, $multiplizierendes_array) {

$neues_array = Array();

foreach($array as $key => $value)
array_push($neues_array, ($value * $multiplizierendes_array[$key]));


return $neues_array;


}

function array_von_array_werten_subtrahieren($array, $subtrahierendes_array) {

$neues_array = Array();

foreach($array as $key => $value)
array_push($neues_array, ($value - $subtrahierendes_array[$key]));


return $neues_array;


}

$gw_L  = array(1.6, 1.2, 2.5, 2.7); #vom Kunden gewuenschte Laengen, Beispielzahlen
$gw_NL = array(6,4,7,11);      #vom Kunden gewuenschte Anzahl der Laengen, Beispielzahlen
$st_L  = array(3, 4, 5, 6);       #Vorrat an vorhandenen Laengen in theoretisch unbegrentzter Anzahl, Beispielzahlen

$n_rekursiv = count($gw_L)-1;
$rest = 10;

$kombination = Array();

for($i=0; $i<count($gw_NL); $i++)
array_push($kombination, 0);


$k_glob = $kombination;
$r_glob=$rest;



#erst prüfen ob alle vom Kunden gewuenschten Laengen kleiner sind als die maximal verfügbare
#Laenge im Vorrat, sonst Fehlermeldung und Abbruch des Programms:
if( max($gw_L)>max($st_L)):
    print("Es kann keine Platte der Breite:".max(gw_L)."bestellt werden");
endif;


function eine_gewuenschte_Laenge_dazufuegen_und_pruefen($index,$delta,$L,$gw_NL,$gw_L,$n_rekursiv) { #definition der rekursiven Funktion
#    print("hallo")
    global $rest;          #aktueller rest bei aktueller Zerlegung der Vorratsplatte
    global $kombination;   #aktuelle Zerlegung der Vorratsplatte
    global $r_glob;        #derzeit bester/kleinster rest bei bester Zerlgung
    global $k_glob;
    global $gw_NL_tmp;
           #derzeit beste Zerlegung
    $i=0;                            #laufindex von 0 bis zur vom Kunden gewünschten Anzahl an platten gw_NL[index]
    while( $i <= $gw_NL[$index]) :
        $kombination[$index] = $i;
        # print(" ")
        # print("schleife startet")
        # print("index: ",index)
        # print("  i: ",i)
        # print("kombi: ", kombination, " k_glob: ",k_glob)


        if($index < $n_rekursiv ):                   #Aufruf der rekursiven Funktion bis die "tiefste Ebene"(=Länge des Arrays gw_L/gw_NL) erreicht ist
#            print("eintauchen in tiefere index-Ebene")
            eine_gewuenschte_Laenge_dazufuegen_und_pruefen($index+1,$delta,$L,$gw_NL,$gw_L,$n_rekursiv); #rufe rekursive Funktion auf
        else:                                    #wenn tiefste Ebene erreicht ist  (= die Anzahlen aller gewünschten Längen festgelegt ist) kann der verschnitt für diese Kombination berechnet werden
            $rest=10;


                    #Wähle irgendeine große Start Zahl
            foreach($delta as $key => $NL) {

              if($NL>=0 AND $rest>$NL)
              $rest = $NL;           # nur Verschnitte die positiv sind spielen mit negative Werte werden abgefangen
                          # nur Verschnitte die positiv sind spielen mit negative Werte werden abgefangen



                 #Schleife über alle verschnitte, d.h für jede Verfüghbare Vorratsplattenlänge
                                   #nimm den rest der Platte die den kleinsten Verschnitt hat
#            print("rest: ",rest," r_glob: ",r_glob)
            if($rest<$r_glob ):                   #wenn die aktuelle Kombination einen kleinen Verschnitt liefert als der bisherige Bestwert, nehme diese Kombination als neue Bestkonfiguration
                # print("setze rest"," index: ", index, " i: ",i)
                # print("delta: ", delta)
                # print("rest, r_glob: ",rest,r_glob)
                # print("verbrauchte Länge " ,L)
                # print("Erste Platte so aufgeteilt:", kombination[0],"*",gw_L[0]," ", kombination[1],"*",gw_L[1]," ", kombination[2],"*",gw_L[2])
                $k_glob = $kombination;
                $r_glob = $rest;

             endif;
           }


        endif;
#        print("k_glob: ",k_glob," r_glob: ", r_glob)
        $L = $L+$gw_L[$index];


        #versuche noch eine gewünschte Platte der Länge gw_L[index] "anzuhängen"->bisherige gesamtlänge
#        print(" L: ", L," index: ", index, " i: ",i)
                         #versuche noch eine gewünschte Platte der Länge gw_L[index] "anzuhängen"->bisherige verschnitt delta reduziert sich weiter
#        print(" delta: ",delta," rest ",rest)

        $delta = wert_von_array_werten_abziehen($delta, $gw_L[$index]);


        $i = $i + 1;





   endwhile;                              #schleifenindex hochzählen
#    print("rückkehr zur höheren index-Ebene")
#    print()

#Nun wird Laenge für Laenge aus dem Vorrat geschaut was am
#besten passen würde in eine 3m Laenge, 4m LAenge, 5m LAenge oder 6m Laenge


}
$gw_NL_tmp = $gw_NL;

while(array_sum($gw_NL_tmp)>0):                                                  #schleife über alle benötigten Vorrats-Platten

#    ist_fertig = False
    $L = 0;  #bisherige Länge der aneinander gehängten wunschplatten für diese Vorratsplatte
    $delta = $st_L;    #bisheriger Verschnitt an dieser Vorratsplatte->array
    eine_gewuenschte_Laenge_dazufuegen_und_pruefen(0,$delta,$L,$gw_NL_tmp,$gw_L,$n_rekursiv);
    #probiere alle Möglichkeiten aus und finde die beste Zerlegung der nächstzen Vorratsplatte

var_dump($r_glob);

    print("<div>gewählte Platte:".array_sum(array_von_array_werten_multiplizieren($k_glob,$gw_L)) + $r_glob."</div>");                               #Nehme diese Vorratsplatte
    print("<div>rest: ".$r_glob." Zerlegung der Vorratsplatte: ". implode('#',$k_glob). "</div>");                 #zerschniede sie auf diese Weise

    $gw_NL_tmp = array_von_array_werten_subtrahieren($gw_NL_tmp,$k_glob);                                                   #k_glob Teile konnten aus dieser Vorratsplatte ausgeschnitten werden, die noch offenen Platten reduzieren sich um diene Anteil
    $rest=10;
    $kombination = Array();                                                        #Setze beliebigen hohen Startwert
    for($i=0; $i<count($gw_NL); $i++)
    array_push($kombination, 0);                              #Neusetzen der Variabeln: null Teile jeder Länge für lokale Kombination
    $k_glob = $kombination;                                       #Neusetzen der besten Kombination mit dem geringsten Verschnitt
    $r_glob = $rest;

endwhile;

leider gibt es noch Fehler beim addieren der variable r_glob, ich weiß nicht woran das liegen könnte. Hat jemand einen Tipp?

float(0)
Warning: A non-numeric value encountered in /opt/lampp/htdocs/to/to3.php on line 159
0
rest: 0 Zerlegung der Vorratsplatte: 0#0#2#0
float(0)
Warning: A non-numeric value encountered in /opt/lampp/htdocs/to/to3.php on line 159
0
rest: 0 Zerlegung der Vorratsplatte: 0#0#2#0
float(0)
Warning: A non-numeric value encountered in /opt/lampp/htdocs/to/to3.php on line 159
0
rest: 0 Zerlegung der Vorratsplatte: 0#0#2#0
float(0)
Warning: A non-numeric value encountered in /opt/lampp/htdocs/to/to3.php on line 159
0
rest: 0 Zerlegung der Vorratsplatte: 1#2#0#0
float(0)
Warning: A non-numeric value encountered in /opt/lampp/htdocs/to/to3.php on line 159
0
rest: 0 Zerlegung der Vorratsplatte: 1#2#0#0
float(0.1)
Warning: A non-numeric value encountered in /opt/lampp/htdocs/to/to3.php on line 159
0.1
rest: 0.1 Zerlegung der Vorratsplatte: 2#0#0#1
float(0.1)
Warning: A non-numeric value encountered in /opt/lampp/htdocs/to/to3.php on line 159
0.1
rest: 0.1 Zerlegung der Vorratsplatte: 2#0#0#1
float(0.3)
Warning: A non-numeric value encountered in /opt/lampp/htdocs/to/to3.php on line 159
0.3
rest: 0.3 Zerlegung der Vorratsplatte: 0#0#0#1
float(0.3)
Warning: A non-numeric value encountered in /opt/lampp/htdocs/to/to3.php on line 159
0.3
rest: 0.3 Zerlegung der Vorratsplatte: 0#0#0#1
float(0.3)
Warning: A non-numeric value encountered in /opt/lampp/htdocs/to/to3.php on line 159
0.3
rest: 0.3 Zerlegung der Vorratsplatte: 0#0#0#1
float(0.3)
Warning: A non-numeric value encountered in /opt/lampp/htdocs/to/to3.php on line 159
0.3
rest: 0.3 Zerlegung der Vorratsplatte: 0#0#0#1
float(0.3)
Warning: A non-numeric value encountered in /opt/lampp/htdocs/to/to3.php on line 159
0.3
rest: 0.3 Zerlegung der Vorratsplatte: 0#0#0#1
float(0.3)
Warning: A non-numeric value encountered in /opt/lampp/htdocs/to/to3.php on line 159
0.3
rest: 0.3 Zerlegung der Vorratsplatte: 0#0#0#1
float(0.3)
Warning: A non-numeric value encountered in /opt/lampp/htdocs/to/to3.php on line 159
0.3
rest: 0.3 Zerlegung der Vorratsplatte: 0#0#0#1
float(0.3)
Warning: A non-numeric value encountered in /opt/lampp/htdocs/to/to3.php on line 159
0.3
rest: 0.3 Zerlegung der Vorratsplatte: 0#0#0#1
float(0.3)
Warning: A non-numeric value encountered in /opt/lampp/htdocs/to/to3.php on line 159
0.3
rest: 0.3 Zerlegung der Vorratsplatte: 0#0#0#1
float(0.5)
Warning: A non-numeric value encountered in /opt/lampp/htdocs/to/to3.php on line 159
0.5
rest: 0.5 Zerlegung der Vorratsplatte: 0#0#1#0

[sanktusm]

hab den Fehler beheben könnten:

print("<div>gewählte Platte:".(array_sum(array_von_array_werten_multipl izieren($k_glob,$gw_L)) + $r_glob)."</div>");