### Compound Distributions in Zig

Source: https://context7.com/pblischak/zprob/llms.txt

Illustrates creating compound distributions where the output of one distribution serves as a parameter for another, using the Beta-Binomial distribution as an example. This requires Zig's standard library and the zprob module, along with an allocator. It generates samples for one distribution and uses them to parameterize another, demonstrating flexible probabilistic modeling.

```zig
const std = @import("std");
const zprob = @import("zprob");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    defer _ = gpa.deinit();

    var env = try zprob.RandomEnvironment.init(allocator);
    defer env.deinit();

    // Beta-Binomial Distribution
    const alpha: f64 = 5.0;
    const beta: f64 = 2.0;
    const n: u32 = 20;
    const size: usize = 1000;

    // Generate Beta samples (probability parameters)
    const beta_samples = try env.rBetaSlice(size, alpha, beta);
    defer allocator.free(beta_samples);

    // Use Beta samples as Binomial probabilities
    var beta_binomial_samples = try allocator.alloc(u32, size);
    defer allocator.free(beta_binomial_samples);

    for (beta_samples, 0..) |p, i| {
        beta_binomial_samples[i] = try env.rBinomial(n, p);
    }

    // Calculate mean of compound distribution
    var sum: f64 = 0.0;
    for (beta_binomial_samples) |value| {
        sum += @as(f64, @floatFromInt(value));
    }
    const mean = sum / @as(f64, @floatFromInt(size));
    std.debug.print("Beta-Binomial mean: {d:.4}\\n", .{mean});
}

```

--------------------------------

### Initialize and Use RandomEnvironment in Zig

Source: https://github.com/pblischak/zprob/blob/main/README.md

Demonstrates initializing the RandomEnvironment, generating random samples from Binomial and Geometric distributions, and creating slices of samples. It requires the 'zprob' module and utilizes Zig's standard library for memory allocation and debugging.

```zig
const std = @import("std");
const zprob = @import("zprob");

pub fn main() !void {
    // Set up main memory allocator and defer deinitilization
    var gpa = std.heap.DebugAllocator.init(.{}, allocator);
    defer {
        const status = gpa.deinit();
        std.testing.expect(status == .ok) catch {
            @panic("Memory leak!");
        };
    }

    // Set up random environment and defer deinitialization
    var env = try zprob.RandomEnvironment.init(allocator);
    defer env.deinit();

    // Generate random samples
    const binomial_sample = try env.rBinomial(10, 0.8);
    const geometric_sample = try env.rGeometric(0.3);
    std.debug.print("b = {d};\tg = {d}\n", .{ binomial_sample, geometric_sample });

    // Generate slices of random samples. The caller is responsible for cleaning up
    // the allocated memory for the slice.
    const binomial_slice = try env.rBinomialSlice(100, 20, 0.4);
    defer allocator.free(binomial_slice);
}
```

--------------------------------

### Initialize RandomEnvironment in Zig

Source: https://context7.com/pblischak/zprob/llms.txt

Demonstrates how to initialize a RandomEnvironment in Zig, either with automatic seeding or a specific seed for reproducible random number generation. This is the first step for using the zprob library's sampling functionalities.

```zig
const std = @import("std");
const zprob = @import("zprob");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    defer _ = gpa.deinit();

    // Auto-seeded initialization
    var env = try zprob.RandomEnvironment.init(allocator);
    defer env.deinit();

    // Or with explicit seed for reproducibility
    var env_seeded = try zprob.RandomEnvironment.initWithSeed(1234567890, allocator);
    defer env_seeded.deinit();

    std.debug.print("Random seed: {}\n", .{env.seed});
}
```

--------------------------------

### Command Line Integration for zprob

Source: https://context7.com/pblischak/zprob/llms.txt

Provides the bash commands necessary to fetch the zprob dependency, build a Zig project that uses it, and run its tests. These commands interact with the Zig build system and package management.

```bash
# Add dependency to project
zig fetch --save git+https://github.com/pblischak/zprob/

# Build project
zig build

# Run tests
zig build test

```

--------------------------------

### Zig Build System Integration for zprob

Source: https://context7.com/pblischak/zprob/llms.txt

Shows how to add the zprob library as a dependency to a Zig project using its build system. This involves defining the dependency in `build.zig.zon` and then referencing it within the `build.zig` file to make the zprob module available to the project's source code.

