0.30.0: Terminplan in Vierteltagen, Überschneidung erst über einen Tag
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
Claude
2026-10-22 11:13:09 +00:00
parent e1b0406289
commit 177c9643c5
24 changed files with 281 additions and 98 deletions

View File

@@ -11,8 +11,10 @@ export type Art = "EA" | "AA" | "EE" | "AE";
export interface PlanVorgang {
id: string;
start: Datum;
/** Arbeitstage; angefangene Tage zählen voll; 0 = Meilenstein */
/** Arbeitstage in Vierteln (0,25 = Vierteltag); 0 = Meilenstein */
dauer: number;
/** Teil des ersten Tages, der vorher schon belegt ist (z. B. 0,5: beginnt mittags) */
start_teil?: number | null;
/** Freitage, an denen dieser Vorgang ausnahmsweise ausgeführt wird */
freitage?: Datum[] | null;
}
@@ -25,14 +27,33 @@ export interface Verknuepfung {
verzoegerung: number;
}
const tage = (v: PlanVorgang) => Math.ceil(v.dauer);
const tage = (v: PlanVorgang) => Number(v.dauer);
export const teilVon = (v: PlanVorgang) => (tage(v) > 0 ? Number(v.start_teil ?? 0) : 0);
/** Zeitpunkt im Plan: Tag und wie viel davon schon vorbei ist (0 = Tagesbeginn) */
export interface Lage { tag: Datum; teil: number }
const vorLage = (a: Lage, b: Lage) => a.tag < b.tag || (a.tag === b.tag && a.teil < b.teil - 1e-9);
const gleich = (a: Lage, b: Lage) => a.tag === b.tag && Math.abs(a.teil - b.teil) < 1e-9;
export function anfang(v: PlanVorgang, woche: Arbeitswoche): Datum {
return naechsterArbeitstag(v.start, wocheVon(v, woche));
}
export function ende(v: PlanVorgang, woche: Arbeitswoche): Datum {
return endeNachDauer(v.start, tage(v), wocheVon(v, woche));
return endeNachDauer(v.start, tage(v), wocheVon(v, woche), teilVon(v));
}
/** Wie viel vom letzten Tag belegt ist (0 < x ≤ 1); Meilensteine zählen als ganzer Tag */
export function endeTeil(v: PlanVorgang): number {
if (tage(v) === 0) return 1;
const x = teilVon(v) + tage(v);
return x - (Math.ceil(x - 1e-9) - 1);
}
/** Anfang als Lage; der Teil gilt nur, wenn der Starttag ein Arbeitstag ist */
function anfangsLage(v: PlanVorgang, woche: Arbeitswoche): Lage {
const a = anfang(v, woche);
return { tag: a, teil: a === v.start ? teilVon(v) : 0 };
}
/** V70 offW: n Arbeitstage nach (n > 0) oder vor (n < 0) dem Tag; 0 = der Tag oder der nächste Arbeitstag. */
@@ -40,47 +61,75 @@ function versatz(d: Datum, n: number, woche: Arbeitswoche): Datum {
return n === 0 ? naechsterArbeitstag(d, woche) : verschiebeArbeitstage(d, n, woche);
}
/** Start, der sich ergibt, wenn der Vorgang an `endeAm` endet. */
function startFuerEnde(v: PlanVorgang, endeAm: Datum, woche: Arbeitswoche): Datum {
/** Start, der sich ergibt, wenn der Vorgang an `endeAm` endet, und zwar nach `teil` dieses Tages (1 = Tagesende). */
function startFuerEnde(v: PlanVorgang, endeAm: Datum, woche: Arbeitswoche, teil = 1): Lage {
const w = wocheVon(v, woche);
const e = naechsterArbeitstag(endeAm, w);
return tage(v) <= 1 ? e : verschiebeArbeitstage(e, -(tage(v) - 1), w);
if (e !== endeAm) teil = 1;
if (tage(v) === 0) return { tag: e, teil: 0 };
// vom Ende zurückrechnen: Tag e zählt als 0, davor negativ
const x = teil - tage(v);
const ganz = Math.floor(x + 1e-9);
return { tag: ganz === 0 ? e : verschiebeArbeitstage(e, ganz, w), teil: Math.max(0, x - ganz) };
}
/** Frühester Start, den eine Verknüpfung dem Nachfolger erlaubt. */
export function startNachVerknuepfung(v: PlanVorgang, vorgaenger: PlanVorgang, k: Verknuepfung, woche: Arbeitswoche): Datum {
/** Start an einem Tag nach `teil`; liegt der Tag im Kalender des Nachfolgers nicht, ab dem nächsten Arbeitstag */
function lageAm(d: Datum, teil: number, w: Arbeitswoche): Lage {
const t = naechsterArbeitstag(d, w);
return t === d ? { tag: d, teil } : { tag: t, teil: 0 };
}
/**
* Frühester Start, den eine Verknüpfung dem Nachfolger erlaubt, mit dem Teil des Tages: endet der Vorgänger
* nach einem Vierteltag, beginnt der Nachfolger am selben Tag danach (Henning, 22.10.2026).
*/
export function lageNachVerknuepfung(v: PlanVorgang, vorgaenger: PlanVorgang, k: Verknuepfung, woche: Arbeitswoche): Lage {
const lg = k.verzoegerung;
const meilenstein = tage(v) === 0;
// gezählt wird im Kalender des Nachfolgers: ein freigegebener Freitag des Nachfolgers kann sein Start sein
const w = wocheVon(v, woche);
const e = ende(vorgaenger, woche), et = endeTeil(vorgaenger);
const a = anfangsLage(vorgaenger, woche);
switch (k.art) {
case "EA": return versatz(ende(vorgaenger, woche), meilenstein ? lg : 1 + lg, w);
case "AA": return versatz(anfang(vorgaenger, woche), lg, w);
case "EE": return startFuerEnde(v, versatz(ende(vorgaenger, woche), lg, w), woche);
case "AE": return startFuerEnde(v, versatz(anfang(vorgaenger, woche), lg, w), woche);
case "EA":
if (meilenstein) return { tag: versatz(e, lg, w), teil: 0 };
if (et < 1 - 1e-9) return lg === 0 ? lageAm(e, et, w) : { tag: versatz(e, lg, w), teil: et };
return { tag: versatz(e, 1 + lg, w), teil: 0 };
case "AA": return lg === 0 ? lageAm(a.tag, a.teil, w) : { tag: versatz(a.tag, lg, w), teil: a.teil };
case "EE": return startFuerEnde(v, versatz(e, lg, w), woche, et);
case "AE": return startFuerEnde(v, versatz(a.tag, lg, w), woche, a.teil > 0 ? a.teil : 1);
}
}
/** Frühester Start aus allen Vorgängern; undefined ohne Vorgänger. */
export function fruehesterStart(v: PlanVorgang, alle: Map<string, PlanVorgang>, links: Verknuepfung[], woche: Arbeitswoche): Datum | undefined {
let s: Datum | undefined;
/** Frühester Starttag, den eine Verknüpfung dem Nachfolger erlaubt. */
export function startNachVerknuepfung(v: PlanVorgang, vorgaenger: PlanVorgang, k: Verknuepfung, woche: Arbeitswoche): Datum {
return lageNachVerknuepfung(v, vorgaenger, k, woche).tag;
}
function fruehesteLage(v: PlanVorgang, alle: Map<string, PlanVorgang>, links: Verknuepfung[], woche: Arbeitswoche): Lage | undefined {
let s: Lage | undefined;
for (const k of links) {
if (k.vorgang_id !== v.id) continue;
const p = alle.get(k.vorgaenger_id);
if (!p) continue;
const x = startNachVerknuepfung(v, p, k, woche);
if (!s || x > s) s = x;
const x = lageNachVerknuepfung(v, p, k, woche);
if (!s || vorLage(s, x)) s = x;
}
return s;
}
/** Frühester Start aus allen Vorgängern; undefined ohne Vorgänger. */
export function fruehesterStart(v: PlanVorgang, alle: Map<string, PlanVorgang>, links: Verknuepfung[], woche: Arbeitswoche): Datum | undefined {
return fruehesteLage(v, alle, links, woche)?.tag;
}
/** Vorgänge, die genau an ihrem frühesten Start liegen; sie rücken mit, wenn der Vorgänger früher fertig wird. */
export function engeVorgaenge(vorgaenge: PlanVorgang[], links: Verknuepfung[], woche: Arbeitswoche): Set<string> {
const alle = new Map(vorgaenge.map((v) => [v.id, v]));
const eng = new Set<string>();
for (const v of vorgaenge) {
const f = fruehesterStart(v, alle, links, woche);
if (f && f === anfang(v, woche)) eng.add(v.id);
const f = fruehesteLage(v, alle, links, woche);
if (f && gleich(f, anfangsLage(v, woche))) eng.add(v.id);
}
return eng;
}
@@ -130,6 +179,8 @@ function topologisch(vorgaenge: PlanVorgang[], links: Verknuepfung[]): PlanVorga
export interface Ergebnis {
/** neuer Start je verschobenem Vorgang */
starts: Map<string, Datum>;
/** Teil des Starttags je verschobenem Vorgang */
teile: Map<string, number>;
/** neue Dauer je Vorgang, dessen Dauer sich aus Stunden und Besetzung ergibt (T15) */
dauern: Map<string, number>;
}
@@ -145,6 +196,7 @@ export function planeNeu(vorgaenge: PlanVorgang[], links: Verknuepfung[], woche:
dauerFuer?: (v: PlanVorgang) => number | undefined): Ergebnis {
const stand = new Map(vorgaenge.map((v) => [v.id, { ...v }]));
const starts = new Map<string, Datum>();
const teile = new Map<string, number>();
const dauern = new Map<string, number>();
for (const v of topologisch(vorgaenge, links)) {
const x = stand.get(v.id)!;
@@ -154,12 +206,14 @@ export function planeNeu(vorgaenge: PlanVorgang[], links: Verknuepfung[], woche:
x.dauer = d;
dauern.set(v.id, d);
}
const f = fruehesterStart(x, stand, links, woche);
const a = anfang(x, woche);
if (!f || !(f > a || (f < a && eng.has(v.id)))) break;
x.start = f;
starts.set(v.id, f);
const f = fruehesteLage(x, stand, links, woche);
const a = anfangsLage(x, woche);
if (!f || !(vorLage(a, f) || (vorLage(f, a) && eng.has(v.id)))) break;
x.start = f.tag;
x.start_teil = f.teil;
starts.set(v.id, f.tag);
teile.set(v.id, f.teil);
}
}
return { starts, dauern };
return { starts, teile, dauern };
}