Five-Number Summary and Box Plot

/**
 * Fintech Math Bootcamp · Lesson 040 of 120
 * Five-Number Summary and Box Plot
 * Module 04: Location, Ranking, and Exploratory Summaries
 *
 * Scenario: A box-plot fence is not an observed whisker
 * Rule:     fences = Q1 − 1.5 IQR, Q3 + 1.5 IQR
 *
 * Try it:   Is seven an observed upper whisker here?
 *
 * Lesson article: https://thefintechbuilder.com/financial-mathematics-statistics-and-data-foundations/location-ranking-and-exploratory-summaries/five-number-summary-and-box-plot/
 * Free course:    https://courses.thefintechbuilder.com
 * Synthetic teaching example, not financial advice or a production library.
 */

export function lesson040() {
  const x = [1,2,2,4,9].sort((a,b)=>a-b);
  const q = (p: number) => { const h=(x.length-1)*p, i=Math.floor(h);
    return x[i] + (h-i)*(x[Math.min(i+1,x.length-1)]-x[i]); };
  const q1 = q(.25), median = q(.5), q3 = q(.75);
  const iqr = q3-q1, lo=q1-1.5*iqr, hi=q3+1.5*iqr;
  const inside = x.filter(v=>v>=lo && v<=hi);
  const result = {five:[x[0],q1,median,q3,x[x.length-1]], fences:[lo,hi],
    whiskers:[Math.min(...inside),Math.max(...inside)], outliers:x.filter(v=>v<lo||v>hi)};
  return result;
}

export const checkedResult = {"five":[1,2,2,4,9],"fences":[-1,7],"whiskers":[1,4],"outliers":[9]};

// Run this file directly: npx tsx lessons/04-location-ranking-and-exploratory-summaries/040-five-number-summary-and-box-plot.ts
if (process.argv[1] && import.meta.url.endsWith(process.argv[1].replace(/\\/g, "/").split("/").pop()!)) {
  console.log(JSON.stringify(lesson040(), null, 2));
}

# Fintech Math Bootcamp · Lesson 040 of 120
# Five-Number Summary and Box Plot
# Module 04: Location, Ranking, and Exploratory Summaries
#
# Scenario: A box-plot fence is not an observed whisker
# Rule:     fences = Q1 − 1.5 IQR, Q3 + 1.5 IQR
#
# Try it:   Is seven an observed upper whisker here?
#
# Lesson article: https://thefintechbuilder.com/financial-mathematics-statistics-and-data-foundations/location-ranking-and-exploratory-summaries/five-number-summary-and-box-plot/
# Free course:    https://courses.thefintechbuilder.com
# Synthetic teaching example, not financial advice or a production library.

import json
import math


def lesson040() -> dict:
    x = sorted([1, 2, 2, 4, 9])

    def q(p: float) -> float:  # type-7 linear interpolation
        h = (len(x) - 1) * p
        i = math.floor(h)
        return x[i] + (h - i) * (x[min(i + 1, len(x) - 1)] - x[i])

    q1, median, q3 = q(0.25), q(0.5), q(0.75)
    iqr = q3 - q1
    lo, hi = q1 - 1.5 * iqr, q3 + 1.5 * iqr
    inside = [v for v in x if lo <= v <= hi]
    return {
        "five": [x[0], q1, median, q3, x[-1]],
        "fences": [lo, hi],
        "whiskers": [min(inside), max(inside)],
        "outliers": [v for v in x if v < lo or v > hi],
    }


if __name__ == "__main__":
    print(json.dumps(lesson040(), indent=2))

/**
 * Fintech Math Bootcamp · Lesson 040 of 120
 * Five-Number Summary and Box Plot
 * Module 04: Location, Ranking, and Exploratory Summaries
 *
 * Scenario: A box-plot fence is not an observed whisker
 * Rule:     fences = Q1 − 1.5 IQR, Q3 + 1.5 IQR
 *
 * Try it:   Is seven an observed upper whisker here?
 *
 * Lesson article: https://thefintechbuilder.com/financial-mathematics-statistics-and-data-foundations/location-ranking-and-exploratory-summaries/five-number-summary-and-box-plot/
 * Free course:    https://courses.thefintechbuilder.com
 * Synthetic teaching example, not financial advice or a production library.
 */

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public class Main {
    // Type-7 linear interpolation between adjacent order statistics; x must be sorted.
    static double quantile7(double[] x, double p) {
        double h = (x.length - 1) * p;
        int i = (int) Math.floor(h);
        return x[i] + (h - i) * (x[Math.min(i + 1, x.length - 1)] - x[i]);
    }

    static Map<String, Object> lesson040() {
        double[] x = {1, 2, 2, 4, 9};
        Arrays.sort(x);
        double q1 = quantile7(x, 0.25), median = quantile7(x, 0.5), q3 = quantile7(x, 0.75);
        double iqr = q3 - q1, lo = q1 - 1.5 * iqr, hi = q3 + 1.5 * iqr;
        List<Double> inside = new ArrayList<Double>();
        List<Double> outliers = new ArrayList<Double>();
        for (double v : x) {
            if (v >= lo && v <= hi) inside.add(v);
            else outliers.add(v);
        }
        Map<String, Object> result = new LinkedHashMap<String, Object>();
        result.put("five", new double[] {x[0], q1, median, q3, x[x.length - 1]});
        result.put("fences", new double[] {lo, hi});
        result.put("whiskers", new double[] {Collections.min(inside), Collections.max(inside)});
        result.put("outliers", outliers);
        return result;
    }

    public static void main(String[] args) {
        System.out.println(toJson(lesson040(), ""));
    }

    // --- Minimal JSON printer: maps keep insertion order, 2-space indent. ---

    static String toJson(Object value, String indent) {
        if (value == null) return "null";
        if (value instanceof String) return "\"" + value + "\"";
        if (value instanceof Double) return formatNumber((Double) value);
        if (value instanceof Number) return value.toString();
        if (value instanceof double[]) {
            List<Object> items = new ArrayList<Object>();
            for (double v : (double[]) value) items.add(v);
            return toJson(items, indent);
        }
        String inner = indent + "  ";
        StringBuilder sb = new StringBuilder();
        if (value instanceof Map) {
            Map<?, ?> map = (Map<?, ?>) value;
            if (map.isEmpty()) return "{}";
            sb.append("{\n");
            int i = 0;
            for (Map.Entry<?, ?> entry : map.entrySet()) {
                sb.append(inner).append('"').append(entry.getKey()).append("\": ")
                  .append(toJson(entry.getValue(), inner))
                  .append(++i < map.size() ? ",\n" : "\n");
            }
            return sb.append(indent).append('}').toString();
        }
        List<?> list = (List<?>) value;
        if (list.isEmpty()) return "[]";
        sb.append("[\n");
        for (int i = 0; i < list.size(); i++) {
            sb.append(inner).append(toJson(list.get(i), inner))
              .append(i + 1 < list.size() ? ",\n" : "\n");
        }
        return sb.append(indent).append(']').toString();
    }

    static String formatNumber(double v) {
        if (Double.isNaN(v) || Double.isInfinite(v)) return "null";
        if (v == Math.rint(v) && Math.abs(v) < 1e15) return Long.toString((long) v);
        return Double.toString(v);
    }
}

// Fintech Math Bootcamp · Lesson 040 of 120
// Five-Number Summary and Box Plot
// Module 04: Location, Ranking, and Exploratory Summaries
//
// Scenario: A box-plot fence is not an observed whisker
// Rule:     fences = Q1 − 1.5 IQR, Q3 + 1.5 IQR
//
// Try it:   Is seven an observed upper whisker here?
//
// Lesson article: https://thefintechbuilder.com/financial-mathematics-statistics-and-data-foundations/location-ranking-and-exploratory-summaries/five-number-summary-and-box-plot/
// Free course:    https://courses.thefintechbuilder.com
// Synthetic teaching example, not financial advice or a production library.

package main

import (
	"encoding/json"
	"fmt"
	"math"
	"slices"
	"sort"
)

// BoxPlot separates the fences (rules) from the whiskers (observed values).
type BoxPlot struct {
	Five     []float64 `json:"five"`
	Fences   []float64 `json:"fences"`
	Whiskers []float64 `json:"whiskers"`
	Outliers []float64 `json:"outliers"`
}

// quantile7 interpolates linearly between adjacent order statistics (type 7).
func quantile7(x []float64, p float64) float64 {
	h := float64(len(x)-1) * p
	i := int(math.Floor(h))
	return x[i] + (h-float64(i))*(x[min(i+1, len(x)-1)]-x[i])
}

func lesson040() BoxPlot {
	x := []float64{1, 2, 2, 4, 9}
	sort.Float64s(x)
	q1, median, q3 := quantile7(x, 0.25), quantile7(x, 0.5), quantile7(x, 0.75)
	iqr := q3 - q1
	lo, hi := q1-1.5*iqr, q3+1.5*iqr
	inside, outliers := []float64{}, []float64{}
	for _, v := range x {
		if v >= lo && v <= hi {
			inside = append(inside, v)
		} else {
			outliers = append(outliers, v)
		}
	}
	return BoxPlot{
		Five:     []float64{x[0], q1, median, q3, x[len(x)-1]},
		Fences:   []float64{lo, hi},
		Whiskers: []float64{slices.Min(inside), slices.Max(inside)},
		Outliers: outliers,
	}
}

func main() {
	out, _ := json.MarshalIndent(lesson040(), "", "  ")
	fmt.Println(string(out))
}

/**
 * Fintech Math Bootcamp · Lesson 040 of 120
 * Five-Number Summary and Box Plot
 * Module 04: Location, Ranking, and Exploratory Summaries
 *
 * Scenario: A box-plot fence is not an observed whisker
 * Rule:     fences = Q1 − 1.5 IQR, Q3 + 1.5 IQR
 *
 * Try it:   Is seven an observed upper whisker here?
 *
 * Lesson article: https://thefintechbuilder.com/financial-mathematics-statistics-and-data-foundations/location-ranking-and-exploratory-summaries/five-number-summary-and-box-plot/
 * Free course:    https://courses.thefintechbuilder.com
 * Synthetic teaching example, not financial advice or a production library.
 */

#include <algorithm>
#include <charconv>
#include <cmath>
#include <iostream>
#include <string>
#include <utility>
#include <vector>

// --- Minimal JSON value and printer: objects keep insertion order, 2-space indent. ---

struct Json {
    enum class Kind { Null, Number, Text, Array, Object };
    Kind kind = Kind::Null;
    double number = 0;
    std::string text;
    std::vector<std::string> keys;  // object keys, parallel to items
    std::vector<Json> items;        // array elements or object values
};

Json num(double v) { Json j; j.kind = Json::Kind::Number; j.number = v; return j; }
Json str(const std::string& s) { Json j; j.kind = Json::Kind::Text; j.text = s; return j; }
Json arr(const std::vector<Json>& values) { Json j; j.kind = Json::Kind::Array; j.items = values; return j; }

Json arr(const std::vector<double>& values) {
    std::vector<Json> items;
    for (double v : values) items.push_back(num(v));
    return arr(items);
}

Json obj(const std::vector<std::pair<std::string, Json>>& fields) {
    Json j;
    j.kind = Json::Kind::Object;
    for (const auto& [key, value] : fields) { j.keys.push_back(key); j.items.push_back(value); }
    return j;
}

std::string formatNumber(double v) {
    if (!std::isfinite(v)) return "null";
    char buf[64];
    auto end = std::to_chars(buf, buf + sizeof buf, v).ptr;  // shortest round-trip form
    return std::string(buf, end);
}

void writeJson(std::ostream& out, const Json& j, const std::string& indent) {
    switch (j.kind) {
    case Json::Kind::Null: out << "null"; return;
    case Json::Kind::Number: out << formatNumber(j.number); return;
    case Json::Kind::Text: out << '"' << j.text << '"'; return;
    default: break;
    }
    bool isObject = j.kind == Json::Kind::Object;
    if (j.items.empty()) { out << (isObject ? "{}" : "[]"); return; }
    std::string inner = indent + "  ";
    out << (isObject ? "{\n" : "[\n");
    for (size_t i = 0; i < j.items.size(); ++i) {
        out << inner;
        if (isObject) out << '"' << j.keys[i] << "\": ";
        writeJson(out, j.items[i], inner);
        out << (i + 1 < j.items.size() ? ",\n" : "\n");
    }
    out << indent << (isObject ? '}' : ']');
}

// --- Lesson ---

// Type-7 linear interpolation between adjacent order statistics; x must be sorted.
double quantile7(const std::vector<double>& x, double p) {
    double h = (x.size() - 1) * p;
    size_t i = static_cast<size_t>(std::floor(h));
    return x[i] + (h - i) * (x[std::min(i + 1, x.size() - 1)] - x[i]);
}

Json lesson040() {
    std::vector<double> x = {1, 2, 2, 4, 9};
    std::sort(x.begin(), x.end());
    double q1 = quantile7(x, 0.25), median = quantile7(x, 0.5), q3 = quantile7(x, 0.75);
    double iqr = q3 - q1, lo = q1 - 1.5 * iqr, hi = q3 + 1.5 * iqr;
    std::vector<double> inside, outliers;
    for (double v : x) {
        if (v >= lo && v <= hi) inside.push_back(v);
        else outliers.push_back(v);
    }
    auto [minInside, maxInside] = std::minmax_element(inside.begin(), inside.end());
    return obj({
        {"five", arr(std::vector<double>{x.front(), q1, median, q3, x.back()})},
        {"fences", arr(std::vector<double>{lo, hi})},
        {"whiskers", arr(std::vector<double>{*minInside, *maxInside})},
        {"outliers", arr(outliers)},
    });
}

int main() {
    writeJson(std::cout, lesson040(), "");
    std::cout << '\n';
}

// Fintech Math Bootcamp · Lesson 040 of 120
// Five-Number Summary and Box Plot
// Module 04: Location, Ranking, and Exploratory Summaries
//
// Scenario: A box-plot fence is not an observed whisker
// Rule:     fences = Q1 − 1.5 IQR, Q3 + 1.5 IQR
//
// Try it:   Is seven an observed upper whisker here?
//
// Lesson article: https://thefintechbuilder.com/financial-mathematics-statistics-and-data-foundations/location-ranking-and-exploratory-summaries/five-number-summary-and-box-plot/
// Free course:    https://courses.thefintechbuilder.com
// Synthetic teaching example, not financial advice or a production library.

// --- Minimal JSON value and printer: objects keep insertion order, 2-space indent. ---

#[allow(dead_code)]
enum Json {
    Null,
    Num(f64),
    Str(String),
    Arr(Vec<Json>),
    Obj(Vec<(String, Json)>),
}

#[allow(dead_code)]
fn nums(values: &[f64]) -> Json {
    Json::Arr(values.iter().map(|&v| Json::Num(v)).collect())
}

#[allow(dead_code)]
fn obj(fields: Vec<(&str, Json)>) -> Json {
    Json::Obj(fields.into_iter().map(|(k, v)| (k.to_string(), v)).collect())
}

fn format_number(v: f64) -> String {
    if !v.is_finite() {
        return "null".to_string();
    }
    if v.fract() == 0.0 && v.abs() < 1e15 {
        return format!("{}", v as i64);
    }
    format!("{:?}", v) // shortest round-trip form
}

impl Json {
    fn render(&self, indent: &str) -> String {
        let inner = format!("{}  ", indent);
        match self {
            Json::Null => "null".to_string(),
            Json::Num(v) => format_number(*v),
            Json::Str(s) => format!("\"{}\"", s),
            Json::Arr(items) if items.is_empty() => "[]".to_string(),
            Json::Obj(fields) if fields.is_empty() => "{}".to_string(),
            Json::Arr(items) => {
                let lines: Vec<String> = items.iter().map(|v| format!("{}{}", inner, v.render(&inner))).collect();
                format!("[\n{}\n{}]", lines.join(",\n"), indent)
            }
            Json::Obj(fields) => {
                let lines: Vec<String> = fields
                    .iter()
                    .map(|(k, v)| format!("{}\"{}\": {}", inner, k, v.render(&inner)))
                    .collect();
                format!("{{\n{}\n{}}}", lines.join(",\n"), indent)
            }
        }
    }
}

// --- Lesson ---

/// Type-7 linear interpolation between adjacent order statistics; `x` must be sorted.
fn quantile7(x: &[f64], p: f64) -> f64 {
    let h = (x.len() - 1) as f64 * p;
    let i = h.floor() as usize;
    x[i] + (h - i as f64) * (x[(i + 1).min(x.len() - 1)] - x[i])
}

fn lesson040() -> Json {
    let mut x: Vec<f64> = vec![1.0, 2.0, 2.0, 4.0, 9.0];
    x.sort_by(|a, b| a.partial_cmp(b).unwrap());
    let (q1, median, q3) = (quantile7(&x, 0.25), quantile7(&x, 0.5), quantile7(&x, 0.75));
    let iqr = q3 - q1;
    let (lo, hi) = (q1 - 1.5 * iqr, q3 + 1.5 * iqr);
    let (inside, outliers): (Vec<f64>, Vec<f64>) = x.iter().partition(|&&v| v >= lo && v <= hi);
    let min_inside = inside.iter().cloned().fold(f64::INFINITY, f64::min);
    let max_inside = inside.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
    obj(vec![
        ("five", nums(&[x[0], q1, median, q3, x[x.len() - 1]])),
        ("fences", nums(&[lo, hi])),
        ("whiskers", nums(&[min_inside, max_inside])),
        ("outliers", nums(&outliers)),
    ])
}

fn main() {
    println!("{}", lesson040().render(""));
}

/**
 * Fintech Math Bootcamp · Lesson 040 of 120
 * Five-Number Summary and Box Plot
 * Module 04: Location, Ranking, and Exploratory Summaries
 *
 * Scenario: A box-plot fence is not an observed whisker
 * Rule:     fences = Q1 − 1.5 IQR, Q3 + 1.5 IQR
 *
 * Try it:   Is seven an observed upper whisker here?
 *
 * Lesson article: https://thefintechbuilder.com/financial-mathematics-statistics-and-data-foundations/location-ranking-and-exploratory-summaries/five-number-summary-and-box-plot/
 * Free course:    https://courses.thefintechbuilder.com
 * Synthetic teaching example, not financial advice or a production library.
 */

using System;
using System.Linq;
using System.Text.Json;

var options = new JsonSerializerOptions { WriteIndented = true };
Console.WriteLine(JsonSerializer.Serialize(Lesson040(), options));

static object Lesson040()
{
    double[] x = new double[] { 1, 2, 2, 4, 9 }.OrderBy(v => v).ToArray();

    // Type-7 linear interpolation between adjacent order statistics.
    double Q(double p)
    {
        double h = (x.Length - 1) * p;
        int i = (int)Math.Floor(h);
        return x[i] + (h - i) * (x[Math.Min(i + 1, x.Length - 1)] - x[i]);
    }

    double q1 = Q(0.25), median = Q(0.5), q3 = Q(0.75);
    double iqr = q3 - q1, lo = q1 - 1.5 * iqr, hi = q3 + 1.5 * iqr;
    double[] inside = x.Where(v => v >= lo && v <= hi).ToArray();
    return new
    {
        five = new[] { x[0], q1, median, q3, x[^1] },
        fences = new[] { lo, hi },
        whiskers = new[] { inside.Min(), inside.Max() },
        outliers = x.Where(v => v < lo || v > hi).ToArray(),
    };
}