Gozintograph: Unterschied zwischen den Versionen

Aus FLBK-Wiki
Zur Navigation springen Zur Suche springen
← Zum vorherigen Versionsunterschied
Flbkwikiadmin (Diskussion | Beiträge)
Bürokraten, Oberflächenadministratoren, Administratoren
2.241 Bearbeitungen
VisuellWikitext
Markierung: Manuelle Zurücksetzung
 
(93 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 1: Zeile 1:
Ein '''Gozintograph''' (von engl. *goes into* = „geht hinein“) ist ein gerichteter Graph, der die Zerlegung eines Endprodukts in seine Einzelteile oder Komponenten beschreibt.   
Ein '''Gozintograph''' (von engl. ''goes into'' = „geht hinein“) ist ein gerichteter Graph, der die Zerlegung eines Endprodukts in seine Einzelteile oder Komponenten beschreibt.   
Jede Kante stellt dabei eine „Gozinto“-Beziehung dar: Sie zeigt von einer Komponente (Teil) auf das Produkt, in das sie eingeht. Der Gozintograph ist ein zentrales Hilfsmittel in der Produktionsplanung und Stücklistenverwaltung.
Jede Kante stellt dabei eine „Gozinto“-Beziehung dar: Sie zeigt von einer Komponente auf das Produkt, in das sie eingeht. Der Gozintograph ist ein zentrales Hilfsmittel in der Produktionsplanung und Stücklistenverwaltung.


== Definition ==
== Definition ==
Ein Gozintograph ist ein gerichteter, azyklischer Graph \( G = (V, E) \), wobei:
* \( V \) die Menge der Knoten darstellt (Produkte oder Teile),
* \( E \subseteq V \times V \) die gerichteten Kanten darstellt, welche „geht-in“-Beziehungen symbolisieren.


Eine Kante \( (v_i, v_j, a_{ij}) \) mit der Beschriftung \( a_{ij} \) zeigt an, dass zur Herstellung eines Teils \( v_j \) genau \( a_{ij} \) Einheiten von Teil \( v_i \) benötigt werden.
Ein Gozintograph ist ein gerichteter, azyklischer Graph
 
:<math>G=(V,E)</math>
 
mit:
* <math>V</math> als Menge der Knoten (Produkte oder Komponenten),
* <math>E \subseteq V \times V</math> als Menge der gerichteten Kanten.
 
Zusätzlich besitzt jede Kante ein Gewicht <math>a_{ij} \in \mathbb{N}</math>. 
Eine Kante <math>(v_i,v_j)\in E</math> mit Gewicht <math>a_{ij}</math> bedeutet, dass zur Herstellung des Produkts <math>v_j</math> genau <math>a_{ij}</math> Einheiten der Komponente <math>v_i</math> benötigt werden.
 
Da rekursive Stücklisten ausgeschlossen werden, enthält ein Gozintograph keine Zyklen.


== Zusammenhang zu Matrizen ==
== Zusammenhang zu Matrizen ==
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. 
In der Produktionsplanung kann die benötigte Gesamtmenge aller Einzelteile über die Gleichung


\[ \mathbf{x} = (I - A)^{-1} \mathbf{y} \]
Die Informationen eines Gozintographen lassen sich in einer sogenannten '''Gozintomatrix''' darstellen.


bestimmt werden, wobei \( \mathbf{y} \) den Vektor der Endprodukte und \( \mathbf{x} \) den Vektor der benötigten Teilemengen beschreibt.
Dies ist eine Matrix
 
:<math>A=(a_{ij})</math>
 
bei der das Element <math>a_{ij}</math> die Anzahl der Einheiten der Komponente <math>i</math> angibt, die unmittelbar zur Herstellung des Produkts <math>j</math> benötigt werden.
 
Unter der Voraussetzung, dass der Gozintograph zyklusfrei ist und <math>I-A</math> invertierbar ist, kann der Gesamtbedarf aller Komponenten über die Gleichung
 
:<math>
\mathbf{x}=(I-A)^{-1}\mathbf{y}
</math>
 
bestimmt werden, wobei:
* <math>\mathbf{y}</math> den Vektor der Endprodukte,
* <math>\mathbf{x}</math> den Vektor der insgesamt benötigten Komponentenmengen
 
beschreibt.
 
== Beispiele ==


==Beispiele==
=== Produktion eines Produkts aus Einzelteilen ===
=== 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 <math>B_1,B_2,B_3,B_4,B_5</math> aus vier Einzelteilen <math>E_1,E_2,E_3,E_4</math> 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 benötigte Stückzahl an.
<!-- Variante B: Reines SVG + JS (kein JSXGraph) -->
 
<html>
<html>
<style>
<style>
   .gozinto-wrap { width:95vw; max-width:1000px; height:70vw; max-height:600px; border:0px solid #ccc; }
   .gozinto-wrap {
   svg { width:100%; height:100%; touch-action:none; user-select:none; }
    width:95vw;
   .node-rect { fill:#3498db; stroke:#1f4e78; stroke-width:2; cursor:grab; }
    height:50vw;
   .node-text { font-family: sans-serif; font-size:13px; fill:#000; pointer-events:none; }
    max-width:1100px;
   .edge-line { stroke:#000; stroke-width:2; fill:none; }
    max-height:450px;
   .edge-arrow { fill:#000; }
    border:0;
   .count-circle { fill:#fff; stroke:#000; stroke-width:1.5; }
    margin:0;
   .count-text { font-family:sans-serif; font-size:12px; text-anchor:middle; dominant-baseline:middle; pointer-events:none; }
    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>
</style>


<div class="gozinto-wrap">
<div class="gozinto-wrap">
<svg id="gozinto_svg" viewBox="0 0 1400 700" preserveAspectRatio="xMidYMid meet">
<svg id="gozinto_svg_2"
  <!-- edges will be inserted dynamically -->
    viewBox="0 0 1200 450"
    preserveAspectRatio="xMinYMin meet">
</svg>
</svg>
</div>
</div>
Zeile 44: Zeile 106:
<script>
<script>
(function(){
(function(){
  const svg = document.getElementById('gozinto_svg');


   // Layout scale (convert logical coords to svg px)
const svg=document.getElementById("gozinto_svg_2");
   const scale = 100; // 1 unit = 100px
 
   const yOffset = 50;
const scale=100;
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
  });
 
  const text=svgEl("text",{
    class:"node-text",
    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={};
 
  rect.addEventListener("pointerdown",e=>{
    rect.setPointerCapture(e.pointerId);
    dragging=true;
 
    const p=getSVGcoords(e);
 
    start={
      px:p.x,
      py:p.y,
      cx:node.cx,
      cy:node.cy
    };
  });
 
   rect.addEventListener("pointermove",e=>{
 
    if(!dragging) return;
 
    const p=getSVGcoords(e);
 
    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);
}
 
function intersectRectBorder(node,tx,ty){
 
  const cx=node.cx;
  const cy=node.cy;
 
  const w2=node.w/2;
  const h2=node.h/2;
 
  const dx=tx-cx;
  const 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;
  const 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;
  let 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);
  const Ci=px(pCircleIn);
  const Co=px(pCircleOut);
  const 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];
  let 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);
}
 
const nodes={};
 
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");
 
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");
 
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>
</html>
 
Die Gozintomatrix zum oberen Gozintographen kann aus folgender Tabelle abgeleitet werden:
 
{| class="wikitable"
! !! B1 !! B2 !! B3 !! B4 !! B5
|-
| '''E1''' || 2 || 2 || 1 || 2 || 1
|-
| '''E2''' || 1 || 1 || 1 || 0 || 0
|-
| '''E3''' || 0 || 0 || 1 || 1 || 0
|-
| '''E4''' || 0 || 0 || 0 || 1 || 2
|}
 
und ist 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.
 
=== Produktion von Spielwaren aus Rohstoffen über Zwischenprodukte ===
 
Ein Spielwarenhersteller produziert aus drei Rohstoffen <math>R_1,R_2,R_3</math> zunächst die beiden Zwischenprodukte <math>Z_1,Z_2</math>, aus denen anschließend die drei Endprodukte <math>E_1,E_2,E_3</math> gefertigt werden.
 
Die Pfeile im Gozintographen geben an, wie viele Mengeneinheiten eines Materials zur Produktion einer Mengeneinheit des entstehenden Produkts benötigt werden.
 
<!-- GOZINTOGRAPH: Rohstoffe → Zwischenprodukte → Endprodukte -->
<html>
<style>
  .gozinto-wrap2 {
    width:95vw;
    height:70vw;
    max-width:1200px;
    max-height:800px;
    border:0;
    margin:0;
    padding:0;
  }
 
  .gozinto-wrap2 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-wrap2">
<svg id="gozinto_svg"
    viewBox="0 0 1180 640"
    preserveAspectRatio="xMinYMin meet">
</svg>
</div>
 
<script>
(function(){
 
  const svg = document.getElementById("gozinto_svg");
 
  const scale = 100;
   const yOffset = 0;
  const xOffsetGlobal = 120;


  // Utility: create SVG element
   function svgEl(name, attrs){
   function svgEl(name, attrs){
     const el = document.createElementNS('http://www.w3.org/2000/svg', name);
     const el = document.createElementNS("http://www.w3.org/2000/svg", name);
     for(const k in (attrs||{})) el.setAttribute(k, attrs[k]);
 
     for(const k in (attrs||{}))
      el.setAttribute(k, attrs[k]);
 
     return el;
     return el;
   }
   }


   // Node factory: creates a rect group with fixed size but movable
  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){
   function createNode(id, cx, cy, w, h, label){
     const g = svgEl('g', {class:'node', 'data-id':id});
 
     const rect = svgEl('rect', {
    cx += xOffsetGlobal / scale;
       class:'node-rect',
 
       x: (cx - w/2)*scale, y: (cy - h/2)*scale + yOffset,
     const g = svgEl("g", {"data-id":id});
       width: w*scale, height: h*scale,
 
       rx:6, ry:6
     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
     });
     });
     const text = svgEl('text', {class:'node-text', x: cx*scale, y: cy*scale + yOffset, 'text-anchor':'middle', 'dominant-baseline':'middle'});
 
     const text = svgEl("text", {
      class:"node-text",
      x:cx*scale,
      y:cy*scale+yOffset,
      "text-anchor":"middle",
      "dominant-baseline":"middle"
    });
 
     text.textContent = label;
     text.textContent = label;


     g.appendChild(rect);
     g.appendChild(rect);
     g.appendChild(text);
     g.appendChild(text);
     svg.appendChild(g);
     svg.appendChild(g);


    // state
     const node = {id,cx,cy,w,h,rect,text,g};
     const node = {
 
      id, cx, cy, w, h, g, rect, text
     // Dragging
     };
 
    let dragging=false,start={};


     // dragging
     rect.addEventListener("pointerdown", e=>{
    let dragging = false;
    let start = null;


    rect.addEventListener('pointerdown', function(e){
       rect.setPointerCapture(e.pointerId);
       rect.setPointerCapture(e.pointerId);
       dragging = true;
 
       start = {x:e.clientX, y:e.clientY, cx:node.cx, cy:node.cy};
       dragging=true;
 
      const p=getSVGcoords(e);
 
       start={
        px:p.x,
        py:p.y,
        cx:node.cx,
        cy:node.cy
      };
     });
     });
     rect.addEventListener('pointermove', function(e){
 
     rect.addEventListener("pointermove", e=>{
 
       if(!dragging) return;
       if(!dragging) return;
       const dx = (e.clientX - start.x)/scale;
 
       const dy = (e.clientY - start.y)/scale;
       const p=getSVGcoords(e);
       node.cx = start.cx + dx;
 
      node.cy = start.cy + dy;
       node.cx=start.cx+(p.x-start.px)/scale;
       node.cy=start.cy+(p.y-start.py)/scale;
 
       updateNode(node);
       updateNode(node);
       updateAllEdges();
       updateAllEdges();
     });
     });
     rect.addEventListener('pointerup', function(e){
 
       dragging = false;
     rect.addEventListener("pointerup", e=>{
 
       dragging=false;
 
       rect.releasePointerCapture(e.pointerId);
       rect.releasePointerCapture(e.pointerId);
     });
     });
    rect.addEventListener('pointercancel', function(e){ dragging=false; });


     return node;
     return node;
   }
   }


   function updateNode(node){
   function updateNode(n){
     node.rect.setAttribute('x', (node.cx - node.w/2)*scale);
 
     node.rect.setAttribute('y', (node.cy - node.h/2)*scale + yOffset);
     n.rect.setAttribute("x",(n.cx-n.w/2)*scale);
     node.text.setAttribute('x', node.cx*scale);
     n.rect.setAttribute("y",(n.cy-n.h/2)*scale+yOffset);
     node.text.setAttribute('y', node.cy*scale + yOffset);
 
     n.text.setAttribute("x",n.cx*scale);
     n.text.setAttribute("y",n.cy*scale+yOffset);
   }
   }


   // compute intersection of ray center->target with rectangle border (axis-aligned)
   // -------------------------------------------------
   function intersectRectBorder(node, targetX, targetY){
  // GEOMETRIE
     const cx = node.cx, cy = node.cy;
  // -------------------------------------------------
    const dx = targetX - cx, dy = targetY - cy;
 
     const xMin = node.cx - node.w/2, xMax = node.cx + node.w/2;
   function intersectRectBorder(node, tx, ty){
     const yMin = node.cy - node.h/2, yMax = node.cy + node.h/2;
 
     let tCandidates = [];
     const cx=node.cx;
     if(Math.abs(dx) > 1e-9){
    const cy=node.cy;
       let t1 = (xMin - cx)/dx;
 
       let y1 = cy + t1*dy;
     const w2=node.w/2;
       if(t1>0 && y1>=yMin-1e-9 && y1<=yMax+1e-9) tCandidates.push({t:t1,x:xMin,y:y1});
    const h2=node.h/2;
       let t2 = (xMax - cx)/dx;
 
       let y2 = cy + t2*dy;
     const dx=tx-cx;
       if(t2>0 && y2>=yMin-1e-9 && y2<=yMax+1e-9) tCandidates.push({t:t2,x:xMax,y:y2});
    const 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 = (yMin - cy)/dy;
     if(Math.abs(dy)>1e-9){
       let x3 = cx + t3*dx;
 
       if(t3>0 && x3>=xMin-1e-9 && x3<=xMax+1e-9) tCandidates.push({t:t3,x:x3,y:yMin});
       let t3=(-h2)/dy;
       let t4 = (yMax - cy)/dy;
       let x3=cx+t3*dx;
       let x4 = cx + t4*dx;
 
       if(t4>0 && x4>=xMin-1e-9 && x4<=xMax+1e-9) tCandidates.push({t:t4,x:x4,y:yMax});
       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});
     }
     }
    if(tCandidates.length===0) return {x:cx,y:cy};
 
     tCandidates.sort((a,b)=>a.t-b.t);
     pts.sort((a,b)=>a.t-b.t);
     return {x:tCandidates[0].x, y:tCandidates[0].y};
 
     return pts[0] || {x:cx,y:cy};
   }
   }


  // circle boundary point toward target
   function pointOnCircle(cx,cy,R,tx,ty){
   function pointOnCircle(cx, cy, R, tx, ty){
 
     const dx = tx - cx, dy = ty - cy;
     const dx=tx-cx;
     const d = Math.sqrt(dx*dx + dy*dy);
    const dy=ty-cy;
     if(d < 1e-9) return {x:cx, y:cy};
 
     return {x: cx + R*dx/d, y: cy + R*dy/d};
     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
    };
   }
   }


  // arrowhead path (triangle) at (x,y) pointing to direction (ux,uy)
   function makeArrowHead(x,y,ux,uy,size){
   function makeArrowHead(x, y, ux, uy, size){
 
    // perpendicular
     let px=-uy;
     const px = -uy, py = ux;
    let py=ux;
     const p1x = x, p1y = y;
 
    const p2x = x - ux*size + px*size*0.5;
     return `M ${x} ${y}
    const p2y = y - uy*size + py*size*0.5;
            L ${x-ux*size+px*size*0.5} ${y-uy*size+py*size*0.5}
    const p3x = x - ux*size - px*size*0.5;
            L ${x-ux*size-px*size*0.5} ${y-uy*size-py*size*0.5} Z`;
    const p3y = y - uy*size - py*size*0.5;
    return `M ${p1x} ${p1y} L ${p2x} ${p2y} L ${p3x} ${p3y} Z`;
   }
   }


   // Edge structure: {fromNode, toNode, amount, circle, lineA, lineB, arrow}
   // -------------------------------------------------
   const edges = [];
  // KANTEN
  // -------------------------------------------------
 
   const edges=[];


   function makeConnection(fromNode, toNode, amount, yMid, xOffset){
   function makeConnection(fromNode,toNode,amount,yMid,xOffset){
     const group = svgEl('g', {});
 
     const circle = svgEl('circle', {class:'count-circle'});
     const g=svgEl("g",{});
     const text = svgEl('text', {class:'count-text'});
 
     const lineA = svgEl('path', {class:'edge-line', fill:'none'}); // from rect -> circle (path to allow potential future styling)
     const lineA=svgEl("path",{class:"edge-line"});
     const lineB = svgEl('path', {class:'edge-line', fill:'none'});
     const lineB=svgEl("path",{class:"edge-line"});
     const arrow = svgEl('path', {class:'edge-arrow'});
 
     group.appendChild(lineA);
     const circle=svgEl("circle",{
     group.appendChild(lineB);
      class:"count-circle"
     group.appendChild(circle);
    });
     group.appendChild(text);
 
     group.appendChild(arrow);
     const text=svgEl("text",{
     svg.appendChild(group);
      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
    };


    const e = {fromNode, toNode, amount, circle, text, lineA, lineB, arrow, yMid, xOffset};
     edges.push(e);
     edges.push(e);
     updateEdge(e);
     updateEdge(e);
   }
   }


   function updateEdge(e){
   function updateEdge(e){
    // circle center is midpoint between centers with offset
    const cx = (e.fromNode.cx + e.toNode.cx)/2 + (e.xOffset||0);
    const cy = e.yMid;
    const R = 0.35;
    // compute in logical coords
    const pFrom = intersectRectBorder(e.fromNode, cx, cy);
    const pTo  = intersectRectBorder(e.toNode, cx, cy);
    const cIn = pointOnCircle(cx, cy, R, pFrom.x, pFrom.y);
    const cOut = pointOnCircle(cx, cy, R, pTo.x, pTo.y);


     // convert to px
     const cx=(e.fromNode.cx+e.toNode.cx)/2+(e.xOffset||0);
    function px(p){ return [p.x*scale, p.y*scale + yOffset]; }
     const cy=e.yMid;
     const pf = px(pFrom), pcIn = px(cIn), pcOut = px(cOut), pt = px(pTo);


     // line A: from rect edge -> circle edge (no arrow)
     const R=0.14;
    lineAPath = `M ${pf[0]} ${pf[1]} L ${pcIn[0]} ${pcIn[1]}`;
    e.lineA.setAttribute('d', lineAPath);


     // line B: circle edge -> rect edge (arrowhead drawn separately)
     const pF=intersectRectBorder(e.fromNode,cx,cy);
     e.lineB.setAttribute('d', `M ${pcOut[0]} ${pcOut[1]} L ${pt[0]} ${pt[1]}`);
     const pT=intersectRectBorder(e.toNode,cx,cy);


     // circle
     const pCircleIn=pointOnCircle(cx,cy,R,pF.x,pF.y);
    e.circle.setAttribute('cx', (cx*scale));
     const pCircleOut=pointOnCircle(cx,cy,R,pT.x,pT.y);
     e.circle.setAttribute('cy', (cy*scale + yOffset));
    e.circle.setAttribute('r', R*scale);
    e.circle.setAttribute('class','count-circle');


     // text
     const px=p=>[p.x*scale,p.y*scale+yOffset];
     e.text.setAttribute('x', cx*scale);
 
     e.text.setAttribute('y', cy*scale + yOffset);
    const F=px(pF);
     e.text.textContent = e.amount;
    const Ci=px(pCircleIn);
    const Co=px(pCircleOut);
    const 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];
    let uy=T[1]-Co[1];
 
    let L=Math.sqrt(ux*ux+uy*uy);


    // arrow head: compute unit vector from cOut -> pTo
    var ux = (pt[0]-pcOut[0]), uy = (pt[1]-pcOut[1]);
    var L = Math.sqrt(ux*ux + uy*uy);
     if(L<1e-6) L=1;
     if(L<1e-6) L=1;
     ux/=L; uy/=L;
 
     const arrowSize = 12;
     ux/=L;
    const arrowPath = makeArrowHead(pt[0], pt[1], ux, uy, arrowSize);
    uy/=L;
    e.arrow.setAttribute('d', arrowPath);
 
     e.arrow.setAttribute('class','edge-arrow');
     e.arrow.setAttribute(
      "d",
      makeArrowHead(T[0],T[1],ux,uy,10)
    );
  }
 
  function updateAllEdges(){
     edges.forEach(updateEdge);
   }
   }


   // create nodes (logical coords)
   // -------------------------------------------------
   const nodes = {};
   // NODES
   nodes.E1 = createNode('E1', 0, 6.8, 1.0, 0.6, 'E1');
   // -------------------------------------------------
   nodes.E2 = createNode('E2', 2.5, 6.8, 1.0, 0.6, 'E2');
 
  nodes.E3 = createNode('E3', 5, 6.8, 1.0, 0.6, 'E3');
   const nodes={};
   nodes.E4 = createNode('E4', 7.5, 6.8, 1.0, 0.6, 'E4');
 
   // Rohstoffe


   nodes.B1 = createNode('B1', 0.75, 3, 1.0, 0.6, 'B1');
   nodes.R1=createNode("R1",0,0.8,1.0,0.5,"R1");
   nodes.B2 = createNode('B2', 2.5, 3, 1.0, 0.6, 'B2');
   nodes.R2=createNode("R2",2.5,0.8,1.0,0.5,"R2");
  nodes.B3 = createNode('B3', 5, 3, 1.0, 0.6, 'B3');
   nodes.R3=createNode("R3",5.0,0.8,1.0,0.5,"R3");
   nodes.B4 = createNode('B4', 7.5, 3, 1.0, 0.6, 'B4');
  nodes.B5 = createNode('B5', 10, 3, 1.0, 0.6, 'B5');


   // create edges (with small xOffsets to avoid overlap)
   // Zwischenprodukte
  makeConnection(nodes.E1, nodes.B1, '2', 5.6, -0.2);
  makeConnection(nodes.E2, nodes.B1, '1', 5.6,  0.2);


   makeConnection(nodes.E1, nodes.B2, '2', 5.6, -0.2);
   nodes.Z1=createNode("Z1",1.2,3.2,1.0,0.5,"Z1");
   makeConnection(nodes.E2, nodes.B2, '1', 5.6, 0.2);
   nodes.Z2=createNode("Z2",3.6,3.2,1.0,0.5,"Z2");


   makeConnection(nodes.E1, nodes.B3, '1', 5.6, -0.3);
   // Endprodukte
  makeConnection(nodes.E2, nodes.B3, '1', 5.6,  0.0);
  makeConnection(nodes.E3, nodes.B3, '1', 5.6,  0.3);


   makeConnection(nodes.E1, nodes.B4, '2', 5.6, -0.3);
   nodes.E1=createNode("E1",0.5,5.6,1.0,0.5,"E1");
   makeConnection(nodes.E3, nodes.B4, '1', 5.6, 0.0);
   nodes.E2=createNode("E2",2.8,5.6,1.0,0.5,"E2");
   makeConnection(nodes.E4, nodes.B4, '1', 5.6, 0.3);
   nodes.E3=createNode("E3",5.1,5.6,1.0,0.5,"E3");


   makeConnection(nodes.E1, nodes.B5, '1', 5.6, -0.2);
   // -------------------------------------------------
   makeConnection(nodes.E4, nodes.B5, '2', 5.6,  0.2);
   // VERBINDUNGEN
  // -------------------------------------------------


   // update all edges
   // Rohstoffe -> Zwischenprodukte
  function updateAllEdges(){ edges.forEach(e=>updateEdge(e)); }


   // initial update
   makeConnection(nodes.R1,nodes.Z1,"3",1.8,-0.3);
   updateAllEdges();
   makeConnection(nodes.R1,nodes.Z2,"1",1.8,0.4);


   // re-update edges also when window resizes (visual)
   makeConnection(nodes.R2,nodes.Z1,"4",1.8,-0.2);
  window.addEventListener('resize', updateAllEdges);
  makeConnection(nodes.R2,nodes.Z2,"2",1.8,0.2);
})();
</script>
</html>


== Beispiel 2: Rezeptstruktur eines Gerichts ==
  makeConnection(nodes.R3,nodes.Z2,"3",1.8,0.0);
<html>
<div id="gozinto2" style="width:90vw; max-width:700px; height:60vw; max-height:500px; margin-top:20px;"></div>
<script>
var brd2 = JXG.JSXGraph.initBoard('gozinto2', {
    boundingbox: [-1, 8, 10, -1],
    axis: false,
    showNavigation: false,
    showCopyright: false
});


function box2(x1,y1,x2,y2,text){
  // Zwischenprodukte -> Endprodukte
    var poly = brd2.create('polygon',[[x1,y1],[x2,y1],[x2,y2],[x1,y2]],{
        fillColor:'#3498db',fillOpacity:0.8,vertices:{visible:false},
        borders:{strokeColor:'#1f4e78',strokeWidth:2}
    });
    brd2.create('text',[(x1+x2)/2,(y1+y2)/2,text],
        {anchorX:'middle',anchorY:'middle',strokeColor:'white',fontSize:14});
    return poly;
}


// Zutaten
  makeConnection(nodes.Z1,nodes.E1,"2",4.4,-0.2);
var M=box2(0,6,1.5,7,'Mehl');
  makeConnection(nodes.Z1,nodes.E2,"1",4.4,0.2);
var W=box2(2,6,3.5,7,'Wasser');
var H=box2(4,6,5.5,7,'Hefe');
var T=box2(2,3.5,3.5,4.5,'Teig');
var S=box2(5,3.5,6.5,4.5,'Soße');
var P=box2(3,1,4.5,2,'Pizza');


// Pfeile mit Kreisen
  makeConnection(nodes.Z2,nodes.E1,"1",4.4,-0.3);
function edge2(from,to,label){
  makeConnection(nodes.Z2,nodes.E2,"3",4.4,0.0);
    var midX=(from[0]+to[0])/2;
  makeConnection(nodes.Z2,nodes.E3,"2",4.4,0.3);
    var midY=(from[1]+to[1])/2;
    var dirX=(to[0]-from[0]);
    var dirY=(to[1]-from[1]);
    var len=Math.sqrt(dirX*dirX+dirY*dirY);
    var ux=dirX/len, uy=dirY/len;
    var gap=0.3;
    var p1=[midX-ux*gap, midY-uy*gap];
    var p2=[midX+ux*gap, midY+uy*gap];
    brd2.create('arrow',[from,p1],{strokeColor:'#000',strokeWidth:1.5});
    brd2.create('arrow',[p2,to],{strokeColor:'#000',strokeWidth:1.5});
    brd2.create('circle',[ [midX,midY],0.2 ],{fillColor:'white',strokeColor:'black'});
    brd2.create('text',[midX,midY,label],{anchorX:'middle',anchorY:'middle',fontSize:11});
}


// Beziehungen
  updateAllEdges();
edge2([0.75,6],[2.75,4.5],'2'); // Mehl->Teig
edge2([2.75,6],[2.75,4.5],'1'); // Wasser->Teig
edge2([4.75,6],[2.75,4.5],'0.5'); // Hefe->Teig


edge2([2.75,4.5],[3.75,2],'1'); // Teig->Pizza
})();
edge2([5.75,4.5],[3.75,2],'1'); // Soße->Pizza
</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
|}


