#numericalanalysis — Public Fediverse posts
Live and recent posts from across the Fediverse tagged #numericalanalysis, aggregated by home.social.
-
Start here: Standard-Slope Integration (SSI)
A new, first-of-its-kind class of derivative-driven integration operators built solely from slope information.
If you’re new to my work, this post links to the full SSI series—a structured overview of a first-of-its-kind, derivative-driven integration operator built on structural iteration invariants and slope-based reconstruction. The recap summarizes all seven posts in order and provides the conceptual foundation for understanding SSI.
Series recap:
https://mathstodon.xyz/@BlueNovaX/116523359117197532
Repository with details and examples:
https://github.com/BlueNovaX/standard-slope-integration
#numericalanalysis #scientificcomputing #mathematics #integration #StandardSlopeIntegration #SSI
-
Standard‑Slope Integration (SSI) — Post #3: Failure-mode robustness
A new, first-of-its-kind class of derivative-driven integration operators built solely from slope information.
Classical integration methods often fail when the integrand is discontinuous, poorly conditioned, or structurally misaligned with area-based accumulation. SSI approaches these cases differently: its derivative-driven structure and step-to-step invariants prevent the amplification and drift that destabilize classical formulations.
This makes SSI effective in cases where traditional quadrature becomes unstable, unreliable, or fails outright—not by modifying classical methods, but by using a fundamentally different reconstruction principle.
#numericalanalysis #scientificcomputing #mathematics #integration #StandardSlopeIntegration #SSI
-
An excellent introduction to #quantization used for #LLMs 👌🏽:
“Quantization From The Ground Up”, Sam Rose, Ngrok (https://ngrok.com/blog/quantization).
On HN: https://news.ycombinator.com/item?id=47519295
#AI #Math #FloatingPoint #NumericalAnalysis #Numbers #NeuralNetworks #Precision #Accuracy
-
An excellent introduction to #quantization used for #LLMs 👌🏽:
“Quantization From The Ground Up”, Sam Rose, Ngrok (https://ngrok.com/blog/quantization).
On HN: https://news.ycombinator.com/item?id=47519295
#AI #Math #FloatingPoint #NumericalAnalysis #Numbers #NeuralNetworks #Precision #Accuracy
-
An excellent introduction to #quantization used for #LLMs 👌🏽:
“Quantization From The Ground Up”, Sam Rose, Ngrok (https://ngrok.com/blog/quantization).
On HN: https://news.ycombinator.com/item?id=47519295
#AI #Math #FloatingPoint #NumericalAnalysis #Numbers #NeuralNetworks #Precision #Accuracy
-
An excellent introduction to #quantization used for #LLMs 👌🏽:
“Quantization From The Ground Up”, Sam Rose, Ngrok (https://ngrok.com/blog/quantization).
On HN: https://news.ycombinator.com/item?id=47519295
#AI #Math #FloatingPoint #NumericalAnalysis #Numbers #NeuralNetworks #Precision #Accuracy
-
`Various software efforts embrace the idea that object oriented programming enables a convenient implementation of the chain rule, facilitating so-called automatic differentiation via backpropagation. Such frameworks have no mechanism for simplifying the expressions (obtained via the chain rule) before evaluating them. As we illustrate below, the resulting errors tend to be unbounded.`
https://arxiv.org/abs/2305.03863
#calculus #software #numericalAnalysis #automaticDifferentiation #uncertainty
-
🧐:
“It’s OK To Compare Floating-Points For Equality”, Nikita Lisitsa (https://lisyarus.github.io/blog/posts/its-ok-to-compare-floating-points-for-equality.html).
Via HN: https://news.ycombinator.com/item?id=47767398
On Lobsters: https://lobste.rs/s/l6c9wi/it_s_ok_compare_floating_points_for
#Math #Programming #FloatingPoint #NumericalAnalysis #Precision #Errors #Numerics
-
🧐:
“It’s OK To Compare Floating-Points For Equality”, Nikita Lisitsa (https://lisyarus.github.io/blog/posts/its-ok-to-compare-floating-points-for-equality.html).
Via HN: https://news.ycombinator.com/item?id=47767398
On Lobsters: https://lobste.rs/s/l6c9wi/it_s_ok_compare_floating_points_for
#Math #Programming #FloatingPoint #NumericalAnalysis #Precision #Errors #Numerics
-
🧐:
“It’s OK To Compare Floating-Points For Equality”, Nikita Lisitsa (https://lisyarus.github.io/blog/posts/its-ok-to-compare-floating-points-for-equality.html).
Via HN: https://news.ycombinator.com/item?id=47767398
On Lobsters: https://lobste.rs/s/l6c9wi/it_s_ok_compare_floating_points_for
#Math #Programming #FloatingPoint #NumericalAnalysis #Precision #Errors #Numerics
-
🧐:
“It’s OK To Compare Floating-Points For Equality”, Nikita Lisitsa (https://lisyarus.github.io/blog/posts/its-ok-to-compare-floating-points-for-equality.html).
Via HN: https://news.ycombinator.com/item?id=47767398
On Lobsters: https://lobste.rs/s/l6c9wi/it_s_ok_compare_floating_points_for
#Math #Programming #FloatingPoint #NumericalAnalysis #Precision #Errors #Numerics
-
Alright, future engineers!
Euler's Method: Approximates solutions to Ordinary Differential Equations (ODEs) by taking small steps along the tangent. Ex: `y_new = y_old + h * f(x_old, y_old)`. Pro-Tip: Simple, but smaller 'h' improves accuracy (at cost of computation)!
#ODEs #NumericalAnalysis #STEM #StudyNotes -
Truncation error is the error from approximating an exact solution (e.g., infinite series) with a finite one. Ex: `e^x ≈ 1 + x + x^2/2!` (we 'truncated' it!). Pro-Tip: Use more terms or smaller step sizes to reduce this error!
-
Your college professor teaches you "A-stable methods are required for stiff ODEs". But PSA, the most commonly used stiff ODE solvers (adaptive order BDF methods) are not A-stable. #sciml #numericalanalysis #diffeq
-
Your college professor teaches you "A-stable methods are required for stiff ODEs". But PSA, the most commonly used stiff ODE solvers (adaptive order BDF methods) are not A-stable. #sciml #numericalanalysis #diffeq
-
Your college professor teaches you "A-stable methods are required for stiff ODEs". But PSA, the most commonly used stiff ODE solvers (adaptive order BDF methods) are not A-stable. #sciml #numericalanalysis #diffeq
-
Your college professor teaches you "A-stable methods are required for stiff ODEs". But PSA, the most commonly used stiff ODE solvers (adaptive order BDF methods) are not A-stable. #sciml #numericalanalysis #diffeq
-
Your college professor teaches you "A-stable methods are required for stiff ODEs". But PSA, the most commonly used stiff ODE solvers (adaptive order BDF methods) are not A-stable. #sciml #numericalanalysis #diffeq
-
New preprint https://arxiv.org/abs/2511.06957
A #perspective discussing Moreau-Yosida (MY) techniques in #densityfunctionaltheory.
MY regularisation has enabled to import tools from #convexanalysis into #dft
providing a new mathematical understanding of the most important atomistic simulation approach
and new robust algorithms for Kohn-Sham #dft.Thanks to my co-authors from the #hylleraas centre and #oslomet for insightful discussions.
-
New preprint https://arxiv.org/abs/2511.06957
A #perspective discussing Moreau-Yosida (MY) techniques in #densityfunctionaltheory.
MY regularisation has enabled to import tools from #convexanalysis into #dft
providing a new mathematical understanding of the most important atomistic simulation approach
and new robust algorithms for Kohn-Sham #dft.Thanks to my co-authors from the #hylleraas centre and #oslomet for insightful discussions.
-
Automatic Differentiation Can Be Incorrect
#HackerNews #AutomaticDifferentiation #Incorrectness #NumericalAnalysis #Simulation #MachineLearning
-
Implicit Ode Solvers Are Not Universally More Robust Than Explicit Ode Solvers
#HackerNews #ImplicitOdeSolvers #ExplicitOdeSolvers #NumericalAnalysis #ComputationalMath #Robustness #Algorithms
-
Implicit Ode Solvers Are Not Universally More Robust Than Explicit Ode Solvers
#HackerNews #ImplicitOdeSolvers #ExplicitOdeSolvers #NumericalAnalysis #ComputationalMath #Robustness #Algorithms
-
Implicit Ode Solvers Are Not Universally More Robust Than Explicit Ode Solvers
#HackerNews #ImplicitOdeSolvers #ExplicitOdeSolvers #NumericalAnalysis #ComputationalMath #Robustness #Algorithms
-
Implicit Ode Solvers Are Not Universally More Robust Than Explicit Ode Solvers
#HackerNews #ImplicitOdeSolvers #ExplicitOdeSolvers #NumericalAnalysis #ComputationalMath #Robustness #Algorithms
-
Implicit Ode Solvers Are Not Universally More Robust Than Explicit Ode Solvers
#HackerNews #ImplicitOdeSolvers #ExplicitOdeSolvers #NumericalAnalysis #ComputationalMath #Robustness #Algorithms
-
@chrisrackauckas The excellent blog post above explains in detail why implicit ODE solvers are considered more robust than explicit ODE solvers (because they do better on linear problems) and why this is NOT true for all problems (roughly speaking, nonlinear problems can behave differently for linear problems; see the blog post for a better explanation which does not fit here).
An extreme example are exponential integrators, which have perfect stability for linear problems (because they use the analytical solution of linear ODEs). Nevertheless, exponential integrators still suffer from stability problems for nonlinear problems.
#NumericalAnalysis #ODEsolver #NumericalIntegration #ExponentialIntegrator
-
Here are more details on the winners of the Leslie Fox Prize for Numerical Analysis, copied from the announcement in NA-Digest at https://na-digest.coecis.cornell.edu/na-digest-html/25/v25n27.html#3
All gave excellent talks and I hugely enjoyed listening to them.
1st Prizes:
James Foster (Bath) for "High order splitting methods for SDEs satisfying a commutativity condition"Tizian Wenzel (LMU Munich) for "Analysis of target data-dependent greedy kernel algorithms"
2nd Prizes:
Sara Fraschin (Vienna) for "Stability of conforming space-time isogeometric methods for the wave equation"Georg Maierhofer (Cambridge) for "Bridging the gap: symplecticity and low regularity in Runge-Kutta resonance-based schemes"
Wenqi Zhu (Oxford) for "Cubic-quartic regularization models for solving polynomial subproblems in third-order tensor methods"
David Persson (NYU) for "Randomized low-rank approximation of monotone matrix functions"
-
Yo! They used the BFGS algorithm, and "S" was SHANNO! That reminded me who it was who tried to recruit me into numerical analysis. It was this very Professor Shanno!
kholub.com/projects/uniform_plinko.html?fbclid=IwQ0xDSwLL9CJjbGNrAsvW8GV4dG4DYWVtAjExAAEeWIYV4owZNQdOwgcdYV0vlNxqFtZVrTclkrYrvCu12qqssxtt7m1UO4fIiDA_aem_x3EEe2QaW4wJTTArSzVjgQ https://kholub.com/projects/uniform_plinko.html?fbclid=IwQ0xDSwLL9CJjbGNrAsvW8GV4dG4DYWVtAjExAAEeWIYV4owZNQdOwgcdYV0vlNxqFtZVrTclkrYrvCu12qqssxtt7m1UO4fIiDA_aem_x3EEe2QaW4wJTTArSzVjgQ
-
I an in Glasgow for the Leslie Fox prize meeting, celebrating young people's contributions to numerical analysis. Already heard two interesting talks. I velieve four more are to follow. Exciting!
-
Whoa, hold onto your protractors! 🤓 Rohan's blog post just made Gaussian integration the hip new thing for the cool kids of numerical analysis. Because nothing screams "party" like Chebyshev-Gauss quadrature and evaluating definite integrals! 🎉
https://rohangautam.github.io/blog/chebyshev_gauss/ #GaussianIntegration #ChebyshevGauss #NumericalAnalysis #MathIsCool #PartyWithMath #HackerNews #ngated -
Whoa, hold onto your protractors! 🤓 Rohan's blog post just made Gaussian integration the hip new thing for the cool kids of numerical analysis. Because nothing screams "party" like Chebyshev-Gauss quadrature and evaluating definite integrals! 🎉
https://rohangautam.github.io/blog/chebyshev_gauss/ #GaussianIntegration #ChebyshevGauss #NumericalAnalysis #MathIsCool #PartyWithMath #HackerNews #ngated -
Whoa, hold onto your protractors! 🤓 Rohan's blog post just made Gaussian integration the hip new thing for the cool kids of numerical analysis. Because nothing screams "party" like Chebyshev-Gauss quadrature and evaluating definite integrals! 🎉
https://rohangautam.github.io/blog/chebyshev_gauss/ #GaussianIntegration #ChebyshevGauss #NumericalAnalysis #MathIsCool #PartyWithMath #HackerNews #ngated -
Whoa, hold onto your protractors! 🤓 Rohan's blog post just made Gaussian integration the hip new thing for the cool kids of numerical analysis. Because nothing screams "party" like Chebyshev-Gauss quadrature and evaluating definite integrals! 🎉
https://rohangautam.github.io/blog/chebyshev_gauss/ #GaussianIntegration #ChebyshevGauss #NumericalAnalysis #MathIsCool #PartyWithMath #HackerNews #ngated -
New publication https://doi.org/10.1103/PhysRevB.111.205143
New algorithm for the #inverseproblem of Kohn-Sham #densityfunctionaltheory (#dft), i.e. to find the #potential from the #density.
Outcome of a fun collaboration of @herbst with the group of Andre Laestadius at #oslomet to derive first mathematical error bounds for this problem
#condensedmatter #planewave #numericalanalysis #convexanalysis #dftk
-
New publication https://doi.org/10.1103/PhysRevB.111.205143
New algorithm for the #inverseproblem of Kohn-Sham #densityfunctionaltheory (#dft), i.e. to find the #potential from the #density.
Outcome of a fun collaboration of @herbst with the group of Andre Laestadius at #oslomet to derive first mathematical error bounds for this problem
#condensedmatter #planewave #numericalanalysis #convexanalysis #dftk
-
That first implementation didn't even support the multi-GPU and multi-node features of #GPUSPH (could only run on a single GPU), but it paved the way for the full version, that took advantage of the whole infrastructure of GPUSPH in multiple ways.
First of all, we didn't have to worry about how to encode the matrix and its sparseness, because we could compute the coefficients on the fly, and operate with the same neighbors list transversal logic that was used in the rest of the code; this allowed us to minimize memory use and increase code reuse.
Secondly, we gained control on the accuracy of intermediate operations, allowing us to use compensating sums wherever needed.
Thirdly, we could leverage the multi-GPU and multi-node capabilities already present in GPUSPH to distribute computations across all available devices.
And last but not least, we actually found ways to improve the classic #CG and #BiCGSTAB linear solving algorithms to achieve excellent accuracy and convergence even without preconditioners, while making the algorithms themselves more parallel-friendly:
https://doi.org/10.1016/j.jcp.2022.111413
4/n
-
That first implementation didn't even support the multi-GPU and multi-node features of #GPUSPH (could only run on a single GPU), but it paved the way for the full version, that took advantage of the whole infrastructure of GPUSPH in multiple ways.
First of all, we didn't have to worry about how to encode the matrix and its sparseness, because we could compute the coefficients on the fly, and operate with the same neighbors list transversal logic that was used in the rest of the code; this allowed us to minimize memory use and increase code reuse.
Secondly, we gained control on the accuracy of intermediate operations, allowing us to use compensating sums wherever needed.
Thirdly, we could leverage the multi-GPU and multi-node capabilities already present in GPUSPH to distribute computations across all available devices.
And last but not least, we actually found ways to improve the classic #CG and #BiCGSTAB linear solving algorithms to achieve excellent accuracy and convergence even without preconditioners, while making the algorithms themselves more parallel-friendly:
https://doi.org/10.1016/j.jcp.2022.111413
4/n
-
That first implementation didn't even support the multi-GPU and multi-node features of #GPUSPH (could only run on a single GPU), but it paved the way for the full version, that took advantage of the whole infrastructure of GPUSPH in multiple ways.
First of all, we didn't have to worry about how to encode the matrix and its sparseness, because we could compute the coefficients on the fly, and operate with the same neighbors list transversal logic that was used in the rest of the code; this allowed us to minimize memory use and increase code reuse.
Secondly, we gained control on the accuracy of intermediate operations, allowing us to use compensating sums wherever needed.
Thirdly, we could leverage the multi-GPU and multi-node capabilities already present in GPUSPH to distribute computations across all available devices.
And last but not least, we actually found ways to improve the classic #CG and #BiCGSTAB linear solving algorithms to achieve excellent accuracy and convergence even without preconditioners, while making the algorithms themselves more parallel-friendly:
https://doi.org/10.1016/j.jcp.2022.111413
4/n
-
That first implementation didn't even support the multi-GPU and multi-node features of #GPUSPH (could only run on a single GPU), but it paved the way for the full version, that took advantage of the whole infrastructure of GPUSPH in multiple ways.
First of all, we didn't have to worry about how to encode the matrix and its sparseness, because we could compute the coefficients on the fly, and operate with the same neighbors list transversal logic that was used in the rest of the code; this allowed us to minimize memory use and increase code reuse.
Secondly, we gained control on the accuracy of intermediate operations, allowing us to use compensating sums wherever needed.
Thirdly, we could leverage the multi-GPU and multi-node capabilities already present in GPUSPH to distribute computations across all available devices.
And last but not least, we actually found ways to improve the classic #CG and #BiCGSTAB linear solving algorithms to achieve excellent accuracy and convergence even without preconditioners, while making the algorithms themselves more parallel-friendly:
https://doi.org/10.1016/j.jcp.2022.111413
4/n
-
That first implementation didn't even support the multi-GPU and multi-node features of #GPUSPH (could only run on a single GPU), but it paved the way for the full version, that took advantage of the whole infrastructure of GPUSPH in multiple ways.
First of all, we didn't have to worry about how to encode the matrix and its sparseness, because we could compute the coefficients on the fly, and operate with the same neighbors list transversal logic that was used in the rest of the code; this allowed us to minimize memory use and increase code reuse.
Secondly, we gained control on the accuracy of intermediate operations, allowing us to use compensating sums wherever needed.
Thirdly, we could leverage the multi-GPU and multi-node capabilities already present in GPUSPH to distribute computations across all available devices.
And last but not least, we actually found ways to improve the classic #CG and #BiCGSTAB linear solving algorithms to achieve excellent accuracy and convergence even without preconditioners, while making the algorithms themselves more parallel-friendly:
https://doi.org/10.1016/j.jcp.2022.111413
4/n
-
People in the market for a postdoc position in numerical linear algebra should look at the advert for a postdoc in Edinburgh "devoted to research on Randomized Numerical Linear Algebra for Optimization and Control of Partial Differential Equations."
The mentors are John Pearson (Edinburgh) and Stefan Güttel (Manchester), both excellent people, and the topic is fascinating. I even fantasised about leaving my permanent job and doing this instead ...
More info: https://www.jobs.ac.uk/job/DNA984/postdoctoral-research-associate
#NumericalAnalysis #optimization #PartialDifferentialEquations #postdoc
-
Thanks to the Manchester NA group for organizing a seminar by David Watkins, one of the foremost experts on matrix eigenvalue algorithms. I find numerical linear algebra talks often too technical, but I could follow David's talk quite well even though I did not get everything, so thanks for that.
David spoke about the standard eigenvalue algorithm, which is normally called the QR-algorithm. He does not like that name because the QR-decomposition is not actually important in practice and he calls it the Francis algorithm (after John Francis, who developed it). It is better to think of the algorithm as an iterative process which reduces the matrix to triangular form in the limit.
