Struct InputBuilder 

pub struct InputBuilder<I: Input, D: Distribution> { /* private fields */ }

Struct used for building an InputSet.

Implementations

impl<I: Input, D: Distribution> InputBuilder<I, D>

pub fn new(distribution: D, builder: I::Builder) -> InputBuilder<I, D>

Creates a new InputBuilder.

Arguments

• distribution - The distribution that will be used to generate the input lengths.
• builder - The builder that will be used to generate the inputs.

Examples found in repository

examples/sorting/main.rs (line 23)

fn main() {
    // Create a distribution for the length of the vectors
    // Here we use an exponential distribution with a minimum of 1000 and a maximum of 500_000
    let length_distribution = Exponential::new(1000..=500_000);

    // Create the builder for the vectors
    let vector_builder = InputBuilder::new(length_distribution, ());

    // Build the vectors
    // Here we build 2000 vectors, 10 of each length
    let mut vectors = vector_builder.build_with_repetitions(200, 10);

    // Create a slice of the algorithms we want to measure
    let algorithms: &[(fn(&mut input::InputVec), &str); 2] = &[
        (merge_sort_input, "Merge sort"),
        (quick_sort_input, "Quick sort"),
    ];

    // Measure the algorithms on the vectors, given a relative error of 0.001
    let results = measure_mut(&mut vectors, algorithms, 0.001);

    let result_clone = results.clone();
    // Serialize the results to a json file
    result_clone.serialize_json("results.json");

    let file_name = "results/sorting.svg";

    // Plot the results
    let config = PlotConfig::default()
        .with_title("Sorting algorithms")
        .with_caption("The time plot of sorting algorithms");

    time_plot(file_name, results, &config);
}

examples/search/main.rs (line 26)

fn main() {
    // Create a distribution for the length of the vectors
    // Here we use an uniform distribution with a minimum of 10 and a maximum of 100_000
    let length_distribution = Uniform::new(10..=100_000);

    // Create the builder for the vectors
    // Here we choose to use the fast generator method in order to generate ordered vectors
    let vector_builder = InputBuilder::new(length_distribution, Generator::Fast);

    // Build 200 vectors
    let vectors = vector_builder.build(200);

    // Create a slice of the algorithms we want to measure
    let algorithms: &[(fn(&input::SearchInput) -> Option<usize>, &str); 2] = &[
        (linear_search_input, "Linear search"),
        (binary_search_input, "Binary search"),
    ];

    // Measure the algorithms on the vectors, given a relative error of 0.001
    let results = measure(&vectors, algorithms, 0.001);

    let file_name = "results/search.svg";

    // Here we print the linear regression of the log-log scale of the results
    for result in results.clone().measurements {
        let log_linear_regression = result.log_log_scale().linear_regression();
        println!(
            "{}: {} * x + {}",
            result.algorithm_name, log_linear_regression.0, log_linear_regression.1
        )
    }

    let config = PlotConfig::default()
        .with_title("Search in an ordered vector")
        .with_caption("The time plot of searching algorithms in an ordered vector");

    // Plot the results
    time_plot(file_name, results, &config);
}

pub fn build(&self, n: usize) -> InputSet<I>

Generates the inputs.

Arguments

• n - The number of inputs to be generated.

Examples found in repository

examples/search/main.rs (line 29)

fn main() {
    // Create a distribution for the length of the vectors
    // Here we use an uniform distribution with a minimum of 10 and a maximum of 100_000
    let length_distribution = Uniform::new(10..=100_000);

    // Create the builder for the vectors
    // Here we choose to use the fast generator method in order to generate ordered vectors
    let vector_builder = InputBuilder::new(length_distribution, Generator::Fast);

    // Build 200 vectors
    let vectors = vector_builder.build(200);

    // Create a slice of the algorithms we want to measure
    let algorithms: &[(fn(&input::SearchInput) -> Option<usize>, &str); 2] = &[
        (linear_search_input, "Linear search"),
        (binary_search_input, "Binary search"),
    ];

    // Measure the algorithms on the vectors, given a relative error of 0.001
    let results = measure(&vectors, algorithms, 0.001);

    let file_name = "results/search.svg";

    // Here we print the linear regression of the log-log scale of the results
    for result in results.clone().measurements {
        let log_linear_regression = result.log_log_scale().linear_regression();
        println!(
            "{}: {} * x + {}",
            result.algorithm_name, log_linear_regression.0, log_linear_regression.1
        )
    }

    let config = PlotConfig::default()
        .with_title("Search in an ordered vector")
        .with_caption("The time plot of searching algorithms in an ordered vector");

    // Plot the results
    time_plot(file_name, results, &config);
}

pub fn build_with_repetitions( &self, n: usize, repetitions: usize, ) -> InputSet<I>

Generates the inputs with repetitions (i.e. multiple inputs with the same size). This can be useful in order to obtain a more accurate result.

Arguments

• n - The number of inputs to be generated (excluding repetitions: the actual amount of inputs generated is n*repetitions).
• repetitions - The number of repetitions for each input size.

Examples found in repository

examples/sorting/main.rs (line 27)

fn main() {
    // Create a distribution for the length of the vectors
    // Here we use an exponential distribution with a minimum of 1000 and a maximum of 500_000
    let length_distribution = Exponential::new(1000..=500_000);

    // Create the builder for the vectors
    let vector_builder = InputBuilder::new(length_distribution, ());

    // Build the vectors
    // Here we build 2000 vectors, 10 of each length
    let mut vectors = vector_builder.build_with_repetitions(200, 10);

    // Create a slice of the algorithms we want to measure
    let algorithms: &[(fn(&mut input::InputVec), &str); 2] = &[
        (merge_sort_input, "Merge sort"),
        (quick_sort_input, "Quick sort"),
    ];

    // Measure the algorithms on the vectors, given a relative error of 0.001
    let results = measure_mut(&mut vectors, algorithms, 0.001);

    let result_clone = results.clone();
    // Serialize the results to a json file
    result_clone.serialize_json("results.json");

    let file_name = "results/sorting.svg";

    // Plot the results
    let config = PlotConfig::default()
        .with_title("Sorting algorithms")
        .with_caption("The time plot of sorting algorithms");

    time_plot(file_name, results, &config);
}

Trait Implementations

impl<I: Input, D> Serialize for InputBuilder<I, D>

where D: Serialize + Distribution, I::Builder: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.