=== Rezeptstruktur eines Gerichts ===
Aus diesen Tabellen ergibt sich die '''Gozintomatrix Rohstoffe → Endprodukte''' durch Matrixmultiplikation:
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. 
Auch hier zeigen Pfeile mit Zahlen, welche Mengen von Zutaten in die jeweiligen Komponenten eingehen.


<html>
:<math>
<div id="gozinto2" style="width:90vw; max-width:600px; height:60vw; max-height:500px; margin-top:20px;"></div>
RZ=
<script>
\begin{pmatrix}
var brd2 = JXG.JSXGraph.initBoard('gozinto2', {
3 & 1 \\
    boundingbox: [-1, 8, 10, -1],
4 & 2 \\
    axis: false,
0 & 3
    showCopyright: false,
\end{pmatrix}
    showNavigation: false
</math>
});


function box2(x1,y1,x2,y2,color){
:<math>
    return brd2.create('polygon',[[x1,y1],[x2,y1],[x2,y2],[x1,y2]],{
ZE=
        fillColor:color,fillOpacity:0.8,vertices:{visible:false},borders:{strokeColor:'#333'}
\begin{pmatrix}
    });
2 & 1 & 0 \\
}
1 & 3 & 2
\end{pmatrix}
</math>


var M1=box2(0,6,1,7,'#e67e22'); // Mehl
:<math>
var W1=box2(2,6,3,7,'#e67e22'); // Wasser
RE=RZ \cdot ZE
var H1=box2(4,6,5,7,'#e67e22'); // Hefe
=
var T1=box2(1,3,2,4,'#3498db'); // Teig
\begin{pmatrix}
var T2=box2(5,3,6,4,'#3498db'); // Soße
3 & 1 \\
var T3=box2(3,1,4,2,'#2ecc71'); // Pizza
4 & 2 \\
0 & 3
\end{pmatrix}
\cdot
\begin{pmatrix}
2 & 1 & 0 \\
1 & 3 & 2
\end{pmatrix}
</math>


