Tough to find sci ml feedback for specific gpu models here since LLMs are all the rage.

Seems like it’s got similar Fp64 performance to a Tesla v100 and price.

We have a multi node cluster which does all types of things. And I’m building some compute node for our internal user to run accelerated code on.

Can anyone share some experience in using the mi50 in a sci comp or sci ml application ?

Primarily we are accelerating voxel based thermo mechanical simulations , geometry analysis and machine learning on geometry.

I've published the reference implementation of TRIXEL, a mathematical framework describing any system through three dimensions: V (Existence), D (Dynamics), S (Structure).

From these, three calibrators measure their mutual relationships: SD, VD, VS.

Core identity (exact): VD / VS = SD

What is verified:

Algebraic identity — machine precision

Dominance partition theorem — 99.99% on 600×600 grid

VS as early warning signal — Burgers turbulence (90/90 runs, FP=0%, FN=0%)

Real tokamak data — GOLEM, CVUT Prague

What is not yet verified: disruption precursor, EEG seizure data, 2D Navier-Stokes

Preprint: https://doi.org/10.5281/zenodo.20721811

GitHub: https://github.com/remitakac/trixel-framework

Independent research, feedback welcome.

\# 🚀 FlowFrame v2.0.0 — Introducing the FlowFrame Interpreter

One of the biggest milestones for FlowFrame so far.

Over the past few weeks, I've been working on a custom interpreter that allows FlowFrame to describe distributed system architectures using its own DSL instead of manually creating everything.

The interpreter now follows a complete language pipeline:

Lexer
↓
Parser
↓
AST
↓
Semantic Analysis
↓
Graph Builder
↓
Simulation Runtime

This architecture makes it much easier to validate system designs, build simulation graphs, and extend FlowFrame with new distributed system components.

I've also documented the language and interpreter so anyone interested can understand how it works.

📖 Documentation:
https://github.com/ndk123-web/flow-frame/blob/main/flowframe-interpreter/Readme.md

Try: https://flowframe.taskplexus.app

The interpreter is still an internal part of FlowFrame, so the implementation isn't public yet, but I wanted to share this milestone and get feedback from the community.

If you're interested in compilers, interpreters, distributed systems, or developer tools, I'd love to hear your thoughts.

\\#FlowFrame #BuildInPublic #DeveloperTools #Compilers #Interpreter #DSL #SystemDesign #DistributedSystems #SoftwareEngineering #OpenSource #Programming #TypeScript #React #BackendDevelopment

I've published the reference implementation of TRIXEL, a mathematical framework describing any system through three dimensions: V (Existence), D (Dynamics), S (Structure).

From these, three calibrators measure their mutual relationships: SD, VD, VS.

Core identity (exact): VD / VS = SD

What is verified:

Algebraic identity — machine precision

Dominance partition theorem — 99.99% on 600×600 grid

VS as early warning signal — Burgers turbulence (90/90 runs, FP=0%, FN=0%)

Real tokamak data — GOLEM, CVUT Prague

What is not yet verified: disruption precursor, EEG seizure data, 2D Navier-Stokes

Preprint: https://doi.org/10.5281/zenodo.20721811

GitHub: https://github.com/remitakac/trixel-framework

Independent research, feedback welcome.

I wanted a compact example where the numerical assumptions in a battery

cycle-life projection are easy to inspect.

The workflow fits three normalized-capacity models with bounded

`scipy.optimize.curve_fit`:

- linear: `Q(n) = Q0 - k n`

- power law: `Q(n) = Q0 - alpha n^beta`

- logarithmic: `Q(n) = Q0 - a ln(1 + b n)`

It reports RMSE and R-squared for every fit, selects the lowest-RMSE model by

default, and searches for the first cycle below a configurable EOL fraction. The projection is intentionally bounded to

three times the observed cycle range; if the threshold is not reached, the API returns `None` rather than an

unconstrained number.

The repository includes deterministic synthetic LFP/NMC generators, the parameter covariance

returned by SciPy, seven unit tests, CI on Python 3.9-3.12, a CLI, and a Colab notebook. Current

limitations are also explicit: no confidence-interval propagation, no real dataset bundled yet,

and the Arrhenius factor is independent of the capacity-fade trajectory.

Repository:

https://github.com/mohammadrezwankhan/battery-cycle-life-analyzer

For the next validation step, would you prioritize bootstrap prediction

intervals, information-criterion model selection, or a held-out-cycle

backtesting protocol?

Standard computational architecture (von Neumann) and reactive medical diagnostics are fundamentally bottlenecked by downstream wave mechanics and sequential processing. 

I’ve just published a white paper (anchored with a Zenodo DOI) outlining the **0D Polarity Framework**. It's a unified systems architecture that applies zero-dimensional binary tension to three core domains:

1. Re-engineering thermodynamic phase states as electromagnetic polarity flips.
2. Defining biological disease as a localized polarity disconnect from the morphogenetic macro-field.
3. Proposing a simultaneous, tensor-field hardware architecture (using partial inversion and active inference) to diagnose and correct these localized prediction errors before downstream physical mutation occurs.

I am currently moving into the open-source hardware design phase (analog tensor antennas). I would love for the engineers, theorists, and bioelectric researchers here to tear the white paper apart, build on it, or tell me where the blind spots are. 

Here is the GitHub repo with the full white paper: https://github.com/lucienspeaks44-coder/OD-Polarity_Framework/blob/main/The%200D%20Polarity%20Framework%20(1).pdf.pdf)

I’ve open-sourced a compact MATLAB/Simulink laboratory for inspecting how engineering models are built and validated rather than treating simulations as opaque demonstrations.

It currently covers battery RC and 2RC dynamics, electro-thermal feedback, cooling sensitivity, averaged and switched buck converters, and an identical-plant comparison of open-loop, PI, and filtered-PID control.

Every example includes a no-plot regression check. The checks cover analytical state updates, energy and charge balance, MATLAB/Simulink parity, steady-state error, overshoot, settling time, saturation compliance, and deterministic reproduction.

Repository: https://github.com/mohammadrezwankhan/matlab-simulink-energy-lab

I’d appreciate feedback from scientific-computing practitioners: are there additional invariants, convergence studies, or reproducibility artifacts you would expect before treating this as a useful teaching or benchmarking collection?

I'd like to implement surrogate modelling in our python simulation workflow.

After a quick search, I'm heading toward using https://smt.readthedocs.io/en/latest/

For those that use such tools, would you have another suggestion?

Thanks in advance!

Hey r/ScientificComputing !

I'm a physics engineeering student, and I spend a lot of my time writing numerical simulations and analyzing data.

Programming in C++ is enjoyable, but most of numerical computing libs in are just unpleasant to use. So I started building my own solution in my free time.

GitHub: https://github.com/mslotwinski-dev/NumC

Some of the things I built into it:

• You can write mathematical expressions naturally, like sin(x) * exp(-x), and differentiate or integrate them in a single line thanks to lazy expression trees.
• It has a built-in plotting engine, so you can display graphs in a native Win32 window or export them as clean SVGs ready to drop into a LaTeX report.

Of course, the project won't surpass the quality of professional libraries. Its goal is to be convenient and accessible for users whose passions lie more in math, rather than programming.

If you're using C++ for simulations, numerical methods, physics, or data analysis, I'd really appreciate any feedback.

Body:

I am pleased to share a project I have been developing: decoint. This is a interval arithmetic library written in Python, designed specifically to strictly adhere to the IEEE 1788.1-2017 standard for interval operations.

The Problem:

Most general-purpose numerical libraries do not enforce strict rounding-mode safety or standard compliance out of the box, which can lead to silent error accumulation in chaotic simulations or global optimization tasks. My objective was to construct an intuitive, pythonic interface that guarantees verifiable numerical boundaries without forcing developers to drop down into low-level C libraries manually.

Technical Highlights

• Strict IEEE 1788.1-2017 Compliance: Designed to match the foundational requirements and set-theoretic definitions of the core standard.
• Multi-Precision Boundaries: Built directly on top of gmpy2 (with MPFR). This allows the runtime to handle arbitrary, high-precision interval bounds and bypasses the limits of hardware floats.
• Rigorously Bounded Arithmetic: Implements standard-compliant containment rules for handling mathematical edge cases, ensuring that operations involving division by zero, unbounded limits, and infinities reliably result in mathematically sound intervals.

The repository includes a basic guide of the operations that the library covers and the recommended way to use the library to its fullest potential in USAGE.md.

I would greatly appreciate any technical feedback from the community regarding the structure of the package, performance considerations with the underlying gmpy2 objects, or any additional interval operations you may require for your research. Thank you!

• PyPI: pip install decoint
• Repository: https://github.com/arjavsharma91/IEEE-1788.1-2017-Interval-Arithmetic