FLBK-Wiki

Gozintograph: Unterschied zwischen den Versionen

← Zum vorherigen Versionsunterschied
VisuellWikitext
 
(102 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 11: Zeile 11:
== Zusammenhang zu Matrizen ==
== Zusammenhang zu Matrizen ==
Die Informationen eines Gozintographen lassen sich in einer sogenannten '''Gozintomatrix''' darstellen.   
Die Informationen eines Gozintographen lassen sich in einer sogenannten '''Gozintomatrix''' darstellen.   
Diese ist eine Matrix \( A = (a_{ij}) \), bei der das Element \( a_{ij} \) die Anzahl der Einheiten von Komponente \( i \) angibt, die für die Herstellung von Produkt \( j \) benötigt wird.   
Diese ist eine [[Matrix]] \( A = (a_{ij}) \), bei der das Element \( a_{ij} \) die Anzahl der Einheiten von Komponente \( i \) angibt, die für die Herstellung von Produkt \( j \) benötigt wird.   
In der Produktionsplanung kann die benötigte Gesamtmenge aller Einzelteile über die Gleichung
In der Produktionsplanung kann die benötigte Gesamtmenge aller Einzelteile über die Gleichung


Zeile 18: Zeile 18:
bestimmt werden, wobei \( \mathbf{y} \) den Vektor der Endprodukte und \( \mathbf{x} \) den Vektor der benötigten Teilemengen beschreibt.
bestimmt werden, wobei \( \mathbf{y} \) den Vektor der Endprodukte und \( \mathbf{x} \) den Vektor der benötigten Teilemengen beschreibt.


== Produktion eines Produkts aus Einzelteilen ==
==Beispiele==
=== Produktion eines Produkts aus Einzelteilen ===


Im folgenden Beispiel werden fünf Bauteile \( B_1, B_2, B_3, B_4, B_5 \) aus vier Einzelteilen \( E_1, E_2, E_3, E_4 \) gefertigt.   
Im folgenden Beispiel werden fünf Bauteile \( B_1, B_2, B_3, B_4, B_5 \) aus vier Einzelteilen \( E_1, E_2, E_3, E_4 \) gefertigt.   
Die Pfeile zeigen, welche Einzelteile in welches Bauteil eingehen. Die Zahlen an den Pfeilen geben die Stückzahl an.
Die Pfeile zeigen, welche Einzelteile in welches Bauteil eingehen. Die Zahlen an den Pfeilen geben die Stückzahl an.
<!-- VARIANTE B – FINAL OPTIMIERT -->
<html>
<style>
  .gozinto-wrap {
    width:95vw;
    height:50vw;
    max-width:1100px;
    max-height:400px;
    border:0;
    margin:0;
    padding:0;
  }
  svg {
    width:100%;
    height:100%;
    touch-action:none;
    user-select:none;
    background:white;
  }
  .node-rect {
    fill:#3498db;
    stroke:#1f4e78;
    stroke-width:2;
    cursor:grab;
  }
  /* Einheitliche Schriftgröße */
  .node-text, .count-text {
    font-family:sans-serif;
    font-size:14px;
    fill:#000;
    pointer-events:none;
  }
  .edge-line {
    stroke:#000;
    stroke-width:2;
    fill:none;
  }
  .edge-arrow { fill:#000; }
  .count-circle {
    fill:#fff;
    stroke:#000;
    stroke-width:1.5;
  }
</style>
<div class="gozinto-wrap">
<svg id="gozinto_svg_2" viewBox="0 0 1200 450" preserveAspectRatio="xMinYMin meet">
</svg>
</div>


<html>
<div id="gozinto1" style="width:90vw; max-width:600px; height:60vw; max-height:500px; margin-top:20px;"></div>
<script src="https://jsxgraph.org/distrib/jsxgraphcore.js"></script>
<script>
<script>
var brd1 = JXG.JSXGraph.initBoard('gozinto1', {
(function(){
     boundingbox: [-1, 8, 10, -1],
  const svg = document.getElementById("gozinto_svg_2");
    axis: false,
 
    showCopyright: false,
  // leicht reduzierte Abstände
    showNavigation: false
  const scale = 100;
});
  const yOffset = 0;          // früher 5 20 → Grafik rückt nach oben
  const xOffsetGlobal = 120;    // gesamte Grafik leicht nach rechts (zentrieren)
 
  function svgEl(name, attrs){
     const el = document.createElementNS("http://www.w3.org/2000/svg", name);
    for(const k in (attrs||{})) el.setAttribute(k, attrs[k]);
    return el;
  }
 
  function getSVGcoords(evt){
    const pt = svg.createSVGPoint();
    pt.x = evt.clientX;
    pt.y = evt.clientY;
    return pt.matrixTransform(svg.getScreenCTM().inverse());
  }
 
  // ----------- NODE -----------
  function createNode(id, cx, cy, w, h, label){
    cx += xOffsetGlobal/scale;  // gesamte Grafik nach rechts versetzt
 
    const g = svgEl("g", {"data-id":id});
    const rect = svgEl("rect", {
      class:"node-rect",
      x:(cx-w/2)*scale, y:(cy-h/2)*scale + yOffset,
      width:w*scale, height:h*scale, rx:6, ry:6
    });


// Hilfsfunktion zum Rechteck
    const text = svgEl("text", {
function box(x1,y1,x2,y2,color){
      class:"node-text",
    return brd1.create('polygon',[[x1,y1],[x2,y1],[x2,y2],[x1,y2]],{
      x:cx*scale, y:cy*scale+yOffset,
        fillColor:color,fillOpacity:0.8,vertices:{visible:false},borders:{strokeColor:'#333'}
      "text-anchor":"middle",
      "dominant-baseline":"middle"
     });
     });
}
    text.textContent = label;


// Knoten
    g.appendChild(rect);
var E1=box(0,6,1,7,'#e67e22');
    g.appendChild(text);
var E2=box(2,6,3,7,'#e67e22');
    svg.appendChild(g);
var E3=box(4,6,5,7,'#e67e22');
var E4=box(6,6,7,7,'#e67e22');
var B1=box(1,3,2,4,'#3498db');
var B2=box(3,3,4,4,'#3498db');
var B3=box(5,3,6,4,'#3498db');
var B4=box(2,1,3,2,'#2ecc71');
var B5=box(4,1,5,2,'#2ecc71');


// Beschriftungen
    const node = {id,cx,cy,w,h,rect,text,g};
brd1.create('text',[0.4,7.2,'E1']);
brd1.create('text',[2.4,7.2,'E2']);
brd1.create('text',[4.4,7.2,'E3']);
brd1.create('text',[6.4,7.2,'E4']);
brd1.create('text',[1.4,4.2,'B1']);
brd1.create('text',[3.4,4.2,'B2']);
brd1.create('text',[5.4,4.2,'B3']);
brd1.create('text',[2.4,2.2,'B4']);
brd1.create('text',[4.4,2.2,'B5']);


function arrow(fromX, fromY, toX, toY, label){
     // Draggen
     brd1.create('arrow',[[fromX,fromY],[toX,toY]],{strokeColor:'#555'});
     let dragging=false, start={};
     brd1.create('text',[(fromX+toX)/2,(fromY+toY)/2+0.2,label],{fontSize:10});
}


// Kanten
    rect.addEventListener("pointerdown", e=>{
arrow(0.5,6,1.5,4,'2');
      rect.setPointerCapture(e.pointerId);
arrow(2.5,6,1.5,4,'1');
      dragging=true;
arrow(2.5,6,3.5,4,'3');
      const p = getSVGcoords(e);
arrow(4.5,6,3.5,4,'2');
      start = {px:p.x, py:p.y, cx:node.cx, cy:node.cy};
arrow(4.5,6,5.5,4,'1');
    });
arrow(6.5,6,5.5,4,'1');
 
arrow(1.5,3,2.5,2,'1');
    rect.addEventListener("pointermove", e=>{
arrow(3.5,3,2.5,2,'2');
      if(!dragging) return;
arrow(3.5,3,4.5,2,'1');
      const p = getSVGcoords(e);
arrow(5.5,3,4.5,2,'1');
      node.cx = start.cx + (p.x - start.px)/scale;
      node.cy = start.cy + (p.y - start.py)/scale;
      updateNode(node);
      updateAllEdges();
    });
 
    rect.addEventListener("pointerup", e=>{
      dragging=false;
      rect.releasePointerCapture(e.pointerId);
    });
 
    return node;
  }
 
  function updateNode(n){
    n.rect.setAttribute("x",(n.cx-n.w/2)*scale);
    n.rect.setAttribute("y",(n.cy-n.h/2)*scale+yOffset);
    n.text.setAttribute("x",n.cx*scale);
    n.text.setAttribute("y",n.cy*scale+yOffset);
  }
 
  // ------- Geometrie -------
  function intersectRectBorder(node, tx, ty){
    const cx=node.cx, cy=node.cy, w2=node.w/2, h2=node.h/2;
    const dx=tx-cx, dy=ty-cy;
    let pts=[];
 
    if(Math.abs(dx)>1e-9){
      let t1=(-w2)/dx; let y1=cy+t1*dy;
      if(t1>0 && y1>=cy-h2 && y1<=cy+h2) pts.push({x:cx-w2,y:y1,t:t1});
      let t2=(w2)/dx; let y2=cy+t2*dy;
      if(t2>0 && y2>=cy-h2 && y2<=cy+h2) pts.push({x:cx+w2,y:y2,t:t2});
    }
    if(Math.abs(dy)>1e-9){
      let t3=(-h2)/dy; let x3=cx+t3*dx;
      if(t3>0 && x3>=cx-w2 && x3<=cx+w2) pts.push({x:x3,y:cy-h2,t:t3});
      let t4=(h2)/dy; let x4=cx+t4*dx;
      if(t4>0 && x4>=cx-w2 && x4<=cx+w2) pts.push({x:x4,y:cy+h2,t:t4});
    }
    pts.sort((a,b)=>a.t-b.t);
    return pts[0] || {x:cx,y:cy};
  }
 
  function pointOnCircle(cx,cy,R,tx,ty){
    const dx=tx-cx, dy=ty-cy;
    const d=Math.sqrt(dx*dx+dy*dy);
    if(d<1e-9) return {x:cx,y:cy};
    return {x:cx+R*dx/d, y:cy+R*dy/d};
  }
 
  function makeArrowHead(x,y,ux,uy,size){
    let px=-uy, py=ux;
    return `M ${x} ${y}
            L ${x-ux*size+px*size*0.5} ${y-uy*size+py*size*0.5}
            L ${x-ux*size-px*size*0.5} ${y-uy*size-py*size*0.5} Z`;
  }
 
  const edges=[];
 
  function makeConnection(fromNode,toNode,amount,yMid,xOffset){
    const g=svgEl("g",{});
    const lineA=svgEl("path",{class:"edge-line"});
    const lineB=svgEl("path",{class:"edge-line"});
    const circle=svgEl("circle",{class:"count-circle"});
    const text=svgEl("text",{class:"count-text"});
    const arrow=svgEl("path",{class:"edge-arrow"});
 
    text.textContent=amount;
    g.appendChild(lineA);
    g.appendChild(lineB);
    g.appendChild(circle);
    g.appendChild(text);
    g.appendChild(arrow);
    svg.appendChild(g);
 
    let e={fromNode,toNode,amount,yMid,xOffset,circle,text,lineA,lineB,arrow};
    edges.push(e);
    updateEdge(e);
  }
 
  function updateEdge(e){
    const cx=(e.fromNode.cx+e.toNode.cx)/2+(e.xOffset||0);
    const cy=e.yMid;
    const R=0.14;
 
    const pF=intersectRectBorder(e.fromNode,cx,cy);
    const pT=intersectRectBorder(e.toNode,cx,cy);
 
    const pCircleIn=pointOnCircle(cx,cy,R,pF.x,pF.y);
    const pCircleOut=pointOnCircle(cx,cy,R,pT.x,pT.y);
 
    const px=p=>[p.x*scale, p.y*scale+yOffset];
    const F=px(pF), Ci=px(pCircleIn), Co=px(pCircleOut), T=px(pT);
 
    e.lineA.setAttribute("d",`M ${F[0]} ${F[1]} L ${Ci[0]} ${Ci[1]}`);
    e.lineB.setAttribute("d",`M ${Co[0]} ${Co[1]} L ${T[0]} ${T[1]}`);
 
    e.circle.setAttribute("cx",cx*scale);
    e.circle.setAttribute("cy",cy*scale+yOffset);
    e.circle.setAttribute("r",R*scale);
 
    e.text.setAttribute('x', cx*scale-5);
    e.text.setAttribute('y', cy*scale + yOffset+5);
 
    let ux=T[0]-Co[0], uy=T[1]-Co[1];
    let L=Math.sqrt(ux*ux+uy*uy); if(L<1e-6) L=1;
    ux/=L; uy/=L;
 
    e.arrow.setAttribute("d",makeArrowHead(T[0],T[1],ux,uy,10));
  }
 
  function updateAllEdges(){ edges.forEach(updateEdge); }
 
  // ------------ Nodes ------------
  const nodes={};
 
  // Einzelteile oben
  nodes.E1=createNode("E1",0,0.5,1.0,0.5,"E1");
  nodes.E2=createNode("E2",2.5,0.5,1.0,0.5,"E2");
  nodes.E3=createNode("E3",5.0,0.5,1.0,0.5,"E3");
  nodes.E4=createNode("E4",7.5,0.5,1.0,0.5,"E4");
 
  // Bauteile darunter
  nodes.B1=createNode("B1",0.75,4.5,1.0,0.5,"B1");
  nodes.B2=createNode("B2",2.5,4.5,1.0,0.5,"B2");
  nodes.B3=createNode("B3",5.0,4.5,1.0,0.5,"B3");
  nodes.B4=createNode("B4",7.5,4.5,1.0,0.5,"B4");
  nodes.B5=createNode("B5",10,4.5,1.0,0.5,"B5");
 
  // ------------ Verbindungen ------------
  makeConnection(nodes.E1,nodes.B1,"2",2.2,-0.2);
  makeConnection(nodes.E2,nodes.B1,"1",2.2, 0.2);
 
  makeConnection(nodes.E1,nodes.B2,"2",2.2,-0.2);
  makeConnection(nodes.E2,nodes.B2,"1",2.2, 0.2);
 
  makeConnection(nodes.E1,nodes.B3,"1",2.2,-0.25);
  makeConnection(nodes.E2,nodes.B3,"1",2.2, 0.0);
  makeConnection(nodes.E3,nodes.B3,"1",2.2, 0.25);
 
  makeConnection(nodes.E1,nodes.B4,"2",2.2,-0.3);
  makeConnection(nodes.E3,nodes.B4,"1",2.2, 0.0);
  makeConnection(nodes.E4,nodes.B4,"1",2.2, 0.3);
 
  makeConnection(nodes.E1,nodes.B5,"1",2.2,-0.2);
  makeConnection(nodes.E4,nodes.B5,"2",2.2, 0.2);
 
  updateAllEdges();
})();
</script>
</script>
</html>
</html>


== Beispiel 2: Rezeptstruktur eines Gerichts ==
Die Gozintomatrix zum oberen Gozintographen kann dann aus der Tabelle
Im nächsten Beispiel wird der Gozintograph genutzt, um die Zutatenstruktur eines Rezepts zu zeigen. 
 
Das Endprodukt „Pizza“ besteht aus mehreren Zwischenprodukten („Teig“, „Soße“) und Basiszutaten. 
{| class="wikitable"
Auch hier zeigen Pfeile mit Zahlen, welche Mengen von Zutaten in die jeweiligen Komponenten eingehen.
!      !! B1  !! B2 !! B3 !! B4 !! B5
|-
| '''E1'''  || 2  || 2 || 1 || 1
|-
| '''E2'''  || 1  || 1 || 1 || 0
|-
| '''E3'''  || 0  || 0 || 1 || 0
|-
| '''E3'''  || 0  || 0 || 0 || 2
|}
 
abgeleitet werden und ist dann durch
 
:<math>
A = \begin{pmatrix}
2 & 2 & 1 & 2 & 1 \\
1 & 1 & 1 & 0 & 0 \\
0 & 0 & 1 & 1 & 0 \\
0 & 0 & 0 & 1 & 2
\end{pmatrix}
</math>


gegeben. Beispielsweise lässt sich aus der ersten Spalte ablesen, dass 2 Einzelteile von E1, 1 Einzelteil von E2 sowie 0 Einzelteile von E3 und E4 für die Herstellung eines Bauteils B1 benötigt werden.
=== Produktion von Spielwaren aus Rohstoffen über Zwischenprodukte ===
Ein Spielwarenhersteller produziert aus drei Rohstoffen \(R_1, R_2, R_3\) zunächst die beiden Zwischenprodukte \(Z_1, Z_2\), aus denen anschließend die drei Endprodukte \(E_1, E_2, E_3\) gefertigt werden.
Die Pfeile im Gozintographen geben an, wie viele Tonnen eines Materials zur Produktion von 1 Tonne des entstehenden Produkts benötigt werden. 
Beispiel: Für die Herstellung von 1 Tonne \(Z_1\) werden 3 Tonnen \(R_1\) und 4 Tonnen \(R_2\) benötigt.
<!-- GOZINTOGRAPH: Rohstoffe → Zwischenprodukte → Endprodukte -->
<html>
<html>
<div id="gozinto2" style="width:90vw; max-width:600px; height:60vw; max-height:500px; margin-top:20px;"></div>
<style>
  .gozinto-wrap {
    width:95vw;
    height:60vw;
    max-width:1200px;
    max-height:650px;
    border:0;
    margin:0;
    padding:0;
  }
 
  svg {
    width:100%;
    height:100%;
    touch-action:none;
    user-select:none;
    background:white;
  }
 
  .node-rect {
    fill:#3498db;
    stroke:#1f4e78;
    stroke-width:2;
    cursor:grab;
  }
 
  .node-text, .count-text {
    font-family:sans-serif;
    font-size:14px;
    fill:#000;
    pointer-events:none;
  }
 
  .edge-line {
    stroke:#000;
    stroke-width:2;
    fill:none;
  }
 
  .edge-arrow { fill:#000; }
 
  .count-circle {
    fill:#fff;
    stroke:#000;
    stroke-width:1.5;
  }
</style>
 
<div class="gozinto-wrap">
<svg id="gozinto_svg" viewBox="0 0 1180 600" preserveAspectRatio="xMinYMin meet">
</svg>
</div>
 
<script>
<script>
var brd2 = JXG.JSXGraph.initBoard('gozinto2', {
(function(){
     boundingbox: [-1, 8, 10, -1],
  const svg = document.getElementById("gozinto_svg");
    axis: false,
 
    showCopyright: false,
  const scale = 100;
    showNavigation: false
  const yOffset = 0;
});
  const xOffsetGlobal = 120;
 
  function svgEl(name, attrs){
     const el = document.createElementNS("http://www.w3.org/2000/svg", name);
    for(const k in (attrs||{})) el.setAttribute(k, attrs[k]);
    return el;
  }
 
  function getSVGcoords(evt){
    const pt = svg.createSVGPoint();
    pt.x = evt.clientX;
    pt.y = evt.clientY;
    return pt.matrixTransform(svg.getScreenCTM().inverse());
  }
 
  function createNode(id, cx, cy, w, h, label){
    cx += xOffsetGlobal/scale;
 
    const g = svgEl("g", {"data-id":id});
    const rect = svgEl("rect", {
      class:"node-rect",
      x:(cx-w/2)*scale, y:(cy-h/2)*scale + yOffset,
      width:w*scale, height:h*scale, rx:6, ry:6
    });


function box2(x1,y1,x2,y2,color){
    const text = svgEl("text", {
    return brd2.create('polygon',[[x1,y1],[x2,y1],[x2,y2],[x1,y2]],{
      class:"node-text",
        fillColor:color,fillOpacity:0.8,vertices:{visible:false},borders:{strokeColor:'#333'}
      x:cx*scale, y:cy*scale+yOffset,
      "text-anchor":"middle",
      "dominant-baseline":"middle"
     });
     });
}
    text.textContent = label;
 
    g.appendChild(rect);
    g.appendChild(text);
    svg.appendChild(g);
 
    const node = {id,cx,cy,w,h,rect,text,g};
 
    let dragging=false, start={};


var M1=box2(0,6,1,7,'#e67e22'); // Mehl
    rect.addEventListener("pointerdown", e=>{
var W1=box2(2,6,3,7,'#e67e22'); // Wasser
      rect.setPointerCapture(e.pointerId);
var H1=box2(4,6,5,7,'#e67e22'); // Hefe
      dragging=true;
var T1=box2(1,3,2,4,'#3498db'); // Teig
      const p = getSVGcoords(e);
var T2=box2(5,3,6,4,'#3498db'); // Soße
      start = {px:p.x, py:p.y, cx:node.cx, cy:node.cy};
var T3=box2(3,1,4,2,'#2ecc71'); // Pizza
    });


brd2.create('text',[0.4,7.2,'Mehl']);
    rect.addEventListener("pointermove", e=>{
brd2.create('text',[2.4,7.2,'Wasser']);
      if(!dragging) return;
brd2.create('text',[4.4,7.2,'Hefe']);
      const p = getSVGcoords(e);
brd2.create('text',[1.4,4.2,'Teig']);
      node.cx = start.cx + (p.x - start.px)/scale;
brd2.create('text',[5.4,4.2,'Soße']);
      node.cy = start.cy + (p.y - start.py)/scale;
brd2.create('text',[3.4,2.2,'Pizza']);
      updateNode(node);
      updateAllEdges();
    });


function arrow2(fromX, fromY, toX, toY, label){
     rect.addEventListener("pointerup", e=>{
     brd2.create('arrow',[[fromX,fromY],[toX,toY]],{strokeColor:'#555'});
      dragging=false;
    brd2.create('text',[(fromX+toX)/2,(fromY+toY)/2+0.2,label],{fontSize:10});
      rect.releasePointerCapture(e.pointerId);
}
    });


// Zutaten -> Teig
    return node;
arrow2(0.5,6,1.5,4,'2');
  }
arrow2(2.5,6,1.5,4,'1');
 
arrow2(4.5,6,1.5,4,'0.5');
  function updateNode(n){
// Teig + Soße -> Pizza
    n.rect.setAttribute("x",(n.cx-n.w/2)*scale);
arrow2(1.5,3,3.5,2,'1');
    n.rect.setAttribute("y",(n.cy-n.h/2)*scale+yOffset);
arrow2(5.5,3,3.5,2,'1');
    n.text.setAttribute("x",n.cx*scale);
    n.text.setAttribute("y",n.cy*scale+yOffset);
  }
 
  function intersectRectBorder(node, tx, ty){
    const cx=node.cx, cy=node.cy, w2=node.w/2, h2=node.h/2;
    const dx=tx-cx, dy=ty-cy;
    let pts=[];
 
    if(Math.abs(dx)>1e-9){
      let t1=(-w2)/dx; let y1=cy+t1*dy;
      if(t1>0 && y1>=cy-h2 && y1<=cy+h2) pts.push({x:cx-w2,y:y1,t:t1});
      let t2=(w2)/dx; let y2=cy+t2*dy;
      if(t2>0 && y2>=cy-h2 && y2<=cy+h2) pts.push({x:cx+w2,y:y2,t:t2});
    }
    if(Math.abs(dy)>1e-9){
      let t3=(-h2)/dy; let x3=cx+t3*dx;
      if(t3>0 && x3>=cx-w2 && x3<=cx+w2) pts.push({x:x3,y:cy-h2,t:t3});
      let t4=(h2)/dy; let x4=cx+t4*dx;
      if(t4>0 && x4>=cx-w2 && x4<=cx+w2) pts.push({x:x4,y:cy+h2,t:t4});
    }
    pts.sort((a,b)=>a.t-b.t);
    return pts[0] || {x:cx,y:cy};
  }
 
  function pointOnCircle(cx,cy,R,tx,ty){
    const dx=tx-cx, dy=ty-cy;
    const d=Math.sqrt(dx*dx+dy*dy);
    if(d<1e-9) return {x:cx,y:cy};
    return {x:cx+R*dx/d, y:cy+R*dy/d};
  }
 
  function makeArrowHead(x,y,ux,uy,size){
    let px=-uy, py=ux;
    return `M ${x} ${y}
            L ${x-ux*size+px*size*0.5} ${y-uy*size+py*size*0.5}
            L ${x-ux*size-px*size*0.5} ${y-uy*size-py*size*0.5} Z`;
  }
 
  const edges=[];
 
  function makeConnection(fromNode,toNode,amount,yMid,xOffset){
    const g=svgEl("g",{});
    const lineA=svgEl("path",{class:"edge-line"});
    const lineB=svgEl("path",{class:"edge-line"});
    const circle=svgEl("circle",{class:"count-circle"});
    const text=svgEl("text",{class:"count-text"});
    const arrow=svgEl("path",{class:"edge-arrow"});
 
    text.textContent=amount;
 
    g.appendChild(lineA);
    g.appendChild(lineB);
    g.appendChild(circle);
    g.appendChild(text);
    g.appendChild(arrow);
    svg.appendChild(g);
 
    let e={fromNode,toNode,amount,yMid,xOffset,circle,text,lineA,lineB,arrow};
    edges.push(e);
    updateEdge(e);
  }
 
  function updateEdge(e){
    const cx=(e.fromNode.cx+e.toNode.cx)/2+(e.xOffset||0);
    const cy=e.yMid;
    const R=0.14;
 
    const pF=intersectRectBorder(e.fromNode,cx,cy);
    const pT=intersectRectBorder(e.toNode,cx,cy);
 
    const pCircleIn=pointOnCircle(cx,cy,R,pF.x,pF.y);
    const pCircleOut=pointOnCircle(cx,cy,R,pT.x,pT.y);
 
    const px=p=>[p.x*scale, p.y*scale+yOffset];
    const F=px(pF), Ci=px(pCircleIn), Co=px(pCircleOut), T=px(pT);
 
    e.lineA.setAttribute("d",`M ${F[0]} ${F[1]} L ${Ci[0]} ${Ci[1]}`);
    e.lineB.setAttribute("d",`M ${Co[0]} ${Co[1]} L ${T[0]} ${T[1]}`);
 
    e.circle.setAttribute("cx",cx*scale);
    e.circle.setAttribute("cy",cy*scale+yOffset);
    e.circle.setAttribute("r",R*scale);
 
    e.text.setAttribute('x', cx*scale-5);
    e.text.setAttribute('y', cy*scale + yOffset+5);
 
    let ux=T[0]-Co[0], uy=T[1]-Co[1];
    let L=Math.sqrt(ux*ux+uy*uy); if(L<1e-6) L=1;
    ux/=L; uy/=L;
 
    e.arrow.setAttribute("d",makeArrowHead(T[0],T[1],ux,uy,10));
  }
 
  function updateAllEdges(){ edges.forEach(updateEdge); }
 
  // -----------------------------------------------------
  // NODES
  // -----------------------------------------------------
 
  const nodes={};
 
  // Rohstoffe (oben)
  nodes.R1=createNode("R1",0,0.8,1.0,0.5,"R1");
  nodes.R2=createNode("R2",2.5,0.8,1.0,0.5,"R2");
  nodes.R3=createNode("R3",5.0,0.8,1.0,0.5,"R3");
 
  // Zwischenprodukte (Mitte)
  nodes.Z1=createNode("Z1",1.2,3.3,1.0,0.5,"Z1");
  nodes.Z2=createNode("Z2",3.0,3.3,1.0,0.5,"Z2");
 
  // Endprodukte (unten)
  nodes.E1=createNode("E1",0.5,5.8,1.0,0.5,"E1");
  nodes.E2=createNode("E2",2.5,5.8,1.0,0.5,"E2");
  nodes.E3=createNode("E3",4.5,5.8,1.0,0.5,"E3");
 
  // -----------------------------------------------------
  // VERBINDUNGEN
  // gemäß Tabellen:
  // Rohstoffe → Zwischenprodukte
  // R1→Z1: 3  | R1→Z2: 1
  // R2→Z1: 4  | R2→Z2: 2
  // R3→Z1: 0  | R3→Z2: 3
  // Zwischenprodukte → Endprodukte
  // Z1: (E1=2, E2=1, E3=0)
  // Z2: (E1=1, E2=3, E3=2)
  // -----------------------------------------------------
 
  // R1
  makeConnection(nodes.R1,nodes.Z1,"3",1.8,-0.3);
  makeConnection(nodes.R1,nodes.Z2,"1",1.8, 0.4);
 
  // R2
  makeConnection(nodes.R2,nodes.Z1,"4",1.8,-0.2);
  makeConnection(nodes.R2,nodes.Z2,"2",1.8, 0.2);
 
  // R3
  makeConnection(nodes.R3,nodes.Z2,"3",1.8, 0.0);
 
  // Z1 → Endprodukte
  makeConnection(nodes.Z1,nodes.E1,"2",4.6,-0.2);
  makeConnection(nodes.Z1,nodes.E2,"1",4.6, 0.2);
 
  // Z2 → Endprodukte
  makeConnection(nodes.Z2,nodes.E1,"1",4.6,-0.3);
  makeConnection(nodes.Z2,nodes.E2,"3",4.6, 0.0);
  makeConnection(nodes.Z2,nodes.E3,"2",4.6, 0.3);
 
  updateAllEdges();
})();
</script>
</script>
</html>
</html>
Die vollständigen Mengen seien wie folgt definiert:
{| class="wikitable"
!              !! Z1 !! Z2
|-
| '''R1'''    || 3 || 1
|-
| '''R2'''    || 4 || 2
|-
| '''R3'''    || 0 || 3
|}
{| class="wikitable"
!              !! E1 !! E2 !! E3
|-
| '''Z1'''    || 2 || 1 || 0
|-
| '''Z2'''    || 1 || 3 || 2
|}
Aus diesen Tabellen ergibt sich die **Gozintomatrix Rohstoffe → Endprodukte**, indem die Matrizen miteinander multipliziert werden:
:<math>
RZ = \begin{pmatrix}
3 & 1 \\
4 & 2 \\
0 & 3
\end{pmatrix},
\qquad
ZE = \begin{pmatrix}
2 & 1 & 0 \\
1 & 3 & 2
\end{pmatrix}
</math>
:<math>
RE = RZ \cdot ZE
    = \begin{pmatrix}
3 & 1 \\
4 & 2 \\
0 & 3
\end{pmatrix}
\cdot
\begin{pmatrix}
2 & 1 & 0 \\
1 & 3 & 2
\end{pmatrix}
</math>
Berechnung:
:<math>
RE =
\begin{pmatrix}
3\cdot2 + 1\cdot1  & 3\cdot1 + 1\cdot3 & 3\cdot0 + 1\cdot2 \\
4\cdot2 + 2\cdot1  & 4\cdot1 + 2\cdot3 & 4\cdot0 + 2\cdot2 \\
0\cdot2 + 3\cdot1  & 0\cdot1 + 3\cdot3 & 0\cdot0 + 3\cdot2
\end{pmatrix}
=
\begin{pmatrix}
7 & 6 & 2 \\
10 & 10 & 4 \\
3 & 9 & 6
\end{pmatrix}
</math>
Die Matrix zeigt, wie viele Tonnen der Rohstoffe \(R_1, R_2, R_3\) jeweils zur Herstellung von 1 Tonne der Endprodukte \(E_1, E_2, E_3\) notwendig sind. 
Beispielsweise bedeutet die erste Spalte:
Für 1 Tonne \(E_1\) werden benötigt:
* 7 Tonnen \(R_1\) 
* 10 Tonnen \(R_2\) 
* 3 Tonnen \(R_3\)
Dies ergibt sich daraus, dass die Zwischenprodukte Z1 und Z2 selbst wiederum aus Rohstoffen bestehen.


[[Kategorie:Lineare_Algebra]]
[[Kategorie:Lineare_Algebra]]
[[Kategorie:AHR_WuV_Mathe_GK]]
[[Kategorie:AHR_WuV_Mathe_GK]]
Abgerufen von „https://wiki.flbk-hamm.de/Gozintograph“