brd2.create('text',[0.4,7.2,'Mehl']);
Berechnung:
brd2.create('text',[2.4,7.2,'Wasser']);
brd2.create('text',[4.4,7.2,'Hefe']);
brd2.create('text',[1.4,4.2,'Teig']);
brd2.create('text',[5.4,4.2,'Soße']);
brd2.create('text',[3.4,2.2,'Pizza']);


function arrow2(fromX, fromY, toX, toY, label){
:<math>
    brd2.create('arrow',[[fromX,fromY],[toX,toY]],{strokeColor:'#555'});
RE=
    brd2.create('text',[(fromX+toX)/2,(fromY+toY)/2+0.2,label],{fontSize:10});
\begin{pmatrix}
}
7 & 6 & 2 \\
10 & 10 & 4 \\
3 & 9 & 6
\end{pmatrix}
</math>


// Zutaten -> Teig
Die Matrix zeigt, wie viele Mengeneinheiten der Rohstoffe <math>R_1,R_2,R_3</math> jeweils zur Herstellung einer Einheit der Endprodukte <math>E_1,E_2,E_3</math> notwendig sind.
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');
// Teig + Soße -> Pizza
arrow2(1.5,3,3.5,2,'1');
arrow2(5.5,3,3.5,2,'1');
</script>
</html>


