Function bodies 361 total

public class EventPackBuilder {

    private final long pcode;

    public EventPackBuilder(long pcode) {
        this.pcode = pcode;
    }

    /**
     * Build an alert message from an anomaly result.
     */
    public AlertMessage build(AnomalyResult result) {
        String title = String.format("[TurboQuant] Anomaly detected on agent %d", result.oid);
        String message = String.format(
                "Cosine similarity dropped to %.4f (threshold: %.4f).\n" +
                "This indicates the server's metric pattern has significantly deviated from its baseline.\n" +
                "Details: %s",
                result.similarity, result.threshold, result.detail);

        String level = result.similarity < result.threshold * 0.7f ? "CRITICAL" : "WARNING";

        return new AlertMessage(pcode, result.oid, result.timestamp, title, message, level);
    }

    public static class AlertMessage {
        public final long pcode;
        public final int oid;
        public fi

    public EventPackBuilder(long pcode) {
        this.pcode = pcode;
    }

    public AlertMessage build(AnomalyResult result) {
        String title = String.format("[TurboQuant] Anomaly detected on agent %d", result.oid);
        String message = String.format(
                "Cosine similarity dropped to %.4f (threshold: %.4f).\n" +
                "This indicates the server's metric pattern has significantly deviated from its baseline.\n" +
                "Details: %s",
                result.similarity, result.threshold, result.detail);

        String level = result.similarity < result.threshold * 0.7f ? "CRITICAL" : "WARNING";

        return new AlertMessage(pcode, result.oid, result.timestamp, title, message, level);
    }

    public static class AlertMessage {
        public final long pcode;
        public final int oid;
        public final long timestamp;
        public final String title;
        public final String message;
        public final String level;

        public AlertMessage(long pcode, int oid, long timestamp, String title, String message, String level) {
            this.pcode = pcode;
            this.oid = oid;
            this.timestamp = timestamp;
            this.title = title;
            this.message = message;
            this.level = level;
        }

        public String toString() {
            return String.format("[%s] %s\n  OID: %d, PCode: %d\n  %s", level, title, oid, pcode, message);
        }
    }

        public AlertMessage(long pcode, int oid, long timestamp, String title, String message, String level) {
            this.pcode = pcode;
            this.oid = oid;
            this.timestamp = timestamp;
            this.title = title;
            this.message = message;
            this.level = level;
        }

        public String toString() {
            return String.format("[%s] %s\n  OID: %d, PCode: %d\n  %s", level, title, oid, pcode, message);
        }

public class AnomalyMain {

    private static final int NUM_AGENTS = 20;
    private static final int TIME_STEPS = 60;
    private static final int BASELINE_WINDOWS = 24; // 24 windows for baseline
    private static final long PCODE = 12345L;