```zig
// build.zig.zon
.{ 
    .name = "my-project",
    .version = "0.1.0",
    .dependencies = .{
        .zprob = .{
            .url = "git+https://github.com/pblischak/zprob/",
        },
    },
}

// build.zig
pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    const exe = b.addExecutable(.{
        .name = "my-project",
        .root_source_file = b.path("src/main.zig"),
        .target = target,
        .optimize = optimize,
    });

    const zprob_dep = b.dependency("zprob", .{
        .target = target,
        .optimize = optimize,
    });

    const zprob_module = zprob_dep.module("zprob");
    exe.root_module.addImport("zprob", zprob_module);

    b.installArtifact(exe);
}

```

--------------------------------

### Sample Continuous Distributions in Zig

Source: https://context7.com/pblischak/zprob/llms.txt

Illustrates generating random samples from continuous probability distributions using zprob's RandomEnvironment in Zig. Supported distributions include Normal, Beta, Gamma, Exponential, and Uniform.

```zig
const std = @import("std");
const zprob = @import("zprob");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    defer _ = gpa.deinit();

    var env = try zprob.RandomEnvironment.init(allocator);
    defer env.deinit();

    // Normal: mu=10.0 mean, sigma=2.5 standard deviation
    const normal_sample = try env.rNormal(10.0, 2.5);
    std.debug.print("Normal sample: {}\n", .{normal_sample});

    // Beta: alpha=2.0, beta=5.0
    const beta_sample = try env.rBeta(2.0, 5.0);
    std.debug.print("Beta sample: {}\n", .{beta_sample});

    // Gamma: shape=2.0, scale=5.0
    const gamma_sample = try env.rGamma(2.0, 5.0);
    std.debug.print("Gamma sample: {}\n", .{gamma_sample});

    // Exponential: lambda=2.0 rate parameter
    const exp_sample = try env.rExponential(2.0);
    std.debug.print("Exponential sample: {}\n", .{exp_sample});

    // Uniform: range [-2.0, 8.0]
    const uniform_sample = env.rUniform(-2.0, 8.0);
    std.debug.print("Uniform sample: {}\n", .{uniform_sample});
}
```

--------------------------------

### Utilize Distributions API for Sampling in Zig

Source: https://github.com/pblischak/zprob/blob/main/README.md

Demonstrates the lower-level Distributions API for more control over probability distributions. It involves manually setting up a random generator and then using distribution structs like Beta and Binomial to sample values. Requires Zig's standard library.

```zig
const std = @import("std");
const zprob = @import("zprob");

pub fn main() !void {
    // Set up random generator.
    const seed: u64 = @intCast(std.time.microTimestamp());
    var prng = std.Random.DefaultPrng.init(seed);
    var rand = prng.random();

    // Same as: `const beta = zprob.Beta(f64){}`;
    const beta = zprob.default_beta;
    // Same as: `const binomial = zprob.Binomial(u32, f64){}`
    const binomial = zprob.default_binomial;

    var b1: f64 = undefined;
    var b2: u32 = undefined;
    for (0..100) |_| {
        b1 = try beta.sample(1.0, 5.0, &rand);
        b2 = try binomial.sample(20, b1, &rand);
    }
}
```

--------------------------------

### Sample Discrete Distributions in Zig

Source: https://context7.com/pblischak/zprob/llms.txt

Shows how to generate random samples from various discrete probability distributions using zprob's RandomEnvironment in Zig. This includes Binomial, Poisson, Geometric, and Uniform integer distributions.

```zig
const std = @import("std");
const zprob = @import("zprob");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    defer _ = gpa.deinit();

    var env = try zprob.RandomEnvironment.init(allocator);
    defer env.deinit();

    // Binomial: n=10 trials, p=0.8 success probability
    const binomial_sample = try env.rBinomial(10, 0.8);
    std.debug.print("Binomial sample: {}\n", .{binomial_sample});

    // Poisson: lambda=5.0 rate parameter
    const poisson_sample = try env.rPoisson(5.0);
    std.debug.print("Poisson sample: {}\n", .{poisson_sample});

    // Geometric: p=0.3 success probability
    const geometric_sample = try env.rGeometric(0.3);
    std.debug.print("Geometric sample: {}\n", .{geometric_sample});

    // Uniform integer: range [-10, 20]
    const uniform_int = env.rUniformInt(-10, 20);
    std.debug.print("Uniform Int sample: {}\n", .{uniform_int});
}
```

--------------------------------

### Low-Level Distributions API in Zig

Source: https://context7.com/pblischak/zprob/llms.txt

Demonstrates using the zprob Distributions API for precise control over distribution types and direct access to sampling and probability calculation methods. It requires the 'std' and 'zprob' Zig modules. Inputs include distribution parameters and a random number generator; outputs are samples or probability values.

```zig
const std = @import("std");
const zprob = @import("zprob");

pub fn main() !void {
    // Set up random generator manually
    const seed: u64 = @intCast(std.time.microTimestamp());
    var prng = std.Random.DefaultPrng.init(seed);
    var rand = prng.random();

    // Create distribution instances with specific types
    const beta = zprob.Beta(f64){};
    const binomial = zprob.Binomial(u32, f64){};
    const normal = zprob.Normal(f64){};

    // Or use default distributions
    const default_beta = zprob.default_beta;
    const default_binomial = zprob.default_binomial;

    // Sample from distributions
    var beta_sample: f64 = undefined;
    var binomial_sample: u32 = undefined;

    for (0..100) |_| {
        beta_sample = try beta.sample(1.0, 5.0, &rand);
        binomial_sample = try binomial.sample(20, beta_sample, &rand);
        std.debug.print("Beta: {d:.4}, Binomial: {}\\n", .{beta_sample, binomial_sample});
    }

    // Calculate probabilities
    const prob = try binomial.pmf(8, 20, 0.4);
    const log_prob = try binomial.lnPmf(8, 20, 0.4);
    std.debug.print("P(X=8): {d:.6}, log(P): {d:.6}\\n", .{prob, log_prob});
}

```

--------------------------------

### Fetch zprob Main Branch using Zig

Source: https://github.com/pblischak/zprob/blob/main/README.md

Fetches the main branch of the zprob project, which tracks the latest release of Zig. This command should be run in your project directory to add zprob as a dependency.

```bash
zig fetch --save git+https://github.com/pblischak/zprob/
```

--------------------------------

### Initialize RandomEnvironment with a Specific Seed in Zig

Source: https://github.com/pblischak/zprob/blob/main/README.md

Shows how to initialize the RandomEnvironment with a specific seed value, ensuring reproducible random number generation. This method also requires an allocator for memory management.

```zig
var env = try zprob.RandomEnvironment.initWithSeed(1234567890, allocator);
defer env.deinit();
```

--------------------------------

### Generate Random Samples: Zig

Source: https://context7.com/pblischak/zprob/llms.txt

Generates arrays of random samples for binomial and normal distributions. It uses a general-purpose allocator and requires the zprob library. Returns allocated slices of samples.

```zig
const std = @import("std");
const zprob = @import("zprob");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    defer _ = gpa.deinit();

    var env = try zprob.RandomEnvironment.init(allocator);
    defer env.deinit();

    // Generate 100 binomial samples
    const binomial_slice = try env.rBinomialSlice(100, 20, 0.4);
    defer allocator.free(binomial_slice);
    std.debug.print("Binomial samples (first 10): {any}\n", .{binomial_slice[0..10]});

    // Generate 100 normal samples
    const normal_slice = try env.rNormalSlice(100, 0.0, 1.0);
    defer allocator.free(normal_slice);

    // Calculate sample mean
    var sum: f64 = 0.0;
    for (normal_slice) |value| {
        sum += value;
    }
    const mean = sum / @as(f64, @floatFromInt(normal_slice.len));
    std.debug.print("Sample mean: {d:.4}\n", .{mean});
}
```

--------------------------------

### Integrate zprob Module in build.zig

Source: https://github.com/pblischak/zprob/blob/main/README.md

Demonstrates how to add the zprob library as a dependency and import its module in a Zig project's `build.zig` file. This is essential for using zprob's functionalities in your Zig application.

```zig
pub fn build(b: *std.Build) void {
    // exe setup...

    const zprob_dep = b.dependency("zprob", .{
            .target = target,
            .optimize = optimize,
    });

    const zprob_module = zprob_dep.module("zprob");
    exe.root_module.addImport("zprob", zprob_module);

    // additional build steps...
}
```

--------------------------------

### Fetch zprob Nightly Branch using Zig

Source: https://github.com/pblischak/zprob/blob/main/README.md

Fetches the nightly branch of the zprob project, which tracks the Zig master branch. Append '#nightly' to the git URL to specify the nightly branch.

```bash
zig fetch --save git+https://github.com/pblischak/zprob/#nightly
```

--------------------------------

### Weighted Random Sampling: Zig

Source: https://context7.com/pblischak/zprob/llms.txt

Samples items from a collection based on specified probabilities or weights. Supports sampling a single item or multiple items with replacement. Requires the zprob library and returns the sampled item(s).

```zig
const std = @import("std");
const zprob = @import("zprob");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    defer _ = gpa.deinit();

    var env = try zprob.RandomEnvironment.init(allocator);
    defer env.deinit();

    // Define items and their weights
    const items = [_][]const u8{ "Common", "Uncommon", "Rare", "Epic", "Legendary" };
    const weights = [_]f64{ 0.5, 0.3, 0.15, 0.04, 0.01 };

    // Sample a single item
    const item = try env.rWeightedSample([]const u8, &items, &weights);
    std.debug.print("Sampled item: {s}\n", .{item});

    // Sample multiple items (with replacement)
    const item_samples = try env.rWeightedSampleSlice([]const u8, 100, &items, &weights);
    defer allocator.free(item_samples);

    // Count frequencies
    var counts = [_]usize{0} ** 5;
    for (item_samples) |sampled| {
        for (items, 0..) |ref_item, i| {
            if (std.mem.eql(u8, sampled, ref_item)) {
                counts[i] += 1;
            }
        }
    }
    std.debug.print("Item counts: {any}\n", .{counts});
}
```

--------------------------------

### Multivariate Distribution Sampling: Zig

Source: https://context7.com/pblischak/zprob/llms.txt

Samples from multivariate distributions such as Multinomial and Dirichlet. Allows compile-time specification of dimensions and requires the zprob library. Outputs samples as arrays.

```zig
const std = @import("std");
const zprob = @import("zprob");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    defer _ = gpa.deinit();

    var env = try zprob.RandomEnvironment.init(allocator);
    defer env.deinit();

    // Multinomial: 10 trials across 5 categories
    const multinomial_sample = try env.rMultinomial(
        5,
        10,
        [_]f64{ 0.1, 0.3, 0.3, 0.2, 0.1 }
    );
    std.debug.print("Multinomial sample: {any}\n", .{multinomial_sample});

    // Multinomial PMF
    const mnm_prob = try env.dMultinomial(
        3,
        [_]u32{ 2, 3, 1 },
        [_]f64{ 0.25, 0.55, 0.2 },
        false
    );
    std.debug.print("Multinomial probability: {d:.6}\n", .{mnm_prob});

    // Dirichlet: concentration parameters
    const dirichlet_sample = try env.rDirichlet(
        4,
        [_]f64{ 0.1, 0.3, 0.3, 0.1 }
    );
    std.debug.print("Dirichlet sample: {any}\n", .{dirichlet_sample});
}
```

--------------------------------

### Calculate Probability Functions: Zig

Source: https://context7.com/pblischak/zprob/llms.txt

Calculates Probability Mass Functions (PMF) for discrete distributions and Probability Density Functions (PDF) for continuous distributions. Supports log-scale calculations and requires the zprob library. Outputs probabilities or log-probabilities.

```zig
const std = @import("std");
const zprob = @import("zprob");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    defer _ = gpa.deinit();

    var env = try zprob.RandomEnvironment.init(allocator);
    defer env.deinit();

    // Binomial PMF: P(X = 8 | n=10, p=0.75)
    const binom_prob = try env.dBinomial(8, 10, 0.75, false);
    const binom_log_prob = try env.dBinomial(8, 10, 0.75, true);
    std.debug.print("P(X=8): {d:.6}\n", .{binom_prob});
    std.debug.print("log P(X=8): {d:.6}\n", .{binom_log_prob});

    // Normal PDF: probability density at x=10.0
    const normal_pdf = try env.dNormal(10.0, 8.0, 2.0, false);
    const normal_log_pdf = try env.dNormal(10.0, 8.0, 2.0, true);
    std.debug.print("Normal PDF at x=10.0: {d:.6}\n", .{normal_pdf});
    std.debug.print("Normal log PDF at x=10.0: {d:.6}\n", .{normal_log_pdf});

    // Beta PDF: probability density at x=0.3
    const beta_pdf = try env.dBeta(0.3, 2.0, 5.0, false);
    std.debug.print("Beta PDF at x=0.3: {d:.6}\n", .{beta_pdf});
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.