Home /Modules/advantage/SLVerticalIntegration.sleela

SLVerticalIntegration.sleela

lib/advantage/integration/SLVerticalIntegration.sleela · 227 line(s) · sleela

<< lib/advantage/integration/SLVerticalIntegration.sleela
   SLeeLa Standard Library Definition.
   Definition: Vertical integration through capitalism/retail -- an ordered
   vertical stack of compartment tiers, recursively composable. >>
#sleela 3.0
material;
artifact;
pure;
gasoline;
< The top-level model. VERTICAL INTEGRATION stacks tiers of a value chain from >
< upstream (tier 0, raw/supply) to downstream (last tier, retail/sale). Each >
< tier is a SLCompartment, so a tier can itself be a nested-model holding its >
< own lower stack (recursion). The model aggregates capacity, utilization, >
< relevance, and a SYSTEM SOPHISTICATION score over the whole recursive tree. >
<  >
< Mainly a vertical arrangement: tier i feeds tier i+1 downstream. The straight >
< onion model, engineering bays, trial compartments, newton median trays, and >
< plain holders are all attached as compartments (or children of compartments), >
< each contributing its own capacitive space, meaning and relevance. >
class SLVerticalIntegration {
  < ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- >
  << Eleven catalogued attributes with getter/setter pairs, so a GUI, loader,
     or catalog can read and (where appropriate) override this record.
     Values are faithful to the subject's real origin where publicly known. >>
  String metaVersion = "1.0.0";
  int metaId = 10545;
  String metaAuthor = "Kiro Agent";
  String metaDate = "2026-11-08";
  String metaCopyright = "SLeeLa project";
  String metaTrademark = "none";
  String metaCorporation = "none";
  < metaOrigin: National | <nation> | International | Galactic >
  String metaOrigin = "International";
  < metaScienceRating: maturity/robustness on a 1..10 scale >
  String metaBirthDate = "2026-11-08";
  int metaScienceRating = 8;
  << metaNationalSchedule: vertical integration is a classical industrial-
     organization concept (Coase, "The Nature of the Firm", 1937); academic,
     not a statute. >>
  String metaNationalSchedule = "none";

  String getMetaVersion() { return metaVersion; }
  void setMetaVersion(String v) { metaVersion = v; }
  int getMetaId() { return metaId; }
  void setMetaId(int v) { metaId = v; }
  String getAuthor() { return metaAuthor; }
  void setAuthor(String v) { metaAuthor = v; }
  String getDate() { return metaDate; }
  void setDate(String v) { metaDate = v; }
  String getCopyright() { return metaCopyright; }
  void setCopyright(String v) { metaCopyright = v; }
  String getTrademark() { return metaTrademark; }
  void setTrademark(String v) { metaTrademark = v; }
  String getCorporation() { return metaCorporation; }
  void setCorporation(String v) { metaCorporation = v; }
  String getOrigin() { return metaOrigin; }
  void setOrigin(String v) { metaOrigin = v; }
  String getBirthDate() { return metaBirthDate; }
  void setBirthDate(String v) { metaBirthDate = v; }
  int getScienceRating() { return metaScienceRating; }
  void setScienceRating(int v) { metaScienceRating = v; }
  String getNationalSchedule() { return metaNationalSchedule; }
  void setNationalSchedule(String v) { metaNationalSchedule = v; }

  String name;
  SLIntegrationKind cat;
  < the vertical stack, index 0 = most upstream >
  SLCompartment[] tiers;
  int tierCount;
  int tierCap;

  void configure(String nm) {
    name = nm;
    cat = new SLIntegrationKind();
    tierCap = 32;
    tiers = new SLCompartment[tierCap];
    tierCount = 0;
  }

  String getName() { return name; }
  SLIntegrationKind catalog() { return cat; }
  int getTierCount() { return tierCount; }

  < Append a tier downstream. Returns its tier index (0 = most upstream). >
  int addTier(SLCompartment tier) {
    if (tierCount >= tierCap) { return 0 - 1; }
    tiers[tierCount] = tier;
    int idx = tierCount;
    tierCount = tierCount + 1;
    return idx;
  }

  < Build and append a tier of a given kind in one call; returns the tier. >
  SLCompartment addKind(String label, int kind) {
    SLCompartment t = new SLCompartment();
    t.configure(label, kind, cat);
    addTier(t);
    return t;
  }

  SLCompartment tierAt(int i) {
    if (i < 0) { return null; }
    if (i >= tierCount) { return null; }
    return tiers[i];
  }

  < ---- Vertical flow: push units from upstream tier i to downstream i+1 ---- >
  < Moves up to `amount` used units out of tier i and stores them in tier i+1, >
  < limited by what tier i holds and what tier i+1 can accept. Returns moved. >
  int flowDownstream(int i, int amount) {
    if (i < 0) { return 0; }
    if (i + 1 >= tierCount) { return 0; }
    SLCompartment up = tiers[i];
    SLCompartment down = tiers[i + 1];
    int take = amount;
    int have = up.getUsed();
    if (take > have) { take = have; }
    int room = down.free();
    if (take > room) { take = room; }
    if (take < 0) { take = 0; }
    up.release(take);
    down.store(take);
    return take;
  }

  < Run one full upstream->downstream sweep moving `amount` per hop. Returns >
  < the units delivered into the most downstream (retail) tier. >
  int runChain(int amount) {
    int delivered = 0;
    int i = 0;
    while (i + 1 < tierCount) {
      int moved = flowDownstream(i, amount);
      if (i + 1 == tierCount - 1) { delivered = delivered + moved; }
      i = i + 1;
    }
    return delivered;
  }

  < ---- Aggregates over the whole recursive tree ---- >
  int totalCompartments() {
    int sum = 0;
    int i = 0;
    while (i < tierCount) {
      SLCompartment t = tiers[i];
      sum = sum + t.subtreeSize();
      i = i + 1;
    }
    return sum;
  }

  int totalCapacity() {
    int sum = 0;
    int i = 0;
    while (i < tierCount) {
      SLCompartment t = tiers[i];
      sum = sum + t.totalCapacity();
      i = i + 1;
    }
    return sum;
  }

  int totalUsed() {
    int sum = 0;
    int i = 0;
    while (i < tierCount) {
      SLCompartment t = tiers[i];
      sum = sum + t.totalUsed();
      i = i + 1;
    }
    return sum;
  }

  int totalRelevance() {
    int sum = 0;
    int i = 0;
    while (i < tierCount) {
      SLCompartment t = tiers[i];
      sum = sum + t.totalRelevance();
      i = i + 1;
    }
    return sum;
  }

  < Maximum recursion depth across all tiers (how deep the nesting goes). >
  int maxDepth() {
    int best = 0;
    int i = 0;
    while (i < tierCount) {
      SLCompartment t = tiers[i];
      int d = t.depth();
      if (d > best) { best = d; }
      i = i + 1;
    }
    return best;
  }

  << System sophistication score: rewards breadth (compartments), depth
     (recursive nesting), and relevance density. A single rolled-up integer so
     two designs can be compared. sophistication =
        totalCompartments + 3*maxDepth + totalRelevance/4. >>
  int sophistication() {
    return totalCompartments() + 3 * maxDepth() + totalRelevance() / 4;
  }

  < Utilization percentage of the whole tree (0 if no capacity). >
  int utilization() {
    int capv = totalCapacity();
    if (capv <= 0) { return 0; }
    return totalUsed() * 100 / capv;
  }

  String describe() {
    return "vertical-integration '" + name + "': tiers=" + tierCount
         + " compartments=" + totalCompartments()
         + " maxDepth=" + maxDepth()
         + " capacity=" + totalCapacity()
         + " relevance=" + totalRelevance()
         + " sophistication=" + sophistication();
  }

  < Report this model through an output emitter (terminal / commonrails / >
  < socket / silent); the emitter and its sink decide the destination. >
  void emitThrough(SLAdvantageEmitter em) {
    em.report("vertical-integration", describe());
  }
}