    public static void main(String[] args) {
        System.out.println("=== TurboQuant Anomaly Detection Demo ===");
        System.out.println("Agents: " + NUM_AGENTS + ", Baseline windows: " + BASELINE_WINDOWS);
        System.out.println();

        Random rng = new Random(42);
        VectorBuilder builder = new VectorBuilder(TIME_STEPS);

        // --- Phase 1: Build baselines from normal data ---
        System.out.println("Phase 1: Building baselines...");
        BaselineBuilder baselineBuilder = new BaselineBuilder();

        Map<Integer, double[]> agentProfiles = new LinkedHashMap<Integer, double[]>();
        for (int a = 0; a < NUM_AGENTS; a++) {
            int oid = 1000 + a;
            double cpuBase = 30 + rng.nextDouble() *

    public static void main(String[] args) {
        System.out.println("=== TurboQuant Anomaly Detection Demo ===");
        System.out.println("Agents: " + NUM_AGENTS + ", Baseline windows: " + BASELINE_WINDOWS);
        System.out.println();

        Random rng = new Random(42);
        VectorBuilder builder = new VectorBuilder(TIME_STEPS);

        // --- Phase 1: Build baselines from normal data ---
        System.out.println("Phase 1: Building baselines...");
        BaselineBuilder baselineBuilder = new BaselineBuilder();

        Map<Integer, double[]> agentProfiles = new LinkedHashMap<Integer, double[]>();
        for (int a = 0; a < NUM_AGENTS; a++) {
            int oid = 1000 + a;
            double cpuBase = 30 + rng.nextDouble() * 30;
            double memBase = 40 + rng.nextDouble() * 20;
            double tpsBase = 80 + rng.nextDouble() * 60;
            agentProfiles.put(oid, new double[]{cpuBase, memBase, tpsBase});

            List<ServerStateVector> history = new

    private static List<Map<String, Double>> generateNormalSnapshots(
            Random rng, int timeSteps, double cpuBase, double memBase, double tpsBase) {
        List<Map<String, Double>> snapshots = new ArrayList<Map<String, Double>>();
        for (int t = 0; t < timeSteps; t++) {
            Map<String, Double> snap = new LinkedHashMap<String, Double>();
            snap.put("cpu", cpuBase + rng.nextGaussian() * 3 + 2 * Math.sin(2 * Math.PI * t / 30.0));
            snap.put("mem", memBase + rng.nextGaussian() * 2);
            snap.put("heap_use", 55.0 + rng.nextGaussian() * 5);
            snap.put("tps", tpsBase + rng.nextGaussian() * 8);
            snap.put("resp_time", 200.0 + rng.nextGaussian() * 30);
            snap.put("gc_count", 3.0 + rng.nextGaussian());
            snap.put("service_error", 1.0 + rng.nextDouble() * 2);
            snap.put("act_svc_count", 2.0 + Math.abs(rng.nextGaussian()));
            snapshots.add(snap);
        }
        return snapshots;
   

    private static List<Map<String, Double>> generateAnomalousSnapshots(
            Random rng, int timeSteps, double cpuBase, double memBase, double tpsBase, double respTime) {
        List<Map<String, Double>> snapshots = new ArrayList<Map<String, Double>>();
        for (int t = 0; t < timeSteps; t++) {
            Map<String, Double> snap = new LinkedHashMap<String, Double>();
            snap.put("cpu", cpuBase + rng.nextGaussian() * 2);
            snap.put("mem", memBase + rng.nextGaussian() * 2);
            snap.put("heap_use", 80.0 + rng.nextGaussian() * 3);
            snap.put("tps", tpsBase + rng.nextGaussian() * 5);
            snap.put("resp_time", respTime + rng.nextGaussian() * 50);
            snap.put("gc_count", 10.0 + Math.abs(rng.nextGaussian()) * 5);
            snap.put("service_error", 10.0 + rng.nextDouble() * 10);
            snap.put("act_svc_count", 8.0 + Math.abs(rng.nextGaussian()) * 3);
            snapshots.add(snap);
        }
        return snapshots

public class BaselineBuilder {

    private final Map<Integer, BaselineEntry> baselines = new HashMap<Integer, BaselineEntry>();

    /**
     * Build baseline from a list of historical state vectors per server.
     */
    public void build(int oid, List<ServerStateVector> history) {
        if (history.isEmpty()) return;

        int dim = history.get(0).getDimension();
        float[] mean = new float[dim];
        float[] variance = new float[dim];
        int n = history.size();

        // Compute mean
        for (ServerStateVector sv : history) {
            float[] vec = sv.getVector();
            for (int i = 0; i < dim; i++) {
                mean[i] += vec[i] / n;
            }
        }

        // Compute variance
        for (ServerStateVector sv : history) {
            float[] vec = sv.getVector();
            for (int i = 0; i < dim; i++) {
                float diff = vec[i] - mean[i];
                variance[i] += diff * diff / n;
            }
        }

        

    public void build(int oid, List<ServerStateVector> history) {
        if (history.isEmpty()) return;

        int dim = history.get(0).getDimension();
        float[] mean = new float[dim];
        float[] variance = new float[dim];
        int n = history.size();

        // Compute mean
        for (ServerStateVector sv : history) {
            float[] vec = sv.getVector();
            for (int i = 0; i < dim; i++) {
                mean[i] += vec[i] / n;
            }
        }

        // Compute variance
        for (ServerStateVector sv : history) {
            float[] vec = sv.getVector();
            for (int i = 0; i < dim; i++) {
                float diff = vec[i] - mean[i];
                variance[i] += diff * diff / n;
            }
        }

        float[] std = new float[dim];
        for (int i = 0; i < dim; i++) {
            std[i] = (float) Math.sqrt(variance[i]);
        }

        // Compute mean similarity using Mahalanobis-like distance
        double sumS

    public BaselineEntry getBaseline(int oid) {
        return baselines.get(oid);
    }

    public Map<Integer, BaselineEntry> getAllBaselines() {
        return baselines;
    }

    private static float mahalanobisSimilarity(float[] vec, float[] mean, float[] std) {
        double distSq = 0;
        int dim = vec.length;
        for (int i = 0; i < dim; i++) {
            double diff = vec[i] - mean[i];
            double var = std[i] * std[i];
            if (var < 1e-6) var = 1e-6;
            distSq += (diff * diff) / var;
        }
        double avgDist = Math.sqrt(distSq / dim);
        return (float) (1.0 / (1.0 + avgDist));
    }

    public static class BaselineEntry {
        public final int oid;
        public final float[] mean;
        public final float[] std;
        public final float meanSimilarity;
        public final float stdSimilarity;
        public final int sampleCount;

        public BaselineEntry(int oid, float[] mean, float[] std,
                             float meanSimilarity, float stdSimilarity, int sampleCount) {
            this.oid = oid;
            this.mean = mean;
            this.std = std;
            this.meanSimilarity = meanSimilarity;
            this.stdSimilarity = stdSimilarity;
            this.sampleCount = sampleCount;
        }
    }

        public BaselineEntry(int oid, float[] mean, float[] std,
                             float meanSimilarity, float stdSimilarity, int sampleCount) {
            this.oid = oid;
            this.mean = mean;
            this.std = std;
            this.meanSimilarity = meanSimilarity;
            this.stdSimilarity = stdSimilarity;
            this.sampleCount = sampleCount;
        }

public class AnomalyDetector {

    private final BaselineBuilder baselineBuilder;
    private final float sigmaMultiplier;
    private final float fixedThreshold;
    private final boolean useAdaptiveThreshold;

    /**
     * @param baselineBuilder the baseline data
     * @param sigmaMultiplier for adaptive threshold: mean - sigma * multiplier
     * @param fixedThreshold fallback fixed threshold (cosine similarity)
     */
    public AnomalyDetector(BaselineBuilder baselineBuilder, float sigmaMultiplier, float fixedThreshold) {
        this.baselineBuilder = baselineBuilder;
        this.sigmaMultiplier = sigmaMultiplier;
        this.fixedThreshold = fixedThreshold;
        this.useAdaptiveThreshold = true;
    }

    public AnomalyDetector(BaselineBuilder baselineBuilder, float fixedThreshold) {
        this.baselineBuilder = baselineBuilder;
        this.sigmaMultiplier = 0;
        this.fixedThreshold = fixedThreshold;
        this.useAdaptiveThreshold = false;
    }

    /**
 

    public AnomalyDetector(BaselineBuilder baselineBuilder, float sigmaMultiplier, float fixedThreshold) {
        this.baselineBuilder = baselineBuilder;
        this.sigmaMultiplier = sigmaMultiplier;
        this.fixedThreshold = fixedThreshold;
        this.useAdaptiveThreshold = true;
    }

    public AnomalyDetector(BaselineBuilder baselineBuilder, float fixedThreshold) {
        this.baselineBuilder = baselineBuilder;
        this.sigmaMultiplier = 0;
        this.fixedThreshold = fixedThreshold;
        this.useAdaptiveThreshold = false;
    }

    public AnomalyResult detect(ServerStateVector current) {
        BaselineBuilder.BaselineEntry baseline = baselineBuilder.getBaseline(current.getOid());
        if (baseline == null) {
            return new AnomalyResult(current.getOid(), current.getTimestamp(),
                    0f, 0f, false, "No baseline available");
        }

        // Mahalanobis-like distance: sum of (x_i - mean_i)^2 / max(std_i^2, epsilon)
        float[] vec = current.getVector();
        double distSq = 0;
        int dim = vec.length;
        for (int i = 0; i < dim; i++) {
            double diff = vec[i] - baseline.mean[i];
            double var = baseline.std[i] * baseline.std[i];
            if (var < 1e-6) var = 1e-6;
            distSq += (diff * diff) / var;
        }
        double avgDist = Math.sqrt(distSq / dim); // normalized distance
        float similarity = (float) (1.0 / (1.0 + avgDist)); // convert to [0,1] similarity

        float threshold;
        if (useAdaptiveThreshold && ba

    public List<AnomalyResult> detectBatch(List<ServerStateVector> currentStates) {
        List<AnomalyResult> results = new ArrayList<AnomalyResult>();
        for (ServerStateVector sv : currentStates) {
            results.add(detect(sv));
        }
        return results;
    }

    private static float cosineSimilarity(float[] a, float[] b) {
        float dot = 0, normA = 0, normB = 0;
        for (int i = 0; i < a.length; i++) {
            dot += a[i] * b[i];
            normA += a[i] * a[i];
            normB += b[i] * b[i];
        }
        normA = (float) Math.sqrt(normA);
        normB = (float) Math.sqrt(normB);
        if (normA < 1e-10f || normB < 1e-10f) return 0f;
        return dot / (normA * normB);
    }

public class AnomalyResult {
    public final int oid;
    public final long timestamp;
    public final float similarity;
    public final float threshold;
    public final boolean isAnomaly;
    public final String detail;

    public AnomalyResult(int oid, long timestamp, float similarity, float threshold,
                         boolean isAnomaly, String detail) {
        this.oid = oid;
        this.timestamp = timestamp;
        this.similarity = similarity;
        this.threshold = threshold;
        this.isAnomaly = isAnomaly;
        this.detail = detail;
    }

    public String toString() {
        return String.format("[%s] oid=%d sim=%.4f threshold=%.4f %s",
                isAnomaly ? "ANOMALY" : "NORMAL", oid, similarity, threshold, detail);
    }
}

    public AnomalyResult(int oid, long timestamp, float similarity, float threshold,
                         boolean isAnomaly, String detail) {
        this.oid = oid;
        this.timestamp = timestamp;
        this.similarity = similarity;
        this.threshold = threshold;
        this.isAnomaly = isAnomaly;
        this.detail = detail;
    }

    public String toString() {
        return String.format("[%s] oid=%d sim=%.4f threshold=%.4f %s",
                isAnomaly ? "ANOMALY" : "NORMAL", oid, similarity, threshold, detail);
    }

public class BitPackedVector {

    /**
     * Pack indices into a byte array using numBits per index.
     */
    public static byte[] pack(int[] indices, int numBits, int dimension) {
        int totalBits = dimension * numBits;
        int numBytes = (totalBits + 7) / 8;
        byte[] packed = new byte[numBytes];

        int bitPos = 0;
        for (int i = 0; i < dimension; i++) {
            int value = indices[i];
            for (int b = numBits - 1; b >= 0; b--) {
                int bit = (value >> b) & 1;
                int byteIdx = bitPos / 8;
                int bitIdx = 7 - (bitPos % 8);
                packed[byteIdx] |= (byte) (bit << bitIdx);
                bitPos++;
            }
        }

        return packed;
    }

    /**
     * Unpack indices from a bit-packed byte array.
     */
    public static int[] unpack(byte[] packed, int numBits, int dimension) {
        int[] indices = new int[dimension];

        int bitPos = 0;
        for (int i = 0; i < dimensi

    public static byte[] pack(int[] indices, int numBits, int dimension) {
        int totalBits = dimension * numBits;
        int numBytes = (totalBits + 7) / 8;
        byte[] packed = new byte[numBytes];

        int bitPos = 0;
        for (int i = 0; i < dimension; i++) {
            int value = indices[i];
            for (int b = numBits - 1; b >= 0; b--) {
                int bit = (value >> b) & 1;
                int byteIdx = bitPos / 8;
                int bitIdx = 7 - (bitPos % 8);
                packed[byteIdx] |= (byte) (bit << bitIdx);
                bitPos++;
            }
        }

        return packed;
    }

    public static int[] unpack(byte[] packed, int numBits, int dimension) {
        int[] indices = new int[dimension];

        int bitPos = 0;
        for (int i = 0; i < dimension; i++) {
            int value = 0;
            for (int b = numBits - 1; b >= 0; b--) {
                int byteIdx = bitPos / 8;
                int bitIdx = 7 - (bitPos % 8);
                int bit = (packed[byteIdx] >> bitIdx) & 1;
                value |= (bit << b);
                bitPos++;
            }
            indices[i] = value;
        }

        return indices;
    }

    public static int packedSize(int dimension, int numBits) {
        return (dimension * numBits + 7) / 8;
    }

public class LloydMaxCodebook {

    private final int numBits;
    private final int codebookSize;
    private final float[] centroids;

    public LloydMaxCodebook(int numBits, int dimension) {
        this.numBits = numBits;
        this.codebookSize = 1 << numBits;
        this.centroids = computeCodebook(numBits, dimension);
    }

    public float[] getCentroids() {
        return centroids;
    }

    public int getCodebookSize() {
        return codebookSize;
    }

    /**
     * Compute Lloyd-Max optimal codebook for Beta(alpha, alpha) distribution
     * where alpha = d/2. For high dimensions, Beta(d/2,d/2) is approximately
     * normal with mean=0, variance=1/d (after centering).
     */
    private static float[] computeCodebook(int numBits, int dimension) {
        int k = 1 << numBits;
        double alpha = dimension / 2.0;

        // For high-dimensional case, approximate Beta(d/2,d/2) as N(0, 1/(4*alpha))
        // after mapping [0,1] -> centered. The standard devi

    public LloydMaxCodebook(int numBits, int dimension) {
        this.numBits = numBits;
        this.codebookSize = 1 << numBits;
        this.centroids = computeCodebook(numBits, dimension);
    }

    public float[] getCentroids() {
        return centroids;
    }

    public int getCodebookSize() {
        return codebookSize;
    }

    private static float[] computeCodebook(int numBits, int dimension) {
        int k = 1 << numBits;
        double alpha = dimension / 2.0;

        // For high-dimensional case, approximate Beta(d/2,d/2) as N(0, 1/(4*alpha))
        // after mapping [0,1] -> centered. The standard deviation is approx 1/(2*sqrt(d))
        double sigma = 1.0 / (2.0 * Math.sqrt(dimension));

        // Initialize centroids uniformly in [-3*sigma, 3*sigma]
        float[] centroids = new float[k];
        double range = 6.0 * sigma;
        for (int i = 0; i < k; i++) {
            centroids[i] = (float) (-3.0 * sigma + range * (i + 0.5) / k);
        }

        // Lloyd-Max iteration
        int maxIter = 300;
        int numSamples = 10000;
        double[] samples = generateBetaSamples(alpha, numSamples);

        for (int iter = 0; iter < maxIter; iter++) {
            // Compute decision boundaries (midpoints between adjacent centroids)
            double[] boundaries = new double[k + 1];
       

    private static double[] generateBetaSamples(double alpha, int n) {
        double[] samples = new double[n];
        double sigma = 1.0 / (2.0 * Math.sqrt(2.0 * alpha));

        java.util.Random rng = new java.util.Random(12345);
        for (int i = 0; i < n; i++) {
            // Centered Beta: mean=0.5, var=1/(4*(2*alpha+1))
            // Shifted to center at 0: subtract 0.5
            samples[i] = rng.nextGaussian() * sigma;
        }
        return samples;
    }

public class QJLProjection {

    private final int originalDim;
    private final int projectionDim;
    private final float[][] projMatrix; // projectionDim x originalDim
    private final float[][] projMatrixT; // originalDim x projectionDim

    public QJLProjection(int originalDim, int projectionDim, long seed) {
        this.originalDim = originalDim;
        this.projectionDim = projectionDim;
        this.projMatrix = new float[projectionDim][originalDim];
        this.projMatrixT = new float[originalDim][projectionDim];

        Random rng = new Random(seed);
        float scale = 1.0f / (float) Math.sqrt(originalDim);
        for (int i = 0; i < projectionDim; i++) {
            for (int j = 0; j < originalDim; j++) {
                float v = rng.nextBoolean() ? scale : -scale; // random sign matrix
                projMatrix[i][j] = v;
                projMatrixT[j][i] = v;
            }
        }
    }

    /**
     * Project residual and extract signs (1-bit per dimension

    public QJLProjection(int originalDim, int projectionDim, long seed) {
        this.originalDim = originalDim;
        this.projectionDim = projectionDim;
        this.projMatrix = new float[projectionDim][originalDim];
        this.projMatrixT = new float[originalDim][projectionDim];

        Random rng = new Random(seed);
        float scale = 1.0f / (float) Math.sqrt(originalDim);
        for (int i = 0; i < projectionDim; i++) {
            for (int j = 0; j < originalDim; j++) {
                float v = rng.nextBoolean() ? scale : -scale; // random sign matrix
                projMatrix[i][j] = v;
                projMatrixT[j][i] = v;
            }
        }
    }

    public ProjectionResult project(float[] residual) {
        float norm = 0;
        for (float v : residual) norm += v * v;
        norm = (float) Math.sqrt(norm);

        // Project: z = S * r
        float[] z = new float[projectionDim];
        for (int i = 0; i < projectionDim; i++) {
            float sum = 0;
            for (int j = 0; j < originalDim; j++) {
                sum += projMatrix[i][j] * residual[j];
            }
            z[i] = sum;
        }

        // Extract signs (pack into bytes)
        byte[] signs = new byte[(projectionDim + 7) / 8];
        for (int i = 0; i < projectionDim; i++) {
            if (z[i] >= 0) {
                signs[i / 8] |= (byte) (1 << (7 - i % 8));
            }
        }

        return new ProjectionResult(signs, norm);
    }

    public float[] reconstruct(byte[] signs, float norm) {
        // Unpack signs to +1/-1
        float[] signVec = new float[projectionDim];
        for (int i = 0; i < projectionDim; i++) {
            int bit = (signs[i / 8] >> (7 - i % 8)) & 1;
            signVec[i] = bit == 1 ? 1.0f : -1.0f;
        }

        // y = S^T * signs
        float[] y = new float[originalDim];
        for (int i = 0; i < originalDim; i++) {
            float sum = 0;
            for (int j = 0; j < projectionDim; j++) {
                sum += projMatrixT[i][j] * signVec[j];
            }
            y[i] = sum;
        }

        // Scale: r_approx = (norm / ||y||) * y
        float yNorm = 0;
        for (float v : y) yNorm += v * v;
        yNorm = (float) Math.sqrt(yNorm);

        if (yNorm > 1e-10f) {
            float scale = norm / yNorm;
            for (int i = 0; i < originalDim; i++) {
                y[i] *= scale;
            }
        }

        return y;
    }

    public static class ProjectionResult {
        public final byte[] signs;
        public final float norm;

        public ProjectionResult(byte[] signs, float norm) {
            this.signs = signs;
            this.norm = norm;
        }
    }

        public ProjectionResult(byte[] signs, float norm) {
            this.signs = signs;
            this.norm = norm;
        }

public class RandomRotation {

    private final int dimension;
    private final float[][] Q; // orthogonal matrix
    private final float[][] QT; // transpose (for inverse)

    public RandomRotation(int dimension, long seed) {
        this.dimension = dimension;
        Random rng = new Random(seed);

        // Generate random Gaussian matrix
        float[][] A = new float[dimension][dimension];
        for (int i = 0; i < dimension; i++) {
            for (int j = 0; j < dimension; j++) {
                A[i][j] = (float) rng.nextGaussian();
            }
        }

        // QR decomposition via Modified Gram-Schmidt
        this.Q = qrGramSchmidt(A, dimension);
        this.QT = transpose(Q, dimension);
    }

    public float[] rotate(float[] x) {
        return matvec(Q, x, dimension);
    }

    public float[] inverseRotate(float[] y) {
        return matvec(QT, y, dimension);
    }

    private static float[][] qrGramSchmidt(float[][] A, int n) {
        float[][] Q = new 

    public RandomRotation(int dimension, long seed) {
        this.dimension = dimension;
        Random rng = new Random(seed);

        // Generate random Gaussian matrix
        float[][] A = new float[dimension][dimension];
        for (int i = 0; i < dimension; i++) {
            for (int j = 0; j < dimension; j++) {
                A[i][j] = (float) rng.nextGaussian();
            }
        }

        // QR decomposition via Modified Gram-Schmidt
        this.Q = qrGramSchmidt(A, dimension);
        this.QT = transpose(Q, dimension);
    }

    public float[] rotate(float[] x) {
        return matvec(Q, x, dimension);
    }

    public float[] inverseRotate(float[] y) {
        return matvec(QT, y, dimension);
    }

    private static float[][] qrGramSchmidt(float[][] A, int n) {
        float[][] Q = new float[n][n];

        // Copy columns
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                Q[j][i] = A[j][i]; // column i
            }
        }

        for (int i = 0; i < n; i++) {
            // Normalize column i
            float norm = 0;
            for (int j = 0; j < n; j++) {
                norm += Q[j][i] * Q[j][i];
            }
            norm = (float) Math.sqrt(norm);
            if (norm < 1e-10f) norm = 1e-10f;
            for (int j = 0; j < n; j++) {
                Q[j][i] /= norm;
            }

            // Orthogonalize subsequent columns against column i
            for (int k = i + 1; k < n; k++) {
                float dot = 0;
                for (int j = 0; j < n; j++) {
                    dot += Q[j][i] * Q[j][k];
                }
                for (int j = 0; j < n; j++) {
                    Q[j][k] -= dot * Q[j][

    private static float[][] transpose(float[][] M, int n) {
        float[][] T = new float[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                T[i][j] = M[j][i];
            }
        }
        return T;
    }

    private static float[] matvec(float[][] M, float[] v, int n) {
        float[] result = new float[n];
        for (int i = 0; i < n; i++) {
            float sum = 0;
            for (int j = 0; j < n; j++) {
                sum += M[i][j] * v[j];
            }
            result[i] = sum;
        }
        return result;
    }

public class RotationCache {

    private static final ConcurrentHashMap<Long, RandomRotation> cache =
            new ConcurrentHashMap<Long, RandomRotation>();

    /**
     * Get or create a cached RandomRotation for the given dimension and seed.
     */
    public static RandomRotation get(int dimension, long seed) {
        long key = ((long) dimension << 32) ^ seed;
        RandomRotation existing = cache.get(key);
        if (existing != null) {
            return existing;
        }
        RandomRotation rotation = new RandomRotation(dimension, seed);
        cache.putIfAbsent(key, rotation);
        return cache.get(key);
    }

    /**
     * Clear all cached rotations (for testing/memory management).
     */
    public static void clear() {
        cache.clear();
    }

    /**
     * Number of cached rotation matrices.
     */
    public static int size() {
        return cache.size();
    }
}