[RFC]: Implement a broader range of statistical distributions

[manit2004]

Full name

Manit Roy

University status

Yes

University name

International Institute of Information Technology, Hyderabad (IIIT-H)

University program

Integrated Dual Degree with Bachelors in Computer Science & Masters in Computational Natural Sciences

Expected graduation

2028

Short biography

I am a third-year Computer Science undergraduate at IIIT Hyderabad with a strong foundation in systems and software development. I have experience with C/C++, Python, JavaScript, and Assembly, working across DSA, operating systems, AI, and full-stack development, along with cloud deployment using AWS.

My primary interest lies in Artificial Intelligence and Machine Learning. I have built end-to-end AI systems across research, hackathons, and industry, with a focus on understanding the mathematical foundations behind models. I am currently working on AI applications for STM imaging.

I also enjoy working with hardware and robotics. As the Coordinator of the Electronics and Robotics Club (ERC) at IIIT Hyderabad, I lead projects and build robots like maze-solving and line-following bots.

Timezone

India Standard Time (GMT+5:30)

Contact details

roymanit2004@gmail.com, manit.roy@research.iiit.ac.in

Platform

Linux

Editor

VScode. Reason being I started my coding journey with VsCode and never really felt the need to switch to other IDE. It gets the job done and runs smoothly. Besides that, I really like how extensive VsCode extension marketplace is, which helps me to customize my development environment further and add any necessary tool if required.

Programming experience

I started coding in school, building basic applications using Microsoft Visual Basic, and later formally began with C and C++ in college. Over time, I expanded to Python and JavaScript, using Node.js for web apps and React Native for mobile development, while also being well versed in C. My primary interest now lies in AI, particularly Generative AI and Deep Learning, where I have worked extensively with libraries like PyTorch, Scikit-learn, and LangChain.

Projects:

• Laptop Finder: Built an Agentic RAG chatbot with LangChain to recommend gadgets based on user requirements and budget.Integrated real-time price tracking via Google Search Agent. Developed a Streamlit UI for seamless interaction.
• E-Commerce Buy-Sell-Rent Web App: Built a full-stack marketplace for buying, selling, and renting with JWT and CAS authentication. Developed a React.js frontend with Bootstrap and a Node.js + MongoDB backend for efficient data handling. Integrated an AI-powered chatbot using OpenAI API to enhance customer support and user experience.
• C Shell: cshell is a modular C shell with separate parser, executor, jobs, logging, and signal modules. It supports pipelines, redirection, background jobs, and built-in commands. Built with make, with clean project structure across src, include, obj, and bin.
• Automotive Insurance Fraud Detection System: Developed a 5-stage AI pipeline for detecting fraudulent insurance claims, integrating image authenticity, tampering, semantic, and duplicate checks, securing 1st place at a hackathon organized by Chubb. Enabled automated damage assessment, cost estimation, and real-time fraud scoring via a web interface.
• Captcha Solver:Built an OCR-based CAPTCHA solver using CRNN with CTC loss, trained on synthetic data for high accuracy. Achieved 96.08% character accuracy on easy CAPTCHAs and 92.84% on hard CAPTCHAs after 30 epochs.
• Wildfire Alert System: Developed a real-time wildfire risk prediction app using satellite imagery, achieving 96% accuracy. Integrated Mapbox for satellite imagery, deep learning for risk detection, and automated alerts for high-risk zones. This was developed during a hackathon, Megathon'24 where our team secured 2nd position.

Work Experience

Beside these projects I have also worked in Montycloud last summer as a AI Intern where I built an AI agentic system to automate writing AWS compliance checks and corresponding tests, CFN templates. Used unit tests to validate generated code and CFN templates to ensure checks handled all edge cases. Also I worked in a project at a company called Hopelog with my friends where we developed a cross-platform mobile app for parenting, built using the MERN stack with React Native. It was an AI audio journaling app for parents, providing personalized guidance to navigate parenting challenges.

JavaScript experience