[[Kategorie:Lineare_Algebra]]
[[Kategorie:Lineare_Algebra]]
[[Kategorie:AHR_WuV_Mathe_GK]]
[[Kategorie:AHR_WuV_Mathe_GK]]

Aktuelle Version vom 27. Mai 2026, 10:30 Uhr

Ein Gozintograph (von engl. goes into = „geht hinein“) ist ein gerichteter Graph, der die Zerlegung eines Endprodukts in seine Einzelteile oder Komponenten beschreibt. Jede Kante stellt dabei eine „Gozinto“-Beziehung dar: Sie zeigt von einer Komponente auf das Produkt, in das sie eingeht. Der Gozintograph ist ein zentrales Hilfsmittel in der Produktionsplanung und Stücklistenverwaltung.

Definition

Ein Gozintograph ist ein gerichteter, azyklischer Graph

[math]\displaystyle{ G=(V,E) }[/math]

mit:

  • [math]\displaystyle{ V }[/math] als Menge der Knoten (Produkte oder Komponenten),
  • [math]\displaystyle{ E \subseteq V \times V }[/math] als Menge der gerichteten Kanten.

Zusätzlich besitzt jede Kante ein Gewicht [math]\displaystyle{ a_{ij} \in \mathbb{N} }[/math]. Eine Kante [math]\displaystyle{ (v_i,v_j)\in E }[/math] mit Gewicht [math]\displaystyle{ a_{ij} }[/math] bedeutet, dass zur Herstellung des Produkts [math]\displaystyle{ v_j }[/math] genau [math]\displaystyle{ a_{ij} }[/math] Einheiten der Komponente [math]\displaystyle{ v_i }[/math] benötigt werden.

