Algoritmes rondom het verdelen van waarden in een array.

[Immutable]

Mijn vraag:

Ik ben bezig met een soort Node structuur systeem waarbij bepaalde nodes dus input in het systeem hebben. En andere nodes dus een output heeft. (en zelfs nodes die input en output kunnen hebben.) Maar elke Node is "anders" en kan elk moment veranderen.

Het is een soort graph structuur maar wel met een common point of coupling. Dus een ster. Elke node kan een batterij zijn, zonnepanelen e.d. en je wil dus de flow regelen naar elk punt toe. Maar elk punt kan groter of kleiner zijn.

De datastructuur is relatief simpel, een Array. Nu ben ik al op zoek geweest naar algoritmes. En kom ik uit op o.a. "bucket fill" algoritmes. Hier wordt bijvoorbeeld de bandbreedte van nodes die aan een telefoon mast verdeelt:
https://www.researchgate....quipped_cellular_networks

Mijn vraag is, ik kan maar weinig vinden over dit soort algoritmes en misschien dat ze een bepaalde "vakterm" hebben in de wereld van algoritmes en datastructuren?

De vraag is, op welke termen zou ik moeten googlen. En heeft iemand hier ervaring met zulke algoritmes en heeft misschien wat goede informatiebronnen voor mij rondom deze vorm van "Verdelings algoritmes" ?
Ook dat je zaken kunt verdelen op ratio, en wat over is verdeelt over de rest... e.d.

Voorbeeld van de datastructuur per array node wat ik nu heb. (versimpeld):

Status van node:
Node[i].MaxFlowIngoing (Dit kan dan 100 zijn, of 200..)
Node[i].MaxFlowOutgoing (Dit kan dan -500 zijn)
Node[i].ExtLimitedFlowIngoing (Dit is een % van MaxFlowIngoing Externe invloed)
Node[i].ExtLimitedFlowOutgoing (Dit is een % van MaxFlowOutgoing Externe invloed)
Node[i].ActualFlow (Actuele waarde zowel positief of negatief.)
Aansturing van node:
Node[i].IntFlowSetpoint (Waarde zowel positief of negatief Interne invloed)
Node[i].IntFlowLimitSetpointIngoing (Dit is een % van MaxFlowIngoing Interne invloed)
Node[i].IntFlowLimitSetpointOutgoing (Dit is een % van MaxFlowOutgoing interne invloed)

Misschien een kleine visualisatie: (Het gaat om de flow van "waarden" die door de nodes heen stromen. En hoe je dit "verkeer" dus regelt door middel van algoritmes.


Nodes kunnen zichzelf aansturen, als dat gewenst is. Maar kan ook aangestuurd worden door externe invloeden. Het is maar net hoe je een Node "configureerd" en op basis van deze configuratie gaat hij zich anders gedragen in het algoritme.

Ben niet zo zeer opzoek naar een kant en klare oplossing. (Helemaal niet.) Maar iemand die ervaring heeft met zulke algoritmes en die mij misschien informatie kan geven in de vorm van links / boeken e.d. zodat ik zelf tot een goede algoritme kan komen.

[Voor 14% gewijzigd door Immutable op 16-12-2022 12:54]

[luukvr]

Paar principes die mij zo te binnen schieten:

- Distributed applications / computing
- Server/client pooling
- Event bus achtige structuren
- Internet of things achtige structuren

Weet niet echt wat het meeste van toepassing is omdat je usecase voor mij vrij wazig is.

[Kalentum]

Ja het is mij ook niet helemaal duidelijk. Ik dacht eerst dat het ging om iets als Node Red (flow-based programming met nodes, input/output, graphs). maar blijkbaar gaat het om specifieke array algoritmes?