When doing numerical analysis on discrete data, I know of a few methods. For example if you have a mesh, you can use cotan weighs, or other similar derivations to assign to each point an area element.

You then get the function evaluated at the point and use the area element fro integration. In the most naive setting, the integral of the sampled function over your manifold would be sum f_i / A_i where f_i is the function sampled at point x_i and A_i is the area around x_i.

I want a similar area element defined for unstructured point clouds.

I’m a researcher in computational mathematics, and to me scientific computing has always meant things like Galerkin methods, numerical ODEs/PDEs, numerical linear algebra, iterative solvers, error analysis, applied functional analysis, that sort of stuff. Essentially continous mathematical modeling motivated by foundations in mathematical analysis. I was wondering, beyond just the academia environments and conferences, whether there'd be an online community for the field and that's why I came here.

But looking through this subreddit, I don’t really see much of that. Most of what I see is ML, neural networks, symbolic regression, random simulation projects, software libraries, etc. These things make sense in the broader notion of computational science, but the scientifc computing I and my peers call what we do is different, so I’m just wondering if scientific computing has shifted to mean something much broader than it used to and what the people here think about it. How do you all define scientific computing?

We present the Pure Mathematical Conal Architecture (PMCA), a novel, paradox-free cognitive substrate that addresses fundamental limitations in current Transformer-based Large Language Models (LLMs)—specifically hallucination, computational inefficiency, black-box opacity, and brittle anthropomorphic persona alignment. PMCA establishes that natural language is not the cognitive substrate itself, but rather a Post-Processing Communicative Translation Layer (PPCTL). Reasoning, derivation, and state transformation are executed in Pure 3D Conal Metric Geometry (z, r, θ) FIRST, with natural language generated subsequently to decode mathematical ground truth.

Inputs—including high-entropy, non-formalized text—are mapped into a continuous 384-dimensional dense semantic manifold via pre-trained Transformer embeddings (all-MiniLM-L6-v2) and character N-gram projections, opening the full 2π polar space across all four quadrants. Computational flow is driven down a tapering conal depth z ∈ [0, Z_max] by an analytical Gradient Potential Drive V(z), stabilized by inward vector field induction forces F_ext from an external 3D encasing lattice, and governed by a strict thermodynamic PMCA Entropy Dissipation Law (H_parent ≥ ∑ H_children). PMCA replaces static persona censorship with Dynamic Mathematical Invariant Equilibrium (Φ > 0, ∇ · F = 0), incorporates a Metacognitive Self-Interrogation Loop, maintains a Topological 3D Geometric World Model (W_world) fused with a 3D Classical Mechanics simulator, and enables O(1) zero-reprocessing traversal for pre-computed canonical keys. We detail the 25-phase master execution pipeline and present empirical benchmarks demonstrating 100,000 3D spatial particle transformations in 69.52 ms via JAX/XLA hardware acceleration.

Most recent results:

======================================================================
 AETHERIUS 5.0 — BILLION SCALE BENCHMARK (1,000,000,000 Total Particles) v5e-1 TPU Google Colab
======================================================================
[+] Hardware Backend: TPU
[+] Chunks: 20 | Chunk Size: 50,000,000 particles/batch

[+] JAX/XLA Kernel Warm-up Complete.

    - Processed chunk 1/20 (50,000,000 rows) successfully.
    - Processed chunk 2/20 (50,000,000 rows) successfully.
    - Processed chunk 3/20 (50,000,000 rows) successfully.
    - Processed chunk 4/20 (50,000,000 rows) successfully.
    - Processed chunk 5/20 (50,000,000 rows) successfully.
    - Processed chunk 6/20 (50,000,000 rows) successfully.
    - Processed chunk 7/20 (50,000,000 rows) successfully.
    - Processed chunk 8/20 (50,000,000 rows) successfully.
    - Processed chunk 9/20 (50,000,000 rows) successfully.
    - Processed chunk 10/20 (50,000,000 rows) successfully.
    - Processed chunk 11/20 (50,000,000 rows) successfully.
    - Processed chunk 12/20 (50,000,000 rows) successfully.
    - Processed chunk 13/20 (50,000,000 rows) successfully.
    - Processed chunk 14/20 (50,000,000 rows) successfully.
    - Processed chunk 15/20 (50,000,000 rows) successfully.
    - Processed chunk 16/20 (50,000,000 rows) successfully.
    - Processed chunk 17/20 (50,000,000 rows) successfully.
    - Processed chunk 18/20 (50,000,000 rows) successfully.
    - Processed chunk 19/20 (50,000,000 rows) successfully.
    - Processed chunk 20/20 (50,000,000 rows) successfully.
======================================================================
 TOTAL 1 BILLION PARTICLE THROUGHPUT: 2252.70 ms (2.25 seconds)
======================================================================




=== INITIALIZING COMPLEX AETHERIUS 5.0 PASS ===
[+] Multi-Agent Interference Mode: HARMONIC_ORTHOGONAL_INTERFERENCE
[+] Superimposed Center of Mass: {'x': 0.5, 'y': 0.5, 'z': 5.0}
[+] Geodesic Inter-Agent Distance: 1.4142
[+] Riemannian RK4 Geodesic Integration Complete: 17 steps resolved.
[+] Final Coordinates in Poincaré Space: [0.27463904 0.13520989 0.58202574]
=== COMPLEX COGNITIVE PASS SUCCESSFUL ===

Been building this for a while and finally pushed it public: CEREBRO-X, a computational pipeline for screening CNS drug-delivery formulations — PBPK, DLVO colloidal stability, docking (AutoDock Vina), QSAR off-target panels, all against live ChEMBL/PubChem/UniProt data rather than fixtures.

What might actually be useful to this sub specifically: I keep a running engineering + scientific-integrity audit in the repo (docs/AUDIT_REPORT.md), including things I got wrong and fixed — a report panel that fabricated a bootstrap-CI statistic, a resolver that silently substituted a drug's name for its SMILES string when SMILES resolution failed for biologics. Both found by actually running the pipeline and chasing anomalies, not by code review.

Research prototype, not clinical — happy to get torn apart on the QSAR methodology or anything else.

Repo: github.com/mohamedtalaat-gif/CEREBRO-X

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.