[RFC]: add optimization and root-finding methods

[sagar7162]

Full name

Sagar Ratna Chaudhary

University status

Yes

University name

Indian Institute of Technology Jodhpur

University program

Artificial Intelligence and Data Science

Expected graduation

2027

Short biography

I am currently an undergraduate student at IIT Jodhpur, pursuing a Bachelor's in Technology in Artificial Intelligence and Data Science. I am particularly interested in algorithms and the mathematical foundations behind them, and I've been spending time exploring these areas both through coursework and on my own.

I primarily work with C/C++ and JavaScript, and I'm comfortable writing efficient, well-structured code with attention to performance. My coursework has covered core areas like data structures, algorithms, mathematics, and ML/DL, which has pushed me to think more about how theoretical ideas translate into real implementations.

In general, I enjoy solving algorithmic problems, understanding how things work under the hood, and building projects to explore new concepts.

Timezone

Indian Standard Time (UTC +5:30)

Contact details

email: sagarratna2005@gmail.com, github: sagar7162

Platform

Linux

Editor

I primarily use VS Code as my code editor because of its lightweight and open source nature. It also has a large number of useful extensions that can be installed to make everyday tasks easier.

Programming experience

My programming experience comes from a mix of coursework and building projects across different areas like machine learning, web development, and algorithms. Some of the projects I have worked on include:

Market Sentiment Analysis: Built a system to predict stock prices by combining NLP with time-series models.

Travel Planner: Developed a full-stack application using React, Node.js, and MongoDB with features like JWT-based authentication, REST APIs, and real-time chat using Socket.IO.

RouteVis (Network Visualization Tool): Created an interactive tool to simulate routing algorithms on graphs, allowing users to build networks and visualize algorithm behavior through animations.

JavaScript experience

I have used JavaScript for both frontend and backend development, mainly working with React and Node.js. Through my projects, I've gained experience in structuring code, working with APIs, and handling asynchronous workflows. I became more familiar with the language and its best practices through my exposure to stdlib.

One of JavaScript’s biggest strengths is its asynchronous nature. It makes it much easier to handle I/O-heavy tasks like API calls or real-time features without blocking execution.

One of the things that I don't like about JavaScript is its weak typing, meaning variables can change types unexpectedly. This often leads to "silent" bugs that produce bizarre results.

Node.js experience

I have used Node.js mainly while building backend services for my projects. I worked with libraries like Express and Mongoose to create REST APIs, handle routing, and manage server-side logic. I have also worked with features like authentication and real-time communication, which helped me understand how Node.js is used in practical applications.

C/Fortran experience

I have experience with C mainly through data structures and algorithms course in my college. I have used it extensively for implementing core data structures and solving algorithmic problems, which helped me get comfortable with pointers, memory management, and writing efficient code.

I have not worked with Fortran yet, but I am open to learning it as per the requirement.

Interest in stdlib

What interests me about stdlib is the idea of doing complex mathematical computations and algorithms directly in JavaScript, especially in the browser. Since JavaScript runs natively in the browser, these workflows are much easier to use across platforms without requiring additional setup or dependencies. Another aspect I like is the potential impact on workflows and data privacy. Running computations in the browser means data can often stay on the client side instead of being sent to external servers, which can be useful in scenarios involving sensitive data.

While exploring stdlib, I also found the codebase quite approachable. The modular structure and consistent style make it easier to understand how things are implemented. I also found the community to be active and helpful—doubts can be discussed directly, which makes it a good environment for someone like me who is relatively new to open source.

Version control

Yes

Contributions to stdlib

Merged PRs : Click Here
Open PRs : Click Here

stdlib showcase

WIP

Goals

The goal of this project is to implement a comprehensive set of numerical optimization and root-finding routines in @stdlib/optimize, including scalar root-finding methods (bisection, Brent, Ridder, Newton-type methods), multidimensional nonlinear solvers (hybr, Levenberg-Marquardt, Broyden variants, Anderson, Krylov), and elementwise optimization utilities such as find_root, find_minimum, and their corresponding bracketing methods. These implementations will be designed to be consistent with existing stdlib APIs, supporting configurable tolerances, convergence criteria, and standardized result objects.

Each routine will follow stdlib package conventions and include comprehensive tests, benchmarks, documentation, and examples, along with ndarray and strided variants where applicable. By the end of the project, @stdlib/optimize will provide a complete and extensible optimization module comparable in scope to scipy.optimize, significantly expanding stdlib's capabilities for numerical computing.

Why this project?

I’ve always been interested in how optimization algorithms actually work under the hood, especially since they appear everywhere in machine learning and numerical computing. Optimization and root-finding form the backbone of many areas in machine learning, deep learning, and scientific computing, where problems are often reduced to minimizing functions or solving nonlinear equations. Working on these algorithms gives me the opportunity to deeply understand how these methods behave in practice, beyond just using them as black-box tools.

I am particularly excited about implementing these methods from scratch in JavaScript and making them part of stdlib, as it allows me to contribute something both fundamental and widely useful. This project combines theory, implementation, and real-world impact, and I find it motivating to build reliable, reusable tools that others can use in areas like ML, optimization, and numerical analysis.

Qualifications

My background in algorithms and numerical methods, along with hands-on experience gained by working with stdlib over the past few months, prepares me well for this project. Through my coursework and projects, I have worked on topics such as search and optimization algorithms, which have given me a solid foundation for understanding how iterative and convergence-based algorithms behave. I have also explored optimization concepts in the context of machine learning, where minimizing loss functions and solving numerical problems are central.

On the technical side, I am comfortable with JavaScript and working in structured codebases, and I have spent time understanding stdlib's conventions for organizing packages, writing tests, and documenting functions. I have also studied how libraries like SciPy design and implement optimization routines, which helps me approach this project from both an algorithmic and design perspective. I am confident in my ability to independently implement these methods, handle edge cases, and ensure correctness through comprehensive testing and benchmarking.

Prior art

Numerical optimization and root-finding have been widely studied and implemented in scientific computing libraries. The most relevant reference for this project is SciPy's scipy.optimize module, which provides a comprehensive collection of scalar and multidimensional solvers such as Brent's method, Newton-type methods, Broyden variants, and Levenberg-Marquardt. These implementations, along with classical libraries like MINPACK, serve as strong references for algorithm design, convergence behavior, and API structure.

While stdlib currently does not have an equivalent optimization module, I have taken the initiative to explore this area by studying these libraries in detail and understanding how such algorithms can be adapted to fit stdlib's design principles. This project builds on that effort by bringing similar functionality into stdlib.

Additionally, I have already begun contributing in this direction by implementing Brent's method as an initial step, which has helped me gain practical insight into both the algorithmic challenges and how to structure such routines within stdlib. My PR can be accessed here.

Commitment

I plan to dedicate approximately 30–35 hours per week to this project during the GSoC period. I do not have any major conflicting commitments such as internships, exams, or travel, which allows me to work consistently and maintain steady progress. I will ensure regular communication with mentors, share updates frequently, and adapt based on feedback to keep the project on track. Additionally, I am committed to continuing my contributions beyond GSoC, further improving and expanding the optimization module within stdlib.

Schedule

Assuming a 12 week schedule,

• Community Bonding Period: Discuss and finalize API design and implementation details with mentors, including method interfaces, shared utilities, and package structure. Refine the project plan and clarify expectations around testing, benchmarking, and documentation. Continue initial implementation work and gather feedback to ensure a smooth start to the coding phase.

• Week 1: Complete brentq (Brent’s method) method, building on the work already underway. This will also help define common utilities (like bracketing and convergence checks) and the overall API.

• Week 2: Implement bisect, newton, and secant methods, ensuring consistency with the design established in Week 1.

• Week 3: Implement brenth and ridder methods, reusing bracketing utilities and standardizing behavior across methods.

• Week 4: Implement halley, toms748 methods and finalize scalar root-finding suite with consistent APIs and edge-case handling.

• Week 5: Begin elementwise optimization: implement find_root and bracket_root methods, along with necessary abstractions for vectorized execution.

• Week 6: (midterm): Complete elementwise root-finding support, including tests, benchmarks, and documentation. Ensure stability and consistency across scalar and elementwise APIs. Finish any pending task.

• Week 7: Begin multidimensional solvers: implement broyden1 and broyden2 methods.

• Week 8: Implement anderson, linearmixing, and diagbroyden methods.

• Week 9: Implement krylov and df-sane methods, along with shared iterative solver utilities.

• Week 10: Implement hybr and lm (Levenberg–Marquardt) methods, focusing on modular design and numerical stability.

• Week 11: Extend elementwise optimization to minimization: implement find_minimum and bracket_minimum methods. Focus on completing tests, improving documentation, and fixing edge cases across all implemented routines

• Week 12: Finalize all implementations, ensure high test coverage, polish documentation, and improve performance.

• Final Week: Address mentor feedback, fix remaining issues, finalize documentation, and submit the project.

Notes:

• The community bonding period is a 3 week period built into GSoC to help you get to know the project community and participate in project discussion. This is an opportunity for you to setup your local development environment, learn how the project's source control works, refine your project plan, read any necessary documentation, and otherwise prepare to execute on your project project proposal.
• Usually, even week 1 deliverables include some code.
• By week 6, you need enough done at this point for your mentor to evaluate your progress and pass you. Usually, you want to be a bit more than halfway done.
• By week 11, you may want to "code freeze" and focus on completing any tests and/or documentation.
• During the final week, you'll be submitting your project.

Related issues

GSoC Idea #27

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.

[gunjjoshi]

Hi @sagar7162, thanks for writing this proposal. A few thoughts:

• Make sure to prepare the stdlib showcase before submitting the proposal.
• As the work that you'll be doing is going to be a new addition, it would be nice if you can also describe more about the implementation, such as, how will the function signature of these methods look like? How will the "result objects", as you have mentioned them, will look like, in structure?
• In the community bonding period, you plan to discuss API design, implementation details, and related decisions with mentors. It would be better if you can come up with some concrete ideas beforehand, as this would demonstrate that you have done enough R&D, rather than leaving the core design work to be figured out during the bonding period itself.
• What all prerequisites will we need to implement these optimization algorithms in stdlib? Does stdlib currently have those prerequisites? If no, how do you plan to implement them? What are all those? Would be good to address these concerns in the proposal.
• You have added a link to all "closed" PRs, not all "merged" PRs, in the Merged PRs section. You need to replace the current link by this: https://github.com/stdlib-js/stdlib/pulls?q=is%3Apr+author%3Asagar7162+is%3Amerged+

Thanks.