Files
Betriebsf-hrungssoftware/src/server/jahresplan.ts
Claude 45c21943bf
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
Stundensätze im Personalmodul, Übergabe ans Angebot (0.26.0)
Rechentabellen je Lohnart wie Hennings Excel (Zeit, Kosten, Vollkostensatz),
Mittellohn mit Schaltern, Versionen mit gilt ab. Excel-Fassung centgenau
(80,38 / 107,81 EUR), Fassung nach S2 mit Akquise/Verwaltung als Kosten.
Angebote schreiben die geltenden Sätze fest, Lohnzuschlag 0 %, Nachfrage
bei neuer Version.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
2026-10-22 06:55:22 +00:00

307 lines
21 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Jahresfinanzplanung und BWA (Stufe 5, Henning 21.10.2026). Nur für den Inhaber (Rollen im Heft).
// Ein Jahr hat Versionen: die Basis bleibt, eine Version „gilt“ und speist Liquidität, Übersicht und Plan/Ist.
import { aktuelleSaetze } from "./stundensaetze.js";
import type { FastifyInstance, FastifyRequest } from "fastify";
import { z } from "zod";
import { type Client, type Pool, transaktion } from "./db.js";
import type { Einstellungen } from "./einstellungen.js";
import { werName } from "./anmeldung.js";
import { type PlanDaten, PLANZEILEN, type Planzeile, SAISON_HANDWERK, leererPlan, rechne, vorschlaege, knappText } from "../domain/jahresplan.js";
import { BwaFehler, istWerte, liesBwa, planIst, zuordnungVorschlag } from "../domain/bwa.js";
import type { Daten, LaufendeKosten } from "../domain/liquiditaet.js";
import { laufendJeMonat } from "../domain/lage.js";
import { type Datum, plusTage, wochentag } from "../domain/datum.js";
const cent = z.number().int().min(0).max(10_000_000_000);
const monat = z.number().int().min(1).max(12);
const PlanSchema = z.object({
mitarbeiter: z.array(z.object({
id: z.string().min(1).max(40), name: z.string().trim().min(1).max(100), art: z.enum(["inhaber", "angestellt"]),
stunden: z.number().min(0).max(4000), brutto: cent, faktor: z.number().min(1).max(3).default(1.25),
eintritt: monat.default(1), austritt: monat.default(12), neu: z.boolean().default(false),
})).max(50).default([]),
investitionen: z.array(z.object({
id: z.string().min(1).max(40), name: z.string().trim().min(1).max(100), betrag: cent, monat: monat.default(1),
art: z.enum(["kauf", "kredit", "leasing"]).default("kauf"), anzahlung: cent.default(0), laufzeit: z.number().int().min(0).max(360).default(60),
zins: z.number().min(0).max(30).default(5), rate: cent.default(0), nutzungsdauer: z.number().min(0).max(50).default(6),
})).max(50).default([]),
annahmen: z.object({
stundensatz: cent, materialEinkauf: cent, materialAufschlag: z.number().min(0).max(500), subEinkauf: cent, subAufschlag: z.number().min(0).max(500),
laufendMonat: cent, preissteigerung: z.number().min(-50).max(100), werbungMonat: cent, afaBisher: cent, tilgungBisher: cent, steuerQuartal: cent,
kontostandStart: z.number().int().min(-10_000_000_000).max(10_000_000_000), mindestgrenze: cent,
}),
saison: z.array(z.number().min(0).max(100)).length(12),
});
const Jahr = z.coerce.number().int().min(2000).max(2100);
/** erster Freitag eines Monats */
export function ersterFreitag(jahr: number, m: number): Datum {
const erster = `${jahr}-${String(m).padStart(2, "0")}-01`;
return plusTage(erster, (5 - wochentag(erster) + 7) % 7);
}
const MONATSNAMEN = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"];
/**
* Finanzsitzung als wiederkehrende Aufgabe (Roos: monatlich, Henning: erster Freitag = Bürotag). Das Programm legt
* sie für den laufenden Monat an, sobald es einen Jahresplan gibt; erledigt oder gelöscht bleibt sie für diesen Monat weg.
*/
export async function finanzsitzungAnlegen(c: Client | Pool, heute: Datum): Promise<void> {
if (!(await c.query("select 1 from jahresplan limit 1")).rowCount) return;
const jahr = Number(heute.slice(0, 4)), m = Number(heute.slice(5, 7));
const serie = `finanzsitzung-${heute.slice(0, 7)}`;
const vor = m === 1 ? { m: 12, j: jahr - 1 } : { m: m - 1, j: jahr };
// eine gelöschte Aufgabe nicht wieder anlegen: der Monat steht dann im Protokoll
if ((await c.query("select 1 from protokoll where tabelle = 'aufgabe' and aktion = 'loeschen' and vorher->>'serie' = $1 limit 1", [serie])).rowCount) return;
await c.query(`insert into aufgabe (text, faellig_am, serie) values ($1, $2, $3) on conflict (serie) do nothing`,
[`Finanzsitzung: BWA ${MONATSNAMEN[vor.m - 1]} ${vor.j} durchgehen (Jahresplanung → Plan / Ist)`, ersterFreitag(jahr, m), serie]);
}
interface Hilfen {
einstellungen: () => Promise<Einstellungen>;
/** Projekte, Zahlungen und Kosten wie in der Liquidität */
liquiDaten: () => Promise<Daten>;
}
export function registriereJahresplan(app: FastifyInstance, pool: Pool, h: Hilfen): void {
const wer = (req: FastifyRequest) => werName(req);
const heute = () => new Date().toISOString().slice(0, 10);
async function laufend(): Promise<LaufendeKosten[]> {
return (await pool.query("select bezeichnung, kategorie, betrag, rhythmus, start, ende from laufende_kosten")).rows
.map((l) => ({ bezeichnung: l.bezeichnung, kategorie: l.kategorie ?? undefined, betrag: Number(l.betrag), rhythmus: l.rhythmus, start: l.start, ende: l.ende ?? undefined }));
}
/** Was der Plan aus dem Programm übernehmen kann: laufende Kosten (Personal getrennt), Kontostand, Mindestgrenze, BWA des Vorjahres */
async function vorlagen(jahr: number) {
const e = await h.einstellungen();
const lk = await laufend();
// im Planjahr laufende Posten, jeder Rhythmus auf den Monat umgerechnet (einmalige zählen nicht)
const imJahr = (k: LaufendeKosten) => k.rhythmus !== "einmalig" && k.start <= `${jahr}-12-31` && (!k.ende || k.ende >= `${jahr}-01-01`);
const jeMonat = (k: LaufendeKosten) => (imJahr(k) ? Math.round(k.betrag / ({ monatlich: 1, vierteljaehrlich: 3, jaehrlich: 12, einmalig: 1 } as const)[k.rhythmus]) : 0);
const istPersonal = (k: LaufendeKosten) => /personal|lohn|gehalt/i.test(`${k.kategorie ?? ""} ${k.bezeichnung}`);
const posten = lk.filter(imJahr).map((k) => ({ bezeichnung: k.bezeichnung, kategorie: k.kategorie ?? "", monat: jeMonat(k), personal: istPersonal(k) }));
const ohnePersonal = posten.filter((k) => !k.personal).reduce((x, k) => x + k.monat, 0);
const personal = posten.filter((k) => k.personal).reduce((x, k) => x + k.monat, 0);
const mindestgrenze = e.mindestgrenzeArt === "fest" ? e.mindestreserve : laufendJeMonat(lk, heute());
// BWA des Vorjahres: jüngster Monat mit kumulierten Werten, aufs Jahr hochgerechnet
const zu = await zuordnung();
const vj = (await pool.query("select monat, zeilen from finanz_monat where jahr = $1 and zeilen is not null order by monat desc limit 1", [jahr - 1])).rows[0];
let vorjahr = null;
if (vj) {
const ist = istWerte(vj.zeilen, zu, true);
const f = 12 / vj.monat;
vorjahr = { monate: vj.monat, umsatz: Math.round(ist.umsatz! * f), material: Math.round(ist.material! * f), laufendMonat: Math.round((ist.laufend! / vj.monat)),
werbungMonat: Math.round(ist.werbung! / vj.monat), afa: Math.round(ist.afa! * f), tilgungMonat: Math.round(ist.tilgung! / vj.monat),
steuerQuartal: Math.round((ist.steuer! / vj.monat) * 3), unternehmerlohnMonat: Math.round(ist.unternehmerlohn! / vj.monat) };
}
// Saison aus dem Vorjahr: Erlöse je Monat aus den eingelesenen BWA (Monatswerte)
const monate = (await pool.query("select monat, zeilen from finanz_monat where jahr = $1 and zeilen is not null order by monat", [jahr - 1])).rows;
const saisonVorjahr = monate.map((r) => ({ monat: r.monat as number, umsatz: istWerte(r.zeilen, zu, false).umsatz! }));
const personalListe = (await pool.query(`select k.name, m.angestellt, m.lohn_cent, m.eintritt, m.austritt from mitarbeiter m join kontakt k on k.id = m.kontakt_id
where m.austritt is null or m.austritt >= $1 order by m.angestellt, k.name`, [`${jahr}-01-01`])).rows;
return { laufend: { ohnePersonal, personal, posten }, kontostand: e.startsaldo, mindestgrenze, vorjahr, saisonVorjahr, personal: personalListe,
stundensatzEk: (await aktuelleSaetze(pool, heute()))?.stundensaetze.mittellohn ?? e.kalkulation.stundensaetze.geselle };
}
async function zuordnung(): Promise<Map<number, Planzeile>> {
return new Map((await pool.query("select zeile, planzeile from bwa_zuordnung")).rows.map((r) => [r.zeile as number, r.planzeile as Planzeile]));
}
/** neuer Plan: Annahmen aus laufenden Kosten, Kontostand, Mindestgrenze und, wenn da, der BWA des Vorjahres */
async function startPlan(jahr: number): Promise<PlanDaten> {
const v = await vorlagen(jahr);
const d = leererPlan({
laufendMonat: v.laufend.ohnePersonal, kontostandStart: v.kontostand, mindestgrenze: v.mindestgrenze,
...(v.vorjahr ? { materialEinkauf: v.vorjahr.material, werbungMonat: v.vorjahr.werbungMonat, afaBisher: v.vorjahr.afa,
tilgungBisher: v.vorjahr.tilgungMonat, steuerQuartal: v.vorjahr.steuerQuartal } : {}),
});
d.mitarbeiter.push({ id: "inhaber", name: "Inhaber", art: "inhaber", stunden: 900, brutto: v.laufend.personal || v.vorjahr?.unternehmerlohnMonat || 0, faktor: 1, eintritt: 1, austritt: 12, neu: false });
v.personal.filter((p) => p.angestellt).forEach((p, i) => {
const ein = p.eintritt && p.eintritt.slice(0, 4) === String(jahr) ? Number(p.eintritt.slice(5, 7)) : 1;
const aus = p.austritt && p.austritt.slice(0, 4) === String(jahr) ? Number(p.austritt.slice(5, 7)) : 12;
// Stundenlohn aus Personal × 173 Stunden im Monat
d.mitarbeiter.push({ id: `m${i + 1}`, name: p.name, art: "angestellt", stunden: 1400, brutto: Math.round(Number(p.lohn_cent ?? 0) * 173), faktor: 1.25, eintritt: ein, austritt: aus, neu: false });
});
if (v.saisonVorjahr.length === 12) d.saison = saisonAus(v.saisonVorjahr.map((x) => x.umsatz));
return d;
}
const zeile = (r: Record<string, any>) => ({ id: r.id, jahr: r.jahr, name: r.name, basis: r.basis, gilt: r.gilt, daten: r.daten as PlanDaten, geaendert_am: r.geaendert_am });
const beauftragt = async (jahr: number) => beauftragtJeMonat(await h.liquiDaten(), jahr);
app.get("/api/jahresplan", async (req) => {
const q = z.object({ jahr: Jahr.optional() }).parse(req.query);
const jahre = (await pool.query("select distinct jahr from jahresplan order by jahr")).rows.map((r) => r.jahr as number);
const jetzt = Number(heute().slice(0, 4));
// ohne Angabe: das nächste Jahr ab Oktober, sonst das laufende
const jahr = q.jahr ?? (jahre.includes(jetzt) && heute().slice(5, 7) < "10" ? jetzt : jahre.find((j) => j > jetzt) ?? (heute().slice(5, 7) >= "10" ? jetzt + 1 : jetzt));
await finanzsitzungAnlegen(pool, heute());
const versionen = (await pool.query("select * from jahresplan where jahr = $1 order by basis desc, angelegt_am", [jahr])).rows.map(zeile);
return { jahr, jahre, versionen, vorlagen: await vorlagen(jahr), beauftragt: await beauftragt(jahr) };
});
app.post("/api/jahresplan", async (req, reply) => {
const q = z.object({ jahr: Jahr, name: z.string().trim().min(1).max(80).optional(), von: z.uuid().optional(), daten: PlanSchema.optional() }).parse(req.body);
const daten = q.daten ?? (q.von ? (await pool.query("select daten from jahresplan where id = $1", [q.von])).rows[0]?.daten : await startPlan(q.jahr));
if (!daten) return reply.status(404).send({ fehler: "Version nicht gefunden" });
const neu = await transaktion(pool, wer(req), async (c) => {
const erste = !(await c.query("select 1 from jahresplan where jahr = $1", [q.jahr])).rowCount;
const r = (await c.query("insert into jahresplan (jahr, name, basis, gilt, daten) values ($1, $2, $3, $3, $4) returning *",
[q.jahr, q.name ?? (erste ? "Basis" : "Neue Version"), erste, PlanSchema.parse(daten)])).rows[0];
await finanzsitzungAnlegen(c, heute());
return r;
});
return reply.status(201).send(zeile(neu));
});
app.patch("/api/jahresplan/:id", async (req, reply) => {
const { id } = z.object({ id: z.uuid() }).parse(req.params);
const q = z.object({ name: z.string().trim().min(1).max(80).optional(), daten: PlanSchema.optional(), gilt: z.literal(true).optional() }).parse(req.body);
const r = await transaktion(pool, wer(req), async (c) => {
const alt = (await c.query("select * from jahresplan where id = $1", [id])).rows[0];
if (!alt) return null;
if (q.gilt) await c.query("update jahresplan set gilt = false where jahr = $1 and gilt and id <> $2", [alt.jahr, id]);
return (await c.query("update jahresplan set name = coalesce($2, name), daten = coalesce($3, daten), gilt = gilt or coalesce($4, false) where id = $1 returning *",
[id, q.name ?? null, q.daten ?? null, q.gilt ?? null])).rows[0];
});
return r ? zeile(r) : reply.status(404).send({ fehler: "Nicht gefunden" });
});
app.delete("/api/jahresplan/:id", async (req, reply) => {
const { id } = z.object({ id: z.uuid() }).parse(req.params);
const r = await transaktion(pool, wer(req), async (c) => {
const alt = (await c.query("select * from jahresplan where id = $1", [id])).rows[0];
if (!alt) return 404;
if (alt.basis) return 409;
await c.query("delete from jahresplan where id = $1", [id]);
if (alt.gilt) await c.query("update jahresplan set gilt = true where jahr = $1 and basis", [alt.jahr]);
return 204;
});
if (r === 409) return reply.status(409).send({ fehler: "Die Basis bleibt immer erhalten." });
return r === 204 ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" });
});
/** Vorschläge, um die Lücke zum Gewinnziel zu schließen; ein Klick legt die Version an */
app.get("/api/jahresplan/:id/vorschlaege", async (req, reply) => {
const { id } = z.object({ id: z.uuid() }).parse(req.params);
const p = (await pool.query("select daten from jahresplan where id = $1", [id])).rows[0];
if (!p) return reply.status(404).send({ fehler: "Nicht gefunden" });
return vorschlaege(PlanSchema.parse(p.daten)).map(({ daten: _, ...v }) => v);
});
// ---------- BWA und Plan/Ist ----------
app.post("/api/bwa", async (req, reply) => {
const q = z.object({ dateiname: z.string().max(200).default(""), inhalt: z.string().min(1).max(20_000_000) }).parse(req.body);
let b;
try { b = liesBwa(q.inhalt); } catch (err) {
if (err instanceof BwaFehler) return reply.status(400).send({ fehler: err.message });
throw err;
}
const neu = await transaktion(pool, wer(req), async (c) => {
await c.query(`insert into finanz_monat (jahr, monat, dateiname, bwa_art, eingelesen_am, zeilen) values ($1, $2, $3, $4, now(), $5)
on conflict (jahr, monat) do update set dateiname = $3, bwa_art = $4, eingelesen_am = now(), zeilen = $5`,
[b.jahr, b.monat, q.dateiname, b.art, JSON.stringify(b.zeilen)]);
const da = new Set((await c.query("select zeile from bwa_zuordnung")).rows.map((r) => r.zeile as number));
const neue = [];
for (const z of b.zeilen) {
if (da.has(z.zeile)) continue;
const p = zuordnungVorschlag(z);
await c.query("insert into bwa_zuordnung (zeile, bezeichnung, planzeile) values ($1, $2, $3)", [z.zeile, z.bezeichnung, p]);
if (!z.summe && (z.monat || z.kumuliert)) neue.push({ zeile: z.zeile, bezeichnung: z.bezeichnung, planzeile: p });
}
return neue;
});
return reply.status(201).send({ jahr: b.jahr, monat: b.monat, art: b.art, zeilen: b.zeilen.length, neu: neu });
});
app.delete("/api/bwa/:jahr/:monat", async (req) => {
const p = z.object({ jahr: Jahr, monat: z.coerce.number().int().min(1).max(12) }).parse(req.params);
await transaktion(pool, wer(req), (c) => c.query("update finanz_monat set zeilen = null, dateiname = null, bwa_art = null, eingelesen_am = null where jahr = $1 and monat = $2", [p.jahr, p.monat]));
return { ok: true };
});
app.put("/api/bwa/zuordnung/:zeile", async (req) => {
const { zeile: nr } = z.object({ zeile: z.coerce.number().int().min(0).max(99999) }).parse(req.params);
const { planzeile } = z.object({ planzeile: z.enum([...PLANZEILEN, "ignorieren"]) }).parse(req.body);
await transaktion(pool, wer(req), (c) => c.query(`insert into bwa_zuordnung (zeile, planzeile) values ($1, $2)
on conflict (zeile) do update set planzeile = $2`, [nr, planzeile]));
return { zeile: nr, planzeile };
});
app.put("/api/finanzmonat/:jahr/:monat", async (req) => {
const p = z.object({ jahr: Jahr, monat: z.coerce.number().int().min(1).max(12) }).parse(req.params);
const q = z.object({ notizen: z.record(z.string(), z.string().max(500)).optional(), erledigt: z.array(z.string().max(40)).max(30).optional() }).parse(req.body);
const r = await transaktion(pool, wer(req), async (c) => (await c.query(`insert into finanz_monat (jahr, monat, notizen, erledigt) values ($1, $2, coalesce($3, '{}'::jsonb), coalesce($4, '[]'::jsonb))
on conflict (jahr, monat) do update set notizen = coalesce($3, finanz_monat.notizen), erledigt = coalesce($4, finanz_monat.erledigt) returning notizen, erledigt`,
[p.jahr, p.monat, q.notizen ? JSON.stringify(q.notizen) : null, q.erledigt ? JSON.stringify(q.erledigt) : null])).rows[0]);
return r;
});
app.get("/api/jahresplan/planist", async (req) => {
const q = z.object({ jahr: Jahr, monat: z.coerce.number().int().min(1).max(12).optional(), kumuliert: z.enum(["0", "1"]).default("0") }).parse(req.query);
// ohne Plan für das Jahr zeigt die Seite nur die Ist-Werte (z. B. die BWA des laufenden Jahres)
const plan = (await pool.query("select * from jahresplan where jahr = $1 and gilt", [q.jahr])).rows[0];
const monate = (await pool.query("select monat, dateiname, bwa_art, eingelesen_am, zeilen is not null as bwa, notizen, erledigt from finanz_monat where jahr = $1 order by monat", [q.jahr])).rows;
const mitBwa = monate.filter((m) => m.bwa);
const m = q.monat ?? mitBwa.at(-1)?.monat ?? Math.max(1, Number(heute().slice(5, 7)) - 1);
const fm = (await pool.query("select * from finanz_monat where jahr = $1 and monat = $2", [q.jahr, m])).rows[0];
const zu = await zuordnung();
const kumuliert = q.kumuliert === "1";
const r = rechne(plan ? PlanSchema.parse(plan.daten) : leererPlan());
const ergebnis = planIst(r, fm?.zeilen ? istWerte(fm.zeilen, zu, kumuliert) : null, m, kumuliert);
const alleZeilen = (await pool.query("select zeile, bezeichnung, planzeile from bwa_zuordnung order by zeile")).rows;
const werte = new Map<number, { monat: number; kumuliert: number; summe: boolean; bezeichnung: string }>((fm?.zeilen ?? []).map((z: any) => [z.zeile, z]));
return {
jahr: q.jahr, monat: m, kumuliert, plan: plan ? { id: plan.id, name: plan.name } : null,
monate: monate.map(({ notizen: _n, erledigt: _e, ...x }) => x),
bwa: fm?.zeilen ? { dateiname: fm.dateiname, art: fm.bwa_art, eingelesen_am: fm.eingelesen_am } : null,
notizen: fm?.notizen ?? {}, erledigt: fm?.erledigt ?? [],
...ergebnis,
zuordnung: alleZeilen.filter((z) => !werte.get(z.zeile)?.summe).map((z) => ({ ...z, bezeichnung: werte.get(z.zeile)?.bezeichnung ?? z.bezeichnung,
monatswert: werte.get(z.zeile)?.monat ?? null, kumuliert: werte.get(z.zeile)?.kumuliert ?? null })),
sitzung: ersterFreitag(m === 12 ? q.jahr + 1 : q.jahr, m === 12 ? 1 : m + 1),
};
});
app.get("/api/jahresplan/stand", async () => jahresplanStand(pool, h.liquiDaten, heute()));
}
/** beauftragter Umsatz je Monat (netto, nach Rechnungstermin) aus Projekten ab „beauftragt“ */
function beauftragtJeMonat(d: Daten, jahr: number): number[] {
const m = Array(12).fill(0);
for (const e of d.einnahmen) if (e.termin.startsWith(`${jahr}-`)) m[Number(e.termin.slice(5, 7)) - 1] += e.netto;
return m;
}
/** Übersicht: wie viel Umsatz im Planjahr noch verkauft werden muss (Stufe-5-Abnahme) */
export async function jahresplanStand(pool: Pool, liquiDaten: () => Promise<Daten>, heute: Datum) {
const p = (await pool.query("select jahr, name, daten from jahresplan where gilt and jahr >= $1 order by jahr limit 1", [Number(heute.slice(0, 4))])).rows[0];
if (!p) return null;
const daten = PlanSchema.parse(p.daten);
const r = rechne(daten);
const b = beauftragtJeMonat(await liquiDaten(), p.jahr).reduce((x, y) => x + y, 0);
return { jahr: p.jahr as number, name: p.name as string, umsatz: r.treppe.umsatz, beauftragt: b, offen: Math.max(0, r.treppe.umsatz - b),
knapp: knappText(daten, r).satz, gewinnQuote: r.treppe.quoteGewinn };
}
/** gilt-Versionen der Jahre, die die Liquidität als Vorschau braucht */
export async function geltendePlaene(pool: Pool, vonJahr: number, bisJahr: number): Promise<{ jahr: number; daten: PlanDaten }[]> {
return (await pool.query("select jahr, daten from jahresplan where gilt and jahr between $1 and $2", [vonJahr, bisJahr])).rows
.map((r) => ({ jahr: r.jahr as number, daten: PlanSchema.parse(r.daten) }));
}
/** Saison in % aus Umsätzen je Monat, auf ganze Prozent, Summe 100 */
export function saisonAus(umsaetze: number[]): number[] {
const s = umsaetze.reduce((a, b) => a + Math.max(0, b), 0);
if (!s) return [...SAISON_HANDWERK];
const roh = umsaetze.map((u) => (Math.max(0, u) / s) * 100);
const ganz = roh.map(Math.floor);
let rest = 100 - ganz.reduce((a, b) => a + b, 0);
roh.map((x, i) => [x - Math.floor(x), i] as const).sort((a, b) => b[0] - a[0]).forEach(([, i]) => { if (rest-- > 0) ganz[i]! += 1; });
return ganz;
}