0.30.0: Terminplan in Vierteltagen, Überschneidung erst über einen Tag
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:
@@ -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 };
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user