Da rekursive Stücklisten ausgeschlossen werden, enthält ein Gozintograph keine Zyklen.

Zusammenhang zu Matrizen

Die Informationen eines Gozintographen lassen sich in einer sogenannten Gozintomatrix darstellen.

Dies ist eine Matrix

[math]\displaystyle{ A=(a_{ij}) }[/math]

bei der das Element [math]\displaystyle{ a_{ij} }[/math] die Anzahl der Einheiten der Komponente [math]\displaystyle{ i }[/math] angibt, die unmittelbar zur Herstellung des Produkts [math]\displaystyle{ j }[/math] benötigt werden.

Unter der Voraussetzung, dass der Gozintograph zyklusfrei ist und [math]\displaystyle{ I-A }[/math] invertierbar ist, kann der Gesamtbedarf aller Komponenten über die Gleichung

[math]\displaystyle{ \mathbf{x}=(I-A)^{-1}\mathbf{y} }[/math]

bestimmt werden, wobei:

  • [math]\displaystyle{ \mathbf{y} }[/math] den Vektor der Endprodukte,
  • [math]\displaystyle{ \mathbf{x} }[/math] den Vektor der insgesamt benötigten Komponentenmengen

beschreibt.

Beispiele

Produktion eines Produkts aus Einzelteilen

Im folgenden Beispiel werden fünf Bauteile [math]\displaystyle{ B_1,B_2,B_3,B_4,B_5 }[/math] aus vier Einzelteilen [math]\displaystyle{ E_1,E_2,E_3,E_4 }[/math] gefertigt. Die Pfeile zeigen, welche Einzelteile in welches Bauteil eingehen. Die Zahlen an den Pfeilen geben die benötigte Stückzahl an.

Die Gozintomatrix zum oberen Gozintographen kann aus folgender Tabelle abgeleitet werden:

B1 B2 B3 B4 B5
E1 2 2 1 2 1
E2 1 1 1 0 0
E3 0 0 1 1 0
E4 0 0 0 1 2

und ist durch

[math]\displaystyle{ 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.

Produktion von Spielwaren aus Rohstoffen über Zwischenprodukte

Ein Spielwarenhersteller produziert aus drei Rohstoffen [math]\displaystyle{ R_1,R_2,R_3 }[/math] zunächst die beiden Zwischenprodukte [math]\displaystyle{ Z_1,Z_2 }[/math], aus denen anschließend die drei Endprodukte [math]\displaystyle{ E_1,E_2,E_3 }[/math] gefertigt werden.

Die Pfeile im Gozintographen geben an, wie viele Mengeneinheiten eines Materials zur Produktion einer Mengeneinheit des entstehenden Produkts benötigt werden.

Die vollständigen Mengen seien wie folgt definiert:

Z1 Z2
R1 3 1
R2 4 2
R3 0 3
E1 E2 E3
Z1 2 1 0
Z2 1 3 2

Aus diesen Tabellen ergibt sich die Gozintomatrix Rohstoffe → Endprodukte durch Matrixmultiplikation:

[math]\displaystyle{ RZ= \begin{pmatrix} 3 & 1 \\ 4 & 2 \\ 0 & 3 \end{pmatrix} }[/math]
[math]\displaystyle{ ZE= \begin{pmatrix} 2 & 1 & 0 \\ 1 & 3 & 2 \end{pmatrix} }[/math]
[math]\displaystyle{ 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]\displaystyle{ RE= \begin{pmatrix} 7 & 6 & 2 \\ 10 & 10 & 4 \\ 3 & 9 & 6 \end{pmatrix} }[/math]

Die Matrix zeigt, wie viele Mengeneinheiten der Rohstoffe [math]\displaystyle{ R_1,R_2,R_3 }[/math] jeweils zur Herstellung einer Einheit der Endprodukte [math]\displaystyle{ E_1,E_2,E_3 }[/math] notwendig sind.

Abgerufen von „https://wiki.flbk-hamm.de/index.php?title=Gozintograph&oldid=2890“