// TGr05.cpp - Zorro64 Strategy DLL (C++) - Two coupled graphs for algo trading

#include <zorro.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define INF 1e30

// =============================== Graph (OO) ===============================
class WeightedGraph {
public:
  int n = 0;
  double* d = 0;   // adjacency/shortest-path matrix (n*n)

  WeightedGraph(int N) { init(N); }
  ~WeightedGraph() { shutdown(); }

  void init(int N) {
    shutdown();
    n = N;
    d = (double*)malloc((size_t)n*(size_t)n*sizeof(double));
    if(!d) quit("OOM: WeightedGraph matrix");
    reset();
  }

  void shutdown() {
    if(d) free(d);
    d = 0;
    n = 0;
  }

  inline int pos(int r,int c) const { return r*n + c; }

  void reset() {
    for(int r=0;r<n;r++)
      for(int c=0;c<n;c++)
        d[pos(r,c)] = (r==c) ? 0.0 : INF;
  }

  // Floyd-Warshall shortest paths
  void allPairsShortest() {
    for(int k=0;k<n;k++)
      for(int i=0;i<n;i++)
        for(int j=0;j<n;j++) {
          double cand = d[pos(i,k)] + d[pos(k,j)];
          if(cand < d[pos(i,j)]) d[pos(i,j)] = cand;
        }
  }

  // Wiener-like sum over unordered pairs (symmetrized)
  double wienerUndirectedLike() const {
    double W = 0.0;
    for(int i=0;i<n;i++)
      for(int j=i+1;j<n;j++) {
        double dij = d[pos(i,j)];
        double dji = d[pos(j,i)];
        W += 0.5*(dij + dji);
      }
    return W;
  }

  void dump(const char* title) const {
    printf("\n%s", title);
    for(int r=0;r<n;r++) {
      printf("\n");
      for(int c=0;c<n;c++) {
        double v = d[pos(r,c)];
        if(v > 1e20) printf("  INF ");
        else printf("%5.2f ", v);
      }
    }
  }
};

// ========================== Graph A: Markov State Graph ===================
// Edge weight = -log(p_ij)  (probability -> distance)
class RegimeMarkovGraph {
public:
  WeightedGraph G;

  RegimeMarkovGraph(int states) : G(states) {}

  static double probToDist(double p) {
    if(p <= 0.0) return INF;
    if(p > 1.0) p = 1.0;
    return -log(p);
  }

  void setTransitionProb(int i,int j,double p) {
    G.d[G.pos(i,j)] = probToDist(p);
  }

  // Example presets: directional vs choppy (toy)
  void buildDirectional4() {
    G.reset();
    setTransitionProb(0,0,0.65); setTransitionProb(0,1,0.30); setTransitionProb(0,2,0.04); setTransitionProb(0,3,0.01);
    setTransitionProb(1,0,0.25); setTransitionProb(1,1,0.60); setTransitionProb(1,2,0.12); setTransitionProb(1,3,0.03);
    setTransitionProb(2,0,0.03); setTransitionProb(2,1,0.12); setTransitionProb(2,2,0.60); setTransitionProb(2,3,0.25);
    setTransitionProb(3,0,0.01); setTransitionProb(3,1,0.04); setTransitionProb(3,2,0.30); setTransitionProb(3,3,0.65);
  }

  void buildChoppy4() {
    G.reset();
    setTransitionProb(0,0,0.28); setTransitionProb(0,1,0.24); setTransitionProb(0,2,0.25); setTransitionProb(0,3,0.23);
    setTransitionProb(1,0,0.23); setTransitionProb(1,1,0.27); setTransitionProb(1,2,0.26); setTransitionProb(1,3,0.24);
    setTransitionProb(2,0,0.24); setTransitionProb(2,1,0.26); setTransitionProb(2,2,0.27); setTransitionProb(2,3,0.23);
    setTransitionProb(3,0,0.25); setTransitionProb(3,1,0.23); setTransitionProb(3,2,0.24); setTransitionProb(3,3,0.28);
  }

  // Compactness: lower Wiener => more compact; convert to a score in [0,1]
  double compactnessScore() {
    G.allPairsShortest();
    double W = G.wienerUndirectedLike();
    // simple squash: smaller W => larger score
    return 1.0/(1.0 + W);
  }
};

// ========================== Graph B: Asset Relationship Graph =============
// Edge weight = 1 - |corr|  (strong corr => short distance)
class AssetCorrelationGraph {
public:
  WeightedGraph G;

  AssetCorrelationGraph(int assets) : G(assets) {}

  static double corrToDist(double corr) {
    double a = fabs(corr);
    if(a > 1.0) a = 1.0;
    return 1.0 - a; // in [0,1]
  }

  void setCorr(int i,int j,double corr) {
    double w = corrToDist(corr);
    G.d[G.pos(i,j)] = w;
    G.d[G.pos(j,i)] = w;
  }

  // Example 3-asset correlation structure (toy)
  // 0=EUR/USD, 1=GBP/USD, 2=USD/JPY
  void buildToyFX() {
    G.reset();
    // self already 0
    setCorr(0,1,0.85);  // EURUSD ~ GBPUSD high positive corr -> short distance
    setCorr(0,2,-0.30); // EURUSD vs USDJPY mild negative -> larger distance
    setCorr(1,2,-0.25); // GBPUSD vs USDJPY mild negative
  }

  // Coupling: lower Wiener => assets tightly coupled; convert to risk penalty in [0,1]
  double couplingPenalty() {
    G.allPairsShortest();
    double W = G.wienerUndirectedLike();
    // smaller W => higher coupling => higher penalty; invert & squash
    return 1.0/(1.0 + W);
  }
};

// ========================== Strategy: Coupled Two-Graph Logic =============
class TwoGraphStrategy {
public:
  // Hyperparameters
  double alpha = 2.0;   // weight for regime compactness
  double beta  = 1.5;   // weight for asset coupling penalty
  double baseRisk = 1.0;

  // Graphs
  RegimeMarkovGraph RG;
  AssetCorrelationGraph AG;

  TwoGraphStrategy() : RG(4), AG(3) {}

  static double sigmoid(double x) {
    // stable-ish sigmoid
    if(x > 30) return 1.0;
    if(x < -30) return 0.0;
    return 1.0/(1.0 + exp(-x));
  }

  // In a real system:
  // - RG transitions come from online Markov counts over price-action states
  // - AG correlations come from rolling returns correlations of assets
  // Here: toy graphs to demonstrate the coupling logic.
  void buildToyInputs(int useDirectional) {
    if(useDirectional) RG.buildDirectional4();
    else              RG.buildChoppy4();

    AG.buildToyFX();
  }

  // Coupling between two graphs in "mathematical context":
  // we treat RG.compactness as signal quality and AG.coupling as diversification risk.
  double riskThrottle() {
    double comp = RG.compactnessScore();   // higher = better / more predictable
    double coup = AG.couplingPenalty();    // higher = more coupled / more dangerous

    // combined score -> throttle in [0,1]
    double x = alpha*comp - beta*coup;
    return sigmoid(x);
  }

  void explain(double thr) {
    printf("\n\n[TwoGraph] Regime compactness score = %.4f", RG.compactnessScore());
    printf("\n[TwoGraph] Asset coupling penalty   = %.4f", AG.couplingPenalty());
    printf("\n[TwoGraph] Risk throttle (0..1)     = %.4f", thr);
    printf("\n[TwoGraph] Suggested Lots scale     = %.3f", baseRisk * (0.25 + 0.75*thr));
  }

  // Demo run: compare two regimes (directional vs choppy) under same asset coupling
  void demo() {
    // Case A: directional
    buildToyInputs(1);
    double thrA = riskThrottle();
    printf("\n=== CASE A: Directional regime ===");
    RG.G.dump("\nRegime graph shortest distances:");
    AG.G.dump("\nAsset graph shortest distances:");
    explain(thrA);

    // Case B: choppy
    buildToyInputs(0);
    double thrB = riskThrottle();
    printf("\n\n=== CASE B: Choppy regime ===");
    RG.G.dump("\nRegime graph shortest distances:");
    AG.G.dump("\nAsset graph shortest distances:");
    explain(thrB);

    printf("\n\nInterpretation:");
    printf("\n- If regime transitions are compact (predictable), throttle increases.");
    printf("\n- If assets are tightly coupled (low diversification), throttle decreases.");
    printf("\n- The trading engine can use throttle to scale order size / aggression.");
  }
};

// =============================== Entry ===================================
static TwoGraphStrategy* S = 0;

DLLFUNC void run()
{
  if(is(INITRUN))
  {
    if(!S) S = new TwoGraphStrategy();
    S->demo();
    quit("Done.");
  }
}

// Gri04.cpp - Zorro64 Strategy DLL (C++), Wiener index demo

#include <zorro.h>
#include <stdio.h>
#include <stdlib.h>

#define N   6
#define INF 1000000

struct Graph {
  int n;
  int* d; // flat n*n matrix
};

static int Graph_pos(const Graph* g, int r, int c) {
  return r*g->n + c;
}

static Graph* Graph_create(int n) {
  Graph* g = (Graph*)malloc(sizeof(Graph));
  if(!g) return 0;

  g->n = n;
  g->d = (int*)malloc(n*n*sizeof(int));
  if(!g->d) { free(g); return 0; }

  return g;
}

static void Graph_destroy(Graph* g) {
  if(!g) return;
  if(g->d) free(g->d);
  free(g);
}

static void Graph_reset(Graph* g) {
  for(int r=0; r<g->n; r++) {
    for(int c=0; c<g->n; c++) {
      g->d[Graph_pos(g,r,c)] = (r==c) ? 0 : INF;
    }
  }
}

static void Graph_link(Graph* g, int a, int b) {
  g->d[Graph_pos(g,a,b)] = 1;
  g->d[Graph_pos(g,b,a)] = 1;
}

static void Graph_buildBenzene(Graph* g) {
  Graph_reset(g);
  Graph_link(g,0,1);
  Graph_link(g,1,2);
  Graph_link(g,2,3);
  Graph_link(g,3,4);
  Graph_link(g,4,5);
  Graph_link(g,5,0);
}

static void Graph_allPairsShortest(Graph* g) {
  for(int k=0; k<g->n; k++) {
    for(int i=0; i<g->n; i++) {
      for(int j=0; j<g->n; j++) {
        int ij = Graph_pos(g,i,j);
        int ik = Graph_pos(g,i,k);
        int kj = Graph_pos(g,k,j);
        int cand = g->d[ik] + g->d[kj];
        if(cand < g->d[ij]) g->d[ij] = cand;
      }
    }
  }
}

static double Graph_wiener(const Graph* g) {
  double W = 0.0;
  for(int i=0; i<g->n; i++)
    for(int j=i+1; j<g->n; j++)
      W += (double)g->d[Graph_pos(g,i,j)];
  return W;
}

static void Graph_dump(const Graph* g) {
  printf("\nDistance matrix:");
  for(int r=0; r<g->n; r++) {
    printf("\n");
    for(int c=0; c<g->n; c++)
      printf("%2d ", g->d[Graph_pos(g,r,c)]);
  }
}

static int doMain()
{
  Graph* G = Graph_create(N);
  if(!G) {
    printf("\nOOM creating Graph");
    return 1;
  }

  Graph_buildBenzene(G);
  Graph_allPairsShortest(G);

  double W = Graph_wiener(G);

  Graph_dump(G);
  printf("\n\nWiener index (benzene C6) = %.0f\n", W);

  Graph_destroy(G);
  return 0;
}

// Zorro entry point for DLL strategies
DLLFUNC void run()
{
  // Only run once at start
  if(is(INITRUN)) {
    doMain();
    quit("Done.");
  }
}