FLBK-Wiki - Benutzerbeiträge [de]

Hauptsatz der Differential- und Integralrechnung

2026-07-11T08:07:23Z

Flbkwikiadmin: /* Definition */

Mit Hilfe des Hauptsatzes der Differential- und Integralrechnung werden Flächeninhalte zwischen dem [[Graph|Graphen]] einer [[Funktion]] der x-Achse berechnet.

==Flächeninhaltsfunktion und Stammfunktion==
Der Flächeninhalt zwischen dem Graphen einer Funktion <math>f</math> und der x-Achse im Intervall <math>[0;x]</math> wird durch den Funktionswert einer '''Flächeninhaltsfunktion''' <math>A</math> ermittelt.

Es sei <math>F</math> die [[Stammfunktion]] zu einer [[ganzrationale_Funktion|ganzrationalen Funktion]] <math>f</math> mit der Konstanten <math>C=0</math>, dann ist <math>F</math> die Flächeninhaltsfunktion zu <math>f</math>.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/r-iUbclLabI?si=a5pPkIEuYHEhuoWi" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe></html>

==Bestimmtes Integral==
Das '''bestimmte Integral''' einer [[Stetige_Funktion|stetigen Funktion]] <math>f</math> auf dem Intervall <math>[a; b]</math> ist durch
:<math>\int_a^b f(x) \, dx</math>
gegeben.

Für auf den Intervallen <math>[a;b] \subseteq [a;c]</math> und <math>[b;c] \subseteq [a;c]</math> stetige Funktionen <math>f, ~g</math> gelten die folgenden Rechenregeln:
===Faktorregel===
:<math>\int_a^b c \cdot f(x) \, dx=c \cdot \int_a^b f(x) \, dx</math>
===Summenregel===
:<math>\int_a^b (f(x)+g(x)) \, dx = \int_a^b f(x) \, dx + \int_a^bg(x) \, dx</math>
===Intervalladditivität===
:<math>\int_a^c f(x) \, dx=\int_a^b f(x) \, dx+\int_b^c f(x) \, dx</math>

===Vertauschen der Integrationsgrenzen===
:<math>\int_a^b f(x) \, dx=-\int_b^a f(x) \, dx</math>

==Definition==
Falls <math>F</math> eine [[Stammfunktion]] von <math>f</math> ist, so wird das bestimmte Integral von <math>f</math> auf dem Intervall <math>[a;b]</math> durch die Gleichung
:<math>\int_a^b f(x) \, dx = F(b) - F(a)</math>
berechnet.

Hierbei bezeichnet <math>a</math> die untere und <math>b</math> die obere Grenze des Integrals. Das bestimmte Integral gibt den '''orientierten Flächeninhalt''' an, das heißt:
* Liegt der Graph von <math>f</math> oberhalb der x-Achse, ist das bestimmte Integral positiv.
* Liegt der Graph von <math>f</math> unterhalb der x-Achse, ist das bestimmte Integral negativ.
* Liegt der Graph von <math>f</math> sowohl unterhalb als auch oberhalb der x-Achse, ist das bestimmte Integral die Differenz aus dem oberen Flächeninhalt und dem unteren Flächeninhalt.

<html>
<head>
<link rel="stylesheet" href="/localassets/jsxgraph/jsxgraph.css">
<script src="/localassets/jsxgraph/jsxgraphcore.js"></script>

</head>
<body>
<div id="box2" style="width: 90vw; max-width: 400px; height: 60vw; max-height: 300px; margin-top:20px;"></div>
<script type="text/javascript">
JXG.Options.text.useMathJax = true;
// JSXGraph-Board erstellen
var board = JXG.JSXGraph.initBoard('box2', {
boundingbox: [-5, 5, 10, -5], // Angepasste Boundingbox für die Skalierung
axis: true,
showCopyright: false,
showNavigation: true,
grid: true, // Gitternetz aktivieren
defaultAxes: {
x: {
withLabel: true,
name: '\\[t\\]',
label: {
position: 'rt',
offset: [-5, 20],
fontSize: 14,
anchorX: 'right'
},
ticks: {
ticksDistance: 1,
minorTicks: 0
}
},
y: {
withLabel: true,
name: '\\[f(t)\\]',
label: {
position: 'rt',
offset: [5, 20],
fontSize: 14,
anchorY: 'right'
},
ticks: {
ticksDistance: 1,
minorTicks: 0
}
}
}
});

// Funktion erstellen
var c1 = board.create('functiongraph', [function(t) {
return (Math.pow(t, 5) / 24 - Math.pow(t, 3) / 2 + t);
}]);

// Integral erstellen
var i1 = board.create('integral', [
[-2.0, 2.0], c1
], {
withLabel: true,
label: {
fontSize: 14,
offset: [0, 50],
digits: 4,
intl: {
enabled: false,
options: {}
}
},
baseLeft: { // Start point
visible: true,
fixed: false,
withLabel: true,
name: 'a'
},
baseRight: { // End point
visible: true,
fixed: false,
withLabel: true,
name: 'b'
}
});

// Integral-Label anpassen
i1.label.setText(() => {
const a = i1.baseLeft.X().toFixed(2); // Untere Grenze
const b = i1.baseRight.X().toFixed(2); // Obere Grenze
const value = i1.Value().toFixed(4); // Wert des Integrals
return `\\[\\int_{${a}}^{${b}} f(t) \\, dt = ${value}\\]`;
});

// Beschriftung der Funktion mit f
board.create('text', [3.5, 3, '\\[f\\]'], {
fontSize: 14,
fixed: true,
anchorX: 'left',
anchorY: 'bottom',
color: 'blue'
});
</script>
</body>
</html>

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/Lc_R0vBSKHw?si=V72WfOUjhQRQlrN9" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

<html><iframe width="280" height="157,5" src="https://www.youtube.com/embed/MX_WQS5-vAg?si=N2TxoCi_PHsr1_1B" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe></html>

==Integralfunktion==
Es sei <math>f</math> eine auf dem Intervall <math>[a;b]</math> [[stetige Funktion]], dann ist
:<math>I_a(x)=\int_a^x f(t) \, dt</math>
die dazugehörige '''Integralfunktion'''.

==Flächen zwischen Funktionsgraphen ermitteln==
Es seien <math>f, ~g</math> auf dem Intervall <math>[a;b]</math> stetige Funktionen. Die Fläche zwischen den Graphen von <math>f, ~g</math> wird wie folgt ermittelt:
# Schnittstellen <math>x_{S_1},\dots,x_{S_n}</math> mit <math>n \in \mathbb{N}</math> der Graphen von <math>f, ~g</math> ermitteln.
# Stammfunktionen <math>F,~G</math> ermitteln
# <math>A=|\int_{x_{S_1}}^{x_{S_2}}(f(x)-g(x)) \, dx|+|\int_{x_{S_2}}^{x_{S_3}}(f(x)-g(x)) \, dx|+\dots+|\int_{x_{S_{n-1}}}^{x_{S_n}}(f(x)-g(x)) \, dx|</math> berechnen. (siehe [[Betragsfunktion]])

==Beispiele==

===Flächeninhalt ermitteln===
[[Datei:HauptsatzIntBspx2.gif|mini|Das bestimmte Integral der Funktion <span style="color:blue"><math>f(x)=x^2</math></span> auf dem Intervall <math>[1;2] </math> berechnet sich durch <span style="color:green"><math>\int_1^2 x^2 \, dx=\frac{7}{3}</math></span>.]]

Wir berechnen das bestimmte Integral von <math>f(x) = x^2</math> auf dem Intervall <math>[1;2]</math>.
Eine Stammfunktion von <math>f</math> ist <math>F(x) = \frac{x^3}{3}</math>.
Das bestimmte Integral auf dem Intervall [1;2] wird durch
:<math>\int_1^2 x^2 \, dx = F(2) - F(1)</math>
:<math>= \frac{2^3}{3} - \frac{1^3}{3} = \frac{8}{3} - \frac{1}{3} = \frac{7}{3}</math>
berechnet.
Der Graph von <math>f</math> verläuft auf dem Intervall <math>[1;2]</math> oberhalb der x-Achse. Der Flächeninhalt beträgt somit <math>\frac{7}{3}</math> Einheiten und ist im rechten Bild grün eingezeichnet.

Wir berechnen den Flächeninhalt zwischen dem Graphen von $f(t)=\frac{t^5}{24}-\frac{t^3}{2}+t$ und der x-Achse auf dem Intervall <math>[-2;2]</math> (siehe [[Hauptsatz_der_Differential-_und_Integralrechnung#Definition|Graph von <math>f</math>]]).

1. Nullstellen von <math>f</math> berechnen
:<math>\frac{t^5}{24}-\frac{t^3}{2}+t=0</math>
:<math>t \approx -3,08 \lor t \approx -1,59 \lor t \approx 0 \lor t \approx 1,59 \lor t \approx 3,08</math>
:<math>-1,59; 0; 1,59 \in [-2;2]</math>
2. Flächeninhalt ermitteln
:<math>A=|\int_{-2}^{-1,59} f(t) \, dt|+|\int_{-1,59}^{0} f(t) \, dt|+|\int_{0}^{1,59} f(t) \, dt|+|\int_{1,59}^{2} f(t) \, dt| </math>
:<math>\approx |0,13|+|-0,58|+|0,58|+|-0,13| = 0,13+0,58+0,58+0,13= 1,42</math>
Der gesuchte Flächeninhalt beträgt <math>A=1,42</math>. Der orientierte Flächeninhalt auf dem Intervall <math>[-2;2]</math> beträgt <math>\int_{-2}^{2} f(t) \, dt=0</math>.

===Orientierten Flächeninhalt ermitteln===
[[Datei:HauptsatzIntBspx.gif|mini|Das bestimmte Integral der Funktion <span style="color:blue"><math>f(x)=x</math></span> auf dem Intervall <math>[-1;1] </math> berechnet sich durch <math>\int_{-1}^1 x \, dx=</math><span style="color:green"><math>\frac{1}{2}</math></span><span style="color:red"><math>-</math><math>\frac{1}{2}</math></span><math>=0</math>.]]

Wir betrachten <math>f(x) = x</math> auf dem Intervall <math>[-1;1]</math>.
Eine Stammfunktion von <math>f</math> ist <math>F(x) = \frac{x^2}{2}</math>.
Das bestimmte Integral ist:
:<math>\int_{-1}^1 x \, dx = F(1) - F(-1)</math>
:<math>= \frac{1^2}{2} - \frac{(-1)^2}{2} = \frac{1}{2} - \frac{1}{2} = 0</math>.
Der orientierte Flächeninhalt beträgt <math>0</math>, da sich die positiven und negativen Flächeninhalte genau ausgleichen.

===Integralfunktion ermitteln===
Gegeben sei <math>f(x) = 3x</math> und <math>a = 0</math>.
Die Integralfunktion ist:
:<math>I_0(x) = \int_0^x 3t \, dt</math>.
Eine Stammfunktion von <math>3t</math> ist <math>\frac{3t^2}{2}</math>, also gilt
:<math>I_0(x) = \frac{3x^2}{2} - \frac{3 \cdot 0^2}{2} = \frac{3x^2}{2}</math>.

===Flächeninhalt zwischen den Graphen von zwei Funktionen ermitteln===
[[Datei:HauptsatzIntFlächenZwGraphen.gif|mini|Fläche zwischen den Graphen von zwei Funktionen ermitteln]]

Wir betrachten die Funktionen <math>f(x)=x^2+1</math> und <math>g(x)=-x^2+3</math> und ermitteln die Fläche zwischen den Graphen der Funktionen.

1. Schnittstellen von <math>g,~f</math> ermitteln <br>
:<math>f(x)=g(x)</math>
:<math>x^2+1=-x^2+3</math>
:<math>2 \cdot x^2=2</math>
:<math> x^2=1</math>
:<math> x=\pm \sqrt{1}</math>
:<math>x=\pm 1</math>
2. Stammfunktionen ermitteln
:<math>F(x)=\frac{1}{3}x^3+x</math>
:<math>G(x)=-\frac{1}{3}x^3+3x</math>
3. Flächeninhalt ermitteln
:<math>\int_{-1}^{1}(f(x)-g(x)) \, dx=F(1)-G(1)-(F(-1)-G(-1))</math>
:<math>=\frac{1}{3} \cdot 1^3+1-(-\frac{1}{3}\cdot 1^3+3 \cdot 1)</math>
:<math>-(\frac{1}{3} \cdot (-1)^3+(-1)-(-\frac{1}{3}\cdot (-1)^3+3 \cdot (-1)))</math>
:<math>=-\frac{8}{3}</math> (orientierter Flächeninhalt)

Der gesuchte Flächeninhalt ist der [[Betragsfunktion|Betrag]] der Zahl und beträgt <span style="color:green"><math>\frac{8}{3}</math></span>.

[[Kategorie:Integralrechnung]]
[[Kategorie:AHR_WuV_Mathe_GK]]

MediaWiki:Common.js

2026-07-09T12:22:14Z

Flbkwikiadmin: Der Seiteninhalt wurde durch einen anderen Text ersetzt: „/* ============================================================ MediaWiki:Common.js – FLBK-Wiki Bereinigte Fassung (Basis: Wikipedia-Common.js). Editier-Komfort, Wikipedia-Infrastruktur & ungenutzte Vorlagen-Skripte entfernt. Hinweis: Gilt NICHT für die mobile Ansicht – dafür MediaWiki:Mobile.js. ============================================================ */ /* Korrekte Sortierung von Umlauten und ß in…“

/* ============================================================
MediaWiki:Common.js – FLBK-Wiki
Bereinigte Fassung (Basis: Wikipedia-Common.js).
Editier-Komfort, Wikipedia-Infrastruktur & ungenutzte
Vorlagen-Skripte entfernt.
Hinweis: Gilt NICHT für die mobile Ansicht – dafür MediaWiki:Mobile.js.
============================================================ */

/* Korrekte Sortierung von Umlauten und ß in sortierbaren Tabellen */
mw.config.set( 'tableSorterCollation', {
'Ä':'A', 'Ö':'O', 'Ü':'U', 'ä':'a', 'ö':'o', 'ü':'u', 'ß':'ss'
} );

MediaWiki:Common.css

2026-07-09T12:21:58Z

Flbkwikiadmin:

/* ============================================================
MediaWiki:Common.css – FLBK-Wiki
Bereinigte Fassung (Basis: Wikipedia-Common.css).
Wikipedia-Infrastruktur & ungenutzte Vorlagen-Styles entfernt.
Hinweis: Gilt NICHT für die mobile Ansicht – dafür MediaWiki:Mobile.css.
============================================================ */

/* Personennamen in Kapitälchen */
.Person {
font-variant: small-caps;
}

/* prettytable: sauberes Alias für wikitable (ohne Wikipedia-Warnfärbung) */
.prettytable {
background-color: #f8f9fa;
border: 1px solid #a2a9b1;
border-collapse: collapse;
color: black;
margin: 1em 0;
}
table.prettytable > * > tr > th,
table.prettytable > * > tr > td {
border: 1px solid #a2a9b1;
padding: .2em .4em;
}
table.prettytable > * > tr > th {
text-align: center;
}
table.prettytable > caption {
font-weight: bold;
}

/* Zebra-Tabellen (.wikitable.zebra) */
table.wikitable.zebra > tbody > :nth-child(even):not([class*="hintergrundfarbe"]) {
background: white;
}

/* Ausrichtungs-Hilfsklassen für Bausteine, Tabellen, Galerien */
/* @noflip */
div.float-left,
table.float-left,
ul.float-left,
.float-left {
clear: left;
float: left;
margin: 1em 1em 1em 0;
}
/* @noflip */
div.float-right,
table.float-right,
ul.float-right,
.float-right {
clear: right;
float: right;
margin: 1em 0 1em 1em;
}
div.centered,
table.centered,
ul.centered,
.centered {
margin-left: auto;
margin-right: auto;
}

/* Obenbündige Textausrichtung in Tabellenzellen */
.toptextcells > * > * > td {
vertical-align: top;
}

/* Metadaten ausblenden */
.metadata {
display: none;
}

/* <noscript>-Emulation */
.client-js .noscript {
display: none;
}

/* Abkürzungen dezenter unterstreicheln */
abbr[title]:not(:hover),
.explain[title]:not(:hover) {
border-bottom-color: rgba(127, 127, 127, .5);
text-decoration-color: rgba(127, 127, 127, .5);
}

/* blockquote: grauen linken Rand entfernen */
.mw-body-content blockquote {
border-left: none;
padding: 0;
}

/* Infoboxen nicht in Kategorie-Inhalt ragen lassen */
div.mw-category-generated {
clear: both;
}

MediaWiki:Minerva.css

2026-07-09T12:11:41Z

Flbkwikiadmin:

.minerva-footer-logo {
display: none !important;
}

MediaWiki:Minerva.css

2026-07-09T12:09:14Z

Flbkwikiadmin: Die Seite wurde neu angelegt: „/* All CSS here will be loaded for users of the MinervaNeue skin */ .minerva-footer-logo { display: none; }“

2026-05-27T08:30:35Z

Flbkwikiadmin: /* Produktion von Spielwaren aus Rohstoffen über Zwischenprodukte */

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>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 ==

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

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 ==

=== Produktion eines Produkts aus Einzelteilen ===

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 benötigte Stückzahl an.

<html>
<style>
.gozinto-wrap {
width:95vw;
height:50vw;
max-width:1100px;
max-height:450px;
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_2"
viewBox="0 0 1200 450"
preserveAspectRatio="xMinYMin meet">
</svg>
</div>

<script>
(function(){

const svg=document.getElementById("gozinto_svg_2");

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.


<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;

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;

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};

// Dragging

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);
}

// -------------------------------------------------
// GEOMETRIE
// -------------------------------------------------

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`;
}

// -------------------------------------------------
// KANTEN
// -------------------------------------------------

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);
}

// -------------------------------------------------
// NODES
// -------------------------------------------------

const nodes={};

// Rohstoffe

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

nodes.Z1=createNode("Z1",1.2,3.2,1.0,0.5,"Z1");
nodes.Z2=createNode("Z2",3.6,3.2,1.0,0.5,"Z2");

// Endprodukte

nodes.E1=createNode("E1",0.5,5.6,1.0,0.5,"E1");
nodes.E2=createNode("E2",2.8,5.6,1.0,0.5,"E2");
nodes.E3=createNode("E3",5.1,5.6,1.0,0.5,"E3");

// -------------------------------------------------
// VERBINDUNGEN
// -------------------------------------------------

// Rohstoffe -> Zwischenprodukte

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

makeConnection(nodes.R2,nodes.Z1,"4",1.8,-0.2);
makeConnection(nodes.R2,nodes.Z2,"2",1.8,0.2);

makeConnection(nodes.R3,nodes.Z2,"3",1.8,0.0);

// Zwischenprodukte -> Endprodukte

makeConnection(nodes.Z1,nodes.E1,"2",4.4,-0.2);
makeConnection(nodes.Z1,nodes.E2,"1",4.4,0.2);

makeConnection(nodes.Z2,nodes.E1,"1",4.4,-0.3);
makeConnection(nodes.Z2,nodes.E2,"3",4.4,0.0);
makeConnection(nodes.Z2,nodes.E3,"2",4.4,0.3);

updateAllEdges();

})();
</script>
</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''' durch Matrixmultiplikation:

:<math>
RZ=
\begin{pmatrix}
3 & 1 \\
4 & 2 \\
0 & 3
\end{pmatrix}
</math>

:<math>
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}
7 & 6 & 2 \\
10 & 10 & 4 \\
3 & 9 & 6
\end{pmatrix}
</math>

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.

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

Gozintograph

2026-05-27T08:27:28Z

Flbkwikiadmin:

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>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 ==

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

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 ==

=== Produktion eines Produkts aus Einzelteilen ===

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 benötigte Stückzahl an.

<html>
<style>
.gozinto-wrap {
width:95vw;
height:50vw;
max-width:1100px;
max-height:450px;
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_2"
viewBox="0 0 1200 450"
preserveAspectRatio="xMinYMin meet">
</svg>
</div>

<script>
(function(){

const svg=document.getElementById("gozinto_svg_2");

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.

<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;
}
</style>

<div class="gozinto-wrap2">
<svg id="gozinto_svg"
viewBox="0 0 1180 700"
preserveAspectRatio="xMinYMin meet">
</svg>
</div>

<script>
(function(){

const svg=document.getElementById("gozinto_svg");

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 createNode(id,cx,cy,w,h,label){

cx+=xOffsetGlobal/scale;

const g=svgEl("g",{});

const rect=svgEl("rect",{
class:"node-rect",
x:(cx-w/2)*scale,
y:(cy-h/2)*scale,
width:w*scale,
height:h*scale,
rx:6,
ry:6
});

const text=svgEl("text",{
class:"node-text",
x:cx*scale,
y:cy*scale,
"text-anchor":"middle",
"dominant-baseline":"middle"
});

text.textContent=label;

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

svg.appendChild(g);

return {cx,cy,w,h};
}

function drawArrow(x1,y1,x2,y2,label){

const line=svgEl("line",{
x1,y1,x2,y2,
stroke:"black",
"stroke-width":"2"
});

svg.appendChild(line);

const text=svgEl("text",{
x:(x1+x2)/2,
y:(y1+y2)/2-10,
class:"count-text",
"text-anchor":"middle"
});

text.textContent=label;

svg.appendChild(text);
}

const R1=createNode("R1",0,1,1,0.5,"R1");
const R2=createNode("R2",2.5,1,1,0.5,"R2");
const R3=createNode("R3",5,1,1,0.5,"R3");

const Z1=createNode("Z1",1.2,3.5,1,0.5,"Z1");
const Z2=createNode("Z2",3.8,3.5,1,0.5,"Z2");

const E1=createNode("E1",0.5,6,1,0.5,"E1");
const E2=createNode("E2",2.8,6,1,0.5,"E2");
const E3=createNode("E3",5.1,6,1,0.5,"E3");

drawArrow(170,120,240,320,"3");
drawArrow(420,120,240,320,"4");

drawArrow(170,120,500,320,"1");
drawArrow(420,120,500,320,"2");
drawArrow(670,120,500,320,"3");

drawArrow(240,370,170,570,"2");
drawArrow(240,370,420,570,"1");

drawArrow(500,370,170,570,"1");
drawArrow(500,370,420,570,"3");
drawArrow(500,370,670,570,"2");

})();
</script>
</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''' durch Matrixmultiplikation:

:<math>
RZ=
\begin{pmatrix}
3 & 1 \\
4 & 2 \\
0 & 3
\end{pmatrix}
</math>

:<math>
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}
7 & 6 & 2 \\
10 & 10 & 4 \\
3 & 9 & 6
\end{pmatrix}
</math>

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.

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

Gozintograph

2026-05-27T08:24:26Z

Flbkwikiadmin:

Gozintograph

2026-05-27T08:23:54Z

Flbkwikiadmin: /* Produktion eines Produkts aus Einzelteilen */

Flbkwikiadmin:

== Einführung ==
Die '''Unified Modeling Language''' (Vereinheitlichte Modellierungssprache), kurz '''UML''', ist eine standardisierte, grafische Modellierungssprache zur Spezifikation, zum Entwurf und zur Dokumentation von Software- und anderen Systemen. Innerhalb der UML gehören '''Anwendungsfalndiagramme''' (auch ''Use-Case-Diagramme'' genannt) zu den Verhaltensdiagrammen. Sie beschreiben das erwartete Verhalten eines Systems aus der Perspektive eines externen Beobachters (Benutzers) heraus, ohne technische Implementierungsdetails offenzulegen.

=== Zielsetzung im Software-Lebenszyklus ===
In der Analysephase eines Softwareprojekts dienen Anwendungsfalldiagramme dazu, die funktionalen Anforderungen des Auftraggebers strukturiert, übersichtlich und vollständig zu erfassen. Sie erfüllen dabei eine essenzielle Brückenfunktion:
* '''Kommunikationsmittel:''' Sie vermitteln barrierefrei zwischen fachlichen Laien (potenziellen Anwendern, Auftraggebern) und dem technischen Entwicklungsteam (Auftragnehmern).
* '''Anforderungsdokumentation:''' Als strukturierte und visuelle Anforderungsbeschreibung sind sie ein fundamentaler Bestandteil des '''Lastenhefts''' (was das System tun soll) und fließen direkt in das '''Pflichtenheft''' ein.

=== Die drei Kernelemente ===
Ein Anwendungsfalndiagramm lässt sich auf drei wesentliche Säulen reduzieren:<ref>Heide Balzer: ''Lehrbuch der Objektmodellierung - Analyse und Entwurf'', Spektrum Akademischer Verlag, S. 62 ff.</ref>
# '''Akteure (Actors):''' Wer interagiert mit dem System? (Sowohl Personen als auch externe Systeme).
# '''Anwendungsfälle (Use Cases):''' Was kann mit dem System getan werden? Welche Ziele werden erreicht?
# '''Beziehungen (Relations):''' Wie interagieren Akteure und Anwendungsfälle miteinander oder wie hängen Anwendungsfälle untereinander zusammen?

''Hinweis zur Abgrenzung:'' Ein Use-Case-Diagramm zeigt '''nicht''', in welcher zeitlichen oder logischen Reihenfolge Prozesse ablaufen. Für die Modellierung von detaillierten, prozessualen Abläufen und Kontrollflüssen wird stattdessen das [[Aktivitätendiagramm]] verwendet.

== Systematische Notation und Aufbau ==
Die Erstellung eines normkonformen Diagramms folgt einem klaren, dreistufigen iterativen Prozess:

=== 1. Akteure identifizieren (Actors) ===
Akteure stellen Rollen dar, die außerhalb des betrachteten Systems liegen, aber mit diesem interagieren.
* '''Darstellung:''' Grafisch als klassisches Strichmännchen (für menschliche Rollen) oder als Rechteck mit dem Stereotyp <code>«system»</code> (für externe Software/Hardware).
* '''Namensgebung:''' Akteure müssen präzise, selbsterklärende Substantive sein (z. B. ''Kunde'', ''Systemadministrator'', ''Buchhaltungssystem''). Generische Bezeichnungen wie „User“, „Benutzer“ oder „Akteur“ sind strikt zu vermeiden, da sie keine differenzierte Rolle beschreiben.

=== 2. Anwendungsfälle definieren (Use Cases) ===
Ein Anwendungsfall beschreibt eine Sequenz von Interaktionen, die für den Akteur ein Ergebnis von messbarem, fachlichem Wert liefert.
* '''Darstellung:''' Als horizontale Ellipse, in deren Zentrum die Beschreibung steht.
* '''Namensgebung:''' Die Formulierung erfolgt kurz, prägnant, im Infinitiv und folgt der sprachlichen Struktur: '''Subjekt-Objekt-Prädikat''' (z. B. ''Artikel in Warenkorb legen'', ''Passwort zurücksetzen'').

=== 3. Beziehungen verknüpfen (Relations) ===
Akteure und Anwendungsfälle werden über Beziehungslinien verknüpft, um Interaktionskanäle aufzuzeigen. Das gesamte System wird optional durch einen rechteckigen '''Systemrahmen (System Boundary)''' umschlossen, welcher die Systemgrenze markiert: Akteure stehen außerhalb, Use Cases innerhalb des Rahmens.

<html>
<svg width="600" height="220" viewBox="0 0 600 220" xmlns="http://www.w3.org/2000/svg" style="background-color: transparent;">
<rect x="180" y="20" width="380" height="180" rx="5" fill="none" stroke="#222222" stroke-width="2" />
<text x="190" y="40" font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="#222222">Systemgrenze (z.B. Webshop)</text>

<g transform="translate(50, 60)">
<circle cx="30" cy="20" r="15" fill="#ffffff" stroke="#222222" stroke-width="2"/>
<line x1="30" y1="35" x2="30" y2="75" stroke="#222222" stroke-width="2"/>
<line x1="10" y1="50" x2="50" y2="50" stroke="#222222" stroke-width="2"/>
<line x1="30" y1="75" x2="10" y2="105" stroke="#222222" stroke-width="2"/>
<line x1="30" y1="75" x2="50" y2="105" stroke="#222222" stroke-width="2"/>
<text x="30" y="125" font-family="Arial, sans-serif" font-size="14" font-weight="bold" text-anchor="middle" fill="#222222">Kunde</text>
</g>

<line x1="110" y1="120" x2="240" y2="120" stroke="#222222" stroke-width="2" />
<text x="175" y="110" font-family="Arial, sans-serif" font-size="12" fill="#555555" text-anchor="middle">Assoziation</text>

<g transform="translate(240, 80)">
<ellipse cx="140" cy="40" rx="120" ry="35" fill="#ffffff" stroke="#222222" stroke-width="2"/>
<text x="140" y="44" font-family="Arial, sans-serif" font-size="14" text-anchor="middle" font-weight="bold" fill="#222222">Artikel suchen</text>
</g>
</svg>
</html>

== Detaillierte Typisierung von Beziehungen ==

=== 1. Assoziationen (Akteur ↔ Use Case) ===
Assoziationen bilden das Fundament der Kommunikation zwischen Akteur und System. Es handelt sich um eine binäre Beziehung (verbindet genau zwei Elemente).

* '''Ungerichtete Assoziation:''' Eine einfache, durchgehende Linie. Sie signalisiert einen bidirektionalen Informationsfluss. Der Akteur interagiert mit dem Use Case, lässt jedoch offen, wer die Interaktion gestartet hat.
* '''Gerichtete Assoziation:''' Eine Linie mit einer offenen Pfeilspitze. Der Pfeil zeigt auf den Initiator des Datenflusses bzw. der Aktion:
** Pfeil zeigt zum ''Use Case'': Der Akteur initiiert den Anwendungsfall aktiv.
** Pfeil zeigt zum ''Akteur'': Der Anwendungsfall stößt eine Aktion beim Akteur an (häufig bei sekundären, externen Systemen wie z. B. Benachrichtigungsdiensten).

=== 2. Multiplizitäten ===
Multiplizitäten (Kardinalitäten) geben an, wie viele Instanzen eines Akteurs zeitgleich mit wie vielen Instanzen eines Anwendungsfalls interagieren können. Sie werden direkt an die Enden der Assoziationslinien geschrieben.

==== Praxisbeispiel: Das Tischtennis-Rundlaufspiel ====
Um die Logik von Multiplizitäten zu verdeutlichen, betrachten wir das Regelwerk eines Tischtennis-Rundlaufs:
* An einem Rundlauf-Spiel müssen '''mindestens 3 Spielerinnen''' teilnehmen, nach oben hin gibt es keine Grenze (<code>3..*</code>). Jede einzelne Spielerin nimmt jedoch zu einem Zeitpunkt an '''exakt 1''' Rundlauf-Spiel teil (<code>1</code>).
* Ein Spiel kann völlig ohne oder mit unbegrenzt vielen Schiedsrichterinnen stattfinden (<code>0..*</code>). Eine Schiedsrichterin kann maximal '''an höchstens 1''' Spiel gleichzeitig als Offizielle zugewiesen sein (<code>0..1</code>).

<html>
<svg width="750" height="280" viewBox="0 0 750 280" xmlns="http://www.w3.org/2000/svg" style="background-color: transparent;">
<g transform="translate(265, 100)">
<ellipse cx="110" cy="40" rx="100" ry="35" fill="#ffffff" stroke="#222222" stroke-width="2"/>
<text x="110" y="44" font-family="Arial, sans-serif" font-size="13" font-weight="bold" text-anchor="middle" fill="#222222">Am Rundlauf-Spiel</text>
<text x="110" y="60" font-family="Arial, sans-serif" font-size="13" font-weight="bold" text-anchor="middle" fill="#222222">teilnehmen</text>
</g>

<g transform="translate(40, 50)">
<circle cx="30" cy="20" r="15" fill="#ffffff" stroke="#222222" stroke-width="2"/>
<line x1="30" y1="35" x2="30" y2="75" stroke="#222222" stroke-width="2"/>
<line x1="10" y1="50" x2="50" y2="50" stroke="#222222" stroke-width="2"/>
<line x1="30" y1="75" x2="10" y2="105" stroke="#222222" stroke-width="2"/>
<line x1="30" y1="75" x2="50" y2="105" stroke="#222222" stroke-width="2"/>
<text x="30" y="125" font-family="Arial, sans-serif" font-size="14" font-weight="bold" text-anchor="middle" fill="#222222">Spielerin</text>
</g>
<line x1="100" y1="130" x2="265" y2="135" stroke="#222222" stroke-width="2" />
<text x="115" y="120" font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="#b30000">1</text>
<text x="240" y="125" font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="#b30000">3..*</text>

<g transform="translate(640, 50)">
<circle cx="30" cy="20" r="15" fill="#ffffff" stroke="#222222" stroke-width="2"/>
<line x1="30" y1="35" x2="30" y2="75" stroke="#222222" stroke-width="2"/>
<line x1="10" y1="50" x2="50" y2="50" stroke="#222222" stroke-width="2"/>
<line x1="30" y1="75" x2="10" y2="105" stroke="#222222" stroke-width="2"/>
<line x1="30" y1="75" x2="50" y2="105" stroke="#222222" stroke-width="2"/>
<text x="30" y="125" font-family="Arial, sans-serif" font-size="14" font-weight="bold" text-anchor="middle" fill="#222222">Schiedsrichterin</text>
</g>
<line x1="465" y1="135" x2="640" y2="130" stroke="#222222" stroke-width="2" />
<text x="480" y="125" font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="#b30000">0..*</text>
<text x="615" y="120" font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="#b30000">0..1</text>
</svg>
</html>

''Hinweis für die Praxis:'' Da Multiplizitäten Use-Case-Diagramme schnell visuell überladen und für fachliche Auftraggeber oft sekundär sind, werden sie in dieser Diagrammart selten notiert. Ihre fundamentale Bedeutung entfalten sie im [[Klassendiagramm]].

=== 3. Include-Beziehungen (Abhängigkeiten) ===
Die <code>«include»</code>-Beziehung beschreibt eine zwingende Abhängigkeit (Einschluss). Wenn ein Basis-Anwendungsfall ausgeführt wird, '''muss''' der inkludierte Anwendungsfall zwingend ebenfalls ausgeführt werden. Sie dient dem Aufbrechen komplexer Use Cases und der Wiederverwendung von Funktionalitäten.

* '''Pfeilrichtung:''' Der gestrichelte Pfeil startet beim ''Basis-Use-Case'' und zeigt '''auf den inkludierten''' Use Case.
* '''Stereotyp:''' Die Beziehungslinie muss zwingend mit dem Schlüsselwort <code>«include»</code> gekennzeichnet werden.

<html>
<svg width="650" height="140" viewBox="0 0 650 140" xmlns="http://www.w3.org/2000/svg" style="background-color: transparent;">
<g transform="translate(10, 30)">
<ellipse cx="110" cy="40" rx="100" ry="35" fill="#ffffff" stroke="#222222" stroke-width="2"/>
<text x="110" y="44" font-family="Arial, sans-serif" font-size="13" font-weight="bold" text-anchor="middle" fill="#222222">Bestellung aufgeben</text>
</g>

<g>
<line x1="210" y1="70" x2="420" y2="70" stroke="#222222" stroke-width="2" stroke-dasharray="6,6" />
<polygon points="430,70 415,63 415,77" fill="#222222" />
<text x="320" y="55" font-family="Arial, sans-serif" font-size="14" font-weight="bold" text-anchor="middle" fill="#222222">«include»</text>
</g>

<g transform="translate(430, 30)">
<ellipse cx="110" cy="40" rx="100" ry="35" fill="#ffffff" stroke="#222222" stroke-width="2"/>
<text x="110" y="44" font-family="Arial, sans-serif" font-size="13" font-weight="bold" text-anchor="middle" fill="#222222">Identität prüfen</text>
</g>
</svg>
</html>

=== 4. Extend-Beziehungen (Erweiterungen) ===
Die <code>«extend»</code>-Beziehung modelliert ein '''optionales''' Verhalten. Der erweiternde Use Case wird nur unter präzise definierten Rahmenbedingungen ausgeführt.

* '''Pfeilrichtung:''' Der gestrichelte Pfeil verhält sich umgekehrt zur Include-Beziehung: Er startet beim ''erweiternden (optionalen) Use Case'' und zeigt '''auf den Basis-Use-Case'''.
* '''Stereotyp:''' Kennzeichnung erfolgt über das Schlüsselwort <code>«extend»</code>.
* '''Erweiterungspunkte (Extension Points):''' Im Basis-Use-Case wird unter einer horizontalen Trennlinie via <code>extension points</code> definiert, an welcher Stelle die Erweiterung eingreift.
* '''Bedingung (Condition):''' Ein umschließendes Notizfeld (als Notizzettel dargestellt) definiert die logische Bedingung. Es wird mit einer fein gestrichelten Linie an die Extend-Beziehung geheftet.

<html>
<svg width="700" height="300" viewBox="0 0 700 300" xmlns="http://www.w3.org/2000/svg" style="background-color: transparent;">
<g transform="translate(20, 100)">
<ellipse cx="120" cy="50" rx="110" ry="45" fill="#ffffff" stroke="#222222" stroke-width="2"/>
<text x="120" y="40" font-family="Arial, sans-serif" font-size="13" font-weight="bold" text-anchor="middle" fill="#222222">Konto einrichten</text>
<line x1="30" y1="52" x2="210" y2="52" stroke="#555555" stroke-width="1" />
<text x="120" y="68" font-family="Arial, sans-serif" font-size="11" font-style="italic" text-anchor="middle" fill="#555555">extension points:</text>
<text x="120" y="82" font-family="Arial, sans-serif" font-size="11" text-anchor="middle" fill="#222222">Premium-Option</text>
</g>

<g>
<line x1="440" y1="150" x2="255" y2="150" stroke="#222222" stroke-width="2" stroke-dasharray="6,6" />
<polygon points="245,150 260,143 260,157" fill="#222222" />
<text x="350" y="135" font-family="Arial, sans-serif" font-size="14" font-weight="bold" text-anchor="middle" fill="#222222">«extend»</text>
</g>

<g transform="translate(450, 100)">
<ellipse cx="110" cy="50" rx="100" ry="45" fill="#ffffff" stroke="#222222" stroke-width="2"/>
<text x="110" y="48" font-family="Arial, sans-serif" font-size="12" font-weight="bold" text-anchor="middle" fill="#222222">Premium-Features</text>
<text x="110" y="64" font-family="Arial, sans-serif" font-size="12" font-weight="bold" text-anchor="middle" fill="#222222">auswählen</text>
</g>

<g transform="translate(250, 10)">
<polygon points="0,0 170,0 190,20 190,60 0,60" fill="#ffffff" stroke="#222222" stroke-width="1" />
<polygon points="170,0 170,20 190,20" fill="#ffffff" stroke="#222222" stroke-width="1" />
<text x="10" y="20" font-family="Arial, sans-serif" font-size="11" font-weight="bold" fill="#222222">Condition: {Nutzer wählt</text>
<text x="10" y="35" font-family="Arial, sans-serif" font-size="11" font-weight="bold" fill="#222222">Premium-Abonnement}</text>
<text x="10" y="50" font-family="Arial, sans-serif" font-size="11" fill="#555555">Extension Point: Premium-Option</text>
</g>

<line x1="345" y1="70" x2="345" y2="150" stroke="#555555" stroke-width="1" stroke-dasharray="3,3" />
</svg>
</html>

=== 5. Generalisierung (Vererbung / Spezialisierung) ===
Eine Generalisierungsbeziehung spiegelt das klassische Konzept der Vererbung (OOP) wider. Sie kann sowohl zwischen zwei Akteuren als auch zwischen zwei Anwendungsfällen existieren. Das spezialisierte Element erbt alle Eigenschaften, Attribute und Verhaltensweisen des allgemeinen Elements und konkretisiert diese.

* '''Darstellung:''' Eine durchgehende Linie mit einer '''großen, leeren und geschlossenen Pfeilspitze'''.
* '''Pfeilrichtung:''' Der Pfeil zeigt immer '''vom spezifischen (Unterklasse) zum allgemeinen (Oberklasse)''' Element.

==== Praxisbeispiel: Nutzerhierarchie ====
Ein ''Fahrer'' ist eine explizite Spezialisierung des allgemeinen ''Anwenders''. Der Fahrer besitzt implizit jede Eigenschaft des Standard-Anwenders (wie Stammdaten: Vorname, Nachname, Username) und erbt dessen Fähigkeit, den Use Case ''Login durchführen'' aufzurufen, ohne dass dies redundant gezeichnet werden muss.

<html>
<svg width="400" height="320" viewBox="0 0 400 320" xmlns="http://www.w3.org/2000/svg" style="background-color: transparent;">
<g transform="translate(40, 20)">
<circle cx="30" cy="20" r="15" fill="#ffffff" stroke="#222222" stroke-width="2"/>
<line x1="30" y1="35" x2="30" y2="75" stroke="#222222" stroke-width="2"/>
<line x1="10" y1="50" x2="50" y2="50" stroke="#222222" stroke-width="2"/>
<line x1="30" y1="75" x2="10" y2="105" stroke="#222222" stroke-width="2"/>
<line x1="30" y1="75" x2="50" y2="105" stroke="#222222" stroke-width="2"/>
<text x="30" y="125" font-family="Arial, sans-serif" font-size="14" font-weight="bold" text-anchor="middle" fill="#222222">Anwender</text>
</g>

<g transform="translate(200, 45)">
<ellipse cx="80" cy="35" rx="70" ry="30" fill="#ffffff" stroke="#222222" stroke-width="2"/>
<text x="80" y="39" font-family="Arial, sans-serif" font-size="13" font-weight="bold" text-anchor="middle" fill="#222222">Login durchführen</text>
</g>
<line x1="100" y1="80" x2="200" y2="80" stroke="#222222" stroke-width="2" />

<g>
<line x1="70" y1="195" x2="70" y2="165" stroke="#222222" stroke-width="2" />
<polygon points="70,150 60,165 80,165" fill="#ffffff" stroke="#222222" stroke-width="2" />
<text x="85" y="185" font-family="Arial, sans-serif" font-size="12" font-style="italic" fill="#555555">Generalisierung</text>
</g>

<g transform="translate(40, 180)">
<circle cx="30" cy="20" r="15" fill="#ffffff" stroke="#222222" stroke-width="2"/>
<line x1="30" y1="35" x2="30" y2="75" stroke="#222222" stroke-width="2"/>
<line x1="10" y1="50" x2="50" y2="50" stroke="#222222" stroke-width="2"/>
<line x1="30" y1="75" x2="10" y2="105" stroke="#222222" stroke-width="2"/>
<line x1="30" y1="75" x2="50" y2="105" stroke="#222222" stroke-width="2"/>
<text x="30" y="125" font-family="Arial, sans-serif" font-size="14" font-weight="bold" text-anchor="middle" fill="#222222">Fahrer</text>
</g>
</svg>
</html>

== Zusammenfassende Gegenüberstellung für die Klausur / Praxis ==

{| class="wikitable" style="width:100%; border:1px solid #aaa;"
|- style="background:#eeeeee;"
! Beziehungstyp !! Notation im Diagramm !! Semantik (Bedeutung) !! Typischer Anwendungsfall
|-
| '''Assoziation''' || Durchgehende Linie || Kommunikationspfad || Verknüpft primäre Akteure mit Kernfunktionen.
|-
| '''Include''' || Gestrichelte Linie + Pfeil zum Ziel + <code>«include»</code> || Zwingende Ausführung (100% Pflicht) || Auslagerung von wiederkehrenden Funktionen wie Login oder Validierung.
|-
| '''Extend''' || Gestrichelte Linie + Pfeil zur Basis + <code>«extend»</code> || Optionale Ausführung (0-100% je nach Bedingung) || Modellierung von Ausnahmefällen, Fehlermeldungen oder optionalen Zusatzfunktionen.
|-
| '''Generalisierung''' || Linie + geschlossene, leere Pfeilspitze || "Ist-ein"-Beziehung (Vererbung) || Abbildung von Benutzer-Rollenstrukturen (Rechtehierarchien).
|}

[[Kategorie:Modellierung]]
[[Kategorie:FI_I_SDM]]
[[Kategorie:AHR_I_Informatik LK]]

Grenzkostenminimum

2026-05-21T08:51:22Z

Flbkwikiadmin:

Die [[Extremwert|Extremstelle]] zum Grenzkostenminimum gibt an, für welche Produktionsmenge der Kostenzuwachs minimal ist. Dieser Kostenzuwachs ist das Grenzkostenminimum.

==Definition==
Es sei <math>K:\mathbb{D}_{ök} \rightarrow \mathbb{W}_K</math> eine [[Kostenfunktion]], <math>K'</math> die dazugehörige [[Grenzkostenfunktion]] und <math>x_0</math> die [[Extremwert|Extremstelle]] zum Tiefpunkt von <math>K'</math>, dann nennen wir <math>K'(x_0)</math> '''Grenzkostenminimum'''.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/zH8wOu7ienk?si=Vv8doT6rvfVEAUw-" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Zusammenhang zwischen Grenzkostenminimum und [[Wendepunkt]]==
Ist <math>x_0</math> die [[Extremwert|Extremstelle]] zum Grenzkostenminimum <math>K'(x_0)</math> für eine Kostenfunktion <math>K</math>, dann ist <math>x_0</math> eine [[Wendepunkt|Wendestelle]] von <math>K</math>.

==Beispiele==
===Grenzkostenminimum berechnen===
Wir betrachten die Kostenfunktion <math>K(x)=3x^3-45x^2+300x+192</math> mit <math>x</math> in ME und <math>K(x)</math> in GE. Es gilt

<math>K'(x)=9x^2-90x+300</math>

<math>K''(x)=18x-90</math>

<math>K'''(x)=18</math>

'''1. Notwendige Bedingung:'''
<math>K''(x)=0</math>

<math>18x-90=0~|~+90</math>

<math>18x=90~|~:18</math>

<math>x=5</math>

'''2. Hinreichende Bedingung:'''

<math>K'''(5)=18 > 0</math>

<math>K'</math> hat bei <math>x=5</math> ein Minimum.

'''3. Funktionswert berechnen:'''

<math>K'(5)=9 \cdot 5^2-90 \cdot 5+300=75</math>

Das Grenzkostenminimum beträgt 75 <math>\frac{GE}{ME}</math>.

===[[Wendepunkt]] der Kostenfunktion mit Hilfe des Grenzkostenminimums ermitteln===
Bei der Berechnung des Wendepunkts <math>K</math> von sind die Schritte 1 und 2 identisch zur oberen Rechnung. Der Funktionswert zum [[Wendepunkt]] ist jedoch <math>K(5)=3 \cdot 5^3-45 \cdot 5^2+300 \cdot 5+192=942</math>. Der Wendepunkt von <math>K</math> ist also <math>W(5|942)</math>. <math>K</math> hat wegen Schritt 2 eine Rechts-Linkskrümmung bei <math>W</math>.

[[Kategorie:Differentialrechnung]]
[[Kategorie:Gewinnanalyse]]
[[Kategorie:FHR_WuV_Mathe]]
[[Kategorie:AHR_WuV_Mathe_GK]]