I started with vanilla JavaScript for frontend development, building web apps using HTML, CSS, and JavaScript with a Python Flask backend. Over time, I expanded to using JavaScript on the backend as well. I have primarily worked with the MERN stack to build full-stack web applications and have also developed mobile applications using React Native.

What I like most about JavaScript is its versatility. It can be used across web, mobile, and even desktop applications through frameworks like Electron, which makes it a powerful end-to-end language. My favorite feature is its support for asynchronous programming, especially with promises and async/await, which makes handling I/O and concurrent operations much more manageable.

My least favorite aspect is the lack of strong type safety, which can lead to unintended type coercion and runtime errors. Floating-point precision issues are another limitation that can sometimes cause subtle bugs.

Node.js experience

I have used Node.js to build backend systems for both web and mobile applications. I have designed and implemented RESTful APIs to handle core application logic, including user authentication, data retrieval, and updates.

I have experience working with authentication mechanisms such as JWT-based systems and managing secure user sessions. I am also comfortable with the Node.js ecosystem, including package management using npm and structuring scalable backend services.

C/Fortran experience

I started programming with C, using it extensively for competitive programming and in my Data Structures and Algorithms coursework. I also used C in my Operating Systems and Networks courses to build systems like a custom shell, a network traffic analyzer, and a distributed document collaboration system. Through this, I gained a strong understanding of low-level programming concepts such as memory management, pointers, and manual resource handling. I also worked with system-level features like process creation, inter-process communication, socket programming, and file I/O, along with debugging tools to analyze and optimize performance.

I do not have prior experience with Fortran, but I am a quick learner. Given my background in low-level languages like C and Assembly, I am confident that I will be able to pick it up quickly and work with it effectively.

Interest in stdlib

I really like the idea of bringing mathematical computation to the web. Earlier, I would rely on Python, R, or MATLAB for serious work, but that involved either a learning curve or setup overhead. With JavaScript, that friction disappears since it is a language I already know and it runs directly in the browser, which is the most accessible platform today.

What excites me about stdlib.js is that it enables serious math in this environment. Its extreme modularity stands out. Instead of importing an entire library, you can use something as granular as a single distribution or even a specific function. This fits naturally with modern web development.

I am also interested in this from an educational perspective. I used to run a YouTube channel for teaching math, and with JavaScript I can create interactive, instantly shareable demos that run in the browser. Instead of just explaining concepts, I can let people experiment with them directly through a simple link.

For me, the most exciting part is making math more accessible, interactive, and shareable through the web.

Version control

Yes

Contributions to stdlib

I started contributing to stdlib with good first issues which helped me to be familiar with the repo. Shortly after I found some old issues related to math and stats which were still open. I picked up #209 and started implementing Inverse Gaussian (Wald) Distribution libraries. Here's a list a of merged and open PRs:

Wald PDF: #9324
Wald Mean: #9502
Wald Variance: #9730
Wald Mode: #10205

Issues Created:
Duplicate test cases in Normal Mean and Variance Package: #9824, #9567

Besides I have also made contributions to matplotlib #30780 and pyaadhaar #25.

stdlib showcase

I have used stdlib to build this CLT Simulator (CLT: Central Limit Theorem) as a part of stdlib showcase. This simulator helps you visualize that with repeated iterations, sample average of any distribution gets close to a normal distribution -- Central Limit Theorem, one of the most fundamental theorems in statistics. Here's the codebase for the simulator mentioned above. I used stdlib to draw population samples with @stdlib/random-base-* modules and plotting the expected normal overlay with @stdlib/stats-base-dists-normal-pdf.

Goals

My goal is to extend the number of statistical distributions currently available in stdlib. I have prepared a sheet that lists all missing distributions, their implementation status, and any blocking dependencies. For this project, I want to focus only on distributions that are present in both SciPy and Julia and can be implemented without any missing dependencies.

I have selected Multinomial, Dirichlet, and Beta-Binomial distributions because their relevance is driven directly by their heavy utilization across modern machine learning, natural language processing, and systems biology.

• Multinomial (Natural Language Processing & ML): This is the core mathematical engine for multi-class classification and count data. In NLP, developers specifically rely on the Multinomial to handle foundational tasks like building POS taggers or training word vectors, where data must be categorized into multiple discrete groups.

• Dirichlet (Statistical Learning & Generative Models): In machine learning, you cannot fully leverage the Multinomial without its Bayesian counterpart. The Dirichlet is the standard for modeling the uncertainty of those categorical probabilities, providing the necessary infrastructure for generative algorithms and topic modeling architectures.

• Beta-Binomial (Systems Biology & Practical Analytics): Standard binomial distributions assume perfect independence, which frequently fails in applied research. In fields like systems biology or practical data analytics, data is noisy and correlated. The Beta-Binomial is the go-to upgrade because it seamlessly handles the extra variance (overdispersion) found in messy datasets, such as fluctuating biological models or clustered A/B testing.

Why this project?

Math has always been something I enjoy, and I have long been curious about how textbook formulas get translated into numerically stable, accurate code in math libraries. It is one thing to derive a closed-form expression for a PDF on paper and another to implement it in a way that handles edge cases, avoids catastrophic cancellation, and performs well across a wide range of inputs. Statistics specifically drew my interest through the Machine Learning courses I took, where it formed a core part of the foundations.
I began contributing to stdlib by implementing the Wald Distribution, and later came across this GSoC Idea. Since it aligned directly with the work I was already doing, choosing this project was an easy decision.

Qualifications

In my 2nd year of college, I completed a course on Probability and Random Processes, which covered random variables, probability theory, and statistical distributions along with their properties. In my 3rd year, I took Statistical Methods in Machine Learning, which focused on how statistics is applied in various ML algorithms.
On the technical side, I am comfortable with JavaScript and have worked with stdlib's codebase enough to understand its conventions around module structure.
My work implementing the Wald Distribution in stdlib gave me hands-on experience with the full contribution process, including writing the implementation and tests to documentation and addressing review feedback. Together, these give me a strong foundation for executing on this proposal.

Prior art

All 3 distributions I am targeting are already implemented in both SciPy and Julia:

• Beta Binomial: SciPy, Julia, Wiki
• Dirichlet: SciPy, Julia, Wiki
• Multinomial: SciPy, Julia, Wiki

I plan to use these reference implementations as guides when writing my code, adapting their approaches to fit stdlib's conventions and JavaScript's numerical constraints where necessary.

Commitment

I am taking this as a large project (350 hours), which over 12 weeks works out to roughly 30 hours per week. I have no other commitments during the summer and do not plan to take any time away. My college summer vacation runs from the second week of May through July 31st. In August, the remaining work will primarily involve addressing feedback from PR reviews which is comparatively lighter in workload. The first month of college is also typically less demanding, so I expect to remain on schedule through August as well.

Schedule

Assuming a 12 week schedule, a detailed day-wise timeline with a Gantt chart is available in this sheet. Following assumptions have been taken into account while making this timeline.

• Reviews happen in 3-day cycles, with coding continuing in parallel 6 days a week.
• Larger libraries (PMF/PDF/CDF/ctor) take 3 days; others take 2 days.
• Each library is a single PR, going through 2 rounds of review before being merged.
• Changes requested on the second review are implemented and merged the same day.

• Community Bonding Period: Get more familiar with the repository under mentor guidance to improve workflow efficiency. If Wald distribution is not yet merged, I will work on finishing it, which will also serve as a practical run-through of the full contribution process. I will research the 3 target distributions and study their closed-form properties (PDF, CDF, etc.), with a focus on identifying numerically stable formulations. I will also review existing implementations in SciPy, Julia, and R so that by the time coding starts, I have a concrete implementation plan for each distribution along with an understanding of edge cases and numerical pitfalls to watch out for.

• Week 1 (May 25 - May 31):

  • Coding: Implement BetaBinomial PMF (PR # 1) and CDF (PR # 2).
  • Reviews: Initiate 1st review for BetaBinomial PMF.

• Week 2 (Jun 01 - Jun 07):

  • Coding: Implement BetaBinomial Mean (PR # 3), Variance (PR # 4), and Skewness (PR # 5).
  • Reviews/Merges: Address 1st reviews for CDF and Mean; 2nd review and merge for PMF and CDF.

• Week 3 (Jun 08 - Jun 14):

  • Coding: Implement BetaBinomial Excess Kurtosis (PR # 6), MGF (PR # 7), and constructor (PR # 8).
  • Reviews/Merges: Address reviews for Variance and Skewness; 2nd review and merge for Mean and Variance.

• Week 4 (Jun 15 - Jun 21):

  • Coding: Write BetaBinomial docs, examples, and tests (PR # 9). Start Dirichlet: Implement PDF (PR # 10).
  • Reviews/Merges: Address reviews for Excess Kurtosis and MGF; 2nd review and merge for Skewness and Excess Kurtosis.

• Week 5 (Jun 22 - Jun 28):

  • Coding: Implement Dirichlet Mean (PR # 11), Mode (PR # 12), and Variance (PR # 13).
  • Reviews/Merges: Address reviews for BetaBinomial constructor and docs; merge MGF and constructor PRs.

• Week 6 (Midterm) (Jun 29 - Jul 05):

  • Coding: Implement Dirichlet Entropy (PR # 14) and constructor (PR # 15).
  • Reviews/Merges: Finalize and merge BetaBinomial docs/examples. Address 1st reviews and merge early Dirichlet PRs (PDF, Mean).
  • Milestone: Complete Midterm Evaluations.

• Week 7 (Jul 06 - Jul 12):

  • Coding: Write Dirichlet docs, examples, and tests (PR # 16). Start Multinomial: Implement PMF (PR # 17) and Mean (PR # 18).
  • Reviews/Merges: Address 1st reviews for Dirichlet Mode and Variance; merge Mode.

• Week 8 (Jul 13 - Jul 19):

  • Coding: Implement Multinomial Variance (PR # 19), Entropy (PR # 20), and MGF (PR # 21).
  • Reviews/Merges: Address reviews and merge Dirichlet Variance, Entropy, and constructor PRs.

• Week 9 (Jul 20 - Jul 26):

  • Coding: Implement Multinomial constructor (PR # 22) and docs/examples/tests (PR # 23).
  • Reviews/Merges: Finalize and merge Dirichlet docs/examples. Initiate 1st review for Multinomial PMF.

• Week 10 (Jul 27 - Aug 02):

  • Reviews/Merges: Focus on Multinomial PRs. Address 1st reviews for Mean and Variance; complete 2nd review and merge for PMF and Mean.

• Week 11 (Aug 03 - Aug 09):

  • Reviews/Merges: Continue Multinomial pipeline. Address 1st reviews for Entropy and MGF; complete 2nd review and merge for Variance and Entropy.

• Week 12 (Aug 10 - Aug 16):

  • Reviews/Merges: Finalize Multinomial base functions. Address 1st reviews for constructor and docs/examples; complete 2nd review and merge for MGF and constructor PRs.

• Final Week (Aug 17 onwards):

  • Reviews/Merges: Complete 2nd review and merge for Multinomial docs, examples, and tests (PR # 23).
  • Milestone: Codebase cleanup, final checks, and submission of Final Evaluations.

Related issues

GSoC Idea
Open Issues related to missing distributions

Checklist

• I have read and understood the Code of Conduct.
• I have read and understood the application materials found in this repository.
• I understand that plagiarism will not be tolerated, and I have authored this application in my own words.
• I have read and understood the patch requirement which is necessary for my application to be considered for acceptance.
• I have read and understood the stdlib showcase requirement which is necessary for my application to be considered for acceptance.
• The issue name begins with [RFC]: and succinctly describes your proposal.
• I understand that, in order to apply to be a GSoC contributor, I must submit my final application to https://summerofcode.withgoogle.com/ before the submission deadline.

[Planeshifter]

Thank you for this proposal, @manit2004. It has a well scoped focus and is very detailed, and your CLT Simulator showcase is nice. Your schedule and decision to front load the Beta-Binomial distribution are sensible since is the most straightforward of the three since it is univariate and fits naturally into the existing package structure.

Main questions from my end:

1. The most important question: Multinomial and Dirichlet are multivariate distributions, while stdlib's current distribution infrastructure (stats/base/dists/*) is designed around univariate distributions. Each univariate distribution has separate sub-packages (pdf, cdf, mean, variance, etc.) that take and return scalar values. For multivariate distributions, the PMF/PDF takes a vector input, the mean returns a vector, and the covariance is a matrix. What design do you envision here?
2. You state that you want to "focus only on distributions that can be implemented without any missing dependencies." However, in a previous year's proposal for the Multinomial distribution ([RFC]: implementing the multinomial distribution in stdlib #126), @kgryte flagged that SciPy's implementation depends on einsum (which stdlib doesn't have) and relies on vectorized ndarray operations.

[manit2004]

@Planeshifter Thanks for the detailed feedback, really appreciate it. Glad to hear that you liked the CLT simulator showcase.

1. Yes, stdlib's current distribution layer is univariate-first, but we can extend it to multivariate without changing the overall package philosophy.

• Add a sibling multivariate namespace and start with Multinomial and Dirichlet.
• Keep the same package shape per distribution (pmf/pdf, logpmf/logpdf, mean, variance, covariance, entropy, ctor).
• Define explicit runtime shapes:
  • pmf/pdf/logpmf/logpdf/entropy → scalar number
  • mean and variance → length-k Float64Array
  • covariance → k×k ndarray
• Define explicit data contracts:
  • vector inputs accept ArrayLike, normalized internally
  • k is inferred from parameters in function form, and fixed/stored in constructor form
  • outputs are newly allocated by default, no shared mutable buffers in public APIs

2. To clarify the einsum concern raised in #126, the Multinomial covariance [source] can be implemented without einsum entirely. SciPy uses it once for the outer-product term, but both alternatives below replace it fully.

---

Python (broadcasting, batched):

def multinomial_cov_no_einsum_broadcast(n, p):
    # n: shape (...,), p: shape (..., k)
    nn = n[..., np.newaxis, np.newaxis]            # (..., 1, 1)
    result = nn * (-p[..., :, np.newaxis] * p[..., np.newaxis, :])  # (..., k, k)
    for i in range(p.shape[-1]):
        result[..., i, i] += n * p[..., i]
    return result

JS stdlib equivalent (broadcasting version):

function multinomialCovNoEinsumBroadcast(n, p) {
  var B = p.shape[0];
  var K = p.shape[1];
  var out = zeros([B, K, K], { dtype: 'float64' });
  var b, i, j, nb, pb_i, pb_j;
  for (b = 0; b < B; b++) {
    nb = n.get(b);
    for (i = 0; i < K; i++) {
      pb_i = p.get(b, i);
      for (j = 0; j < K; j++) {
        pb_j = p.get(b, j);
        out.set(b, i, j, -nb * pb_i * pb_j);
      }
      out.set(b, i, i, out.get(b, i, i) + nb * pb_i); // diagonal correction
    }
  }
  return out;
}

---

Python (outer product, 1D):

def multinomial_cov_no_einsum_outer(n, p):
    # n: scalar, p: shape (k,)
    result = n * np.outer(-p, p)
    for i in range(p.shape[-1]):
        result[i, i] += n * p[i]
    return result

JS stdlib equivalent (outer product version):

function multinomialCovNoEinsumOuter(n, p) {
  var K = p.shape[0];
  var out = zeros([K, K], { dtype: 'float64' });
  var i, j, pi, pj;
  for (i = 0; i < K; i++) {
    pi = p.get(i);
    for (j = 0; j < K; j++) {
      pj = p.get(j);
      out.set(i, j, -n * pi * pj);
    }
    out.set(i, i, out.get(i, i) + n * pi); // diagonal correction
  }
  return out;
}

---

Happy to elaborate further on either point if needed.

[kgryte]

As long as there is a workaround and no specialized need for einsum, that is reasonable.