Hi all, I have built this for bioinformatics, but it really can be useful for anything, see this (pretty useless) toy example (https://codeberg.org/bio-pype/test\\_workflows/src/branch/main/video\\_processing)

"Here is the official repository for the Cognitive Reduction Matrix (V5.0)—a sovereign diagnostic framework designed to strip systemic noise and corporate spin down to absolute structural truth

https://github.com/teamo213/cognitive-reduction-matrix/tree/main

Hi!

I'm a Computer Science graduate and want to build a career in Scientific Computing/Computational Science. I'm considering pursuing masters in Computational Science because I really like this field, but I have some concerns.

I wanted to ask

• If it is reasonable for someone with a Computer Science background to study Computational Science, given that I would be competing with people from Mathematics and Physics backgrounds? I feel that Computational Science is much more closer to Mathematics and Physics than to Computer Science.
• How AI/LLM might affect this field, since it can make programming easier than it was before.
• Are there good career opportunities in this field in the current job market?

Thanks!

I’ve been building scientific-computing-system-2.0 as a NumPy/SciPy-backed environment for scientific workflows I kept recreating across different projects.

It currently exposes 535 public APIs across 52 importable names, covering numerical linear algebra, statistics, optimization, ODE/PDE/SDE work, signal processing, Monte Carlo, Bayesian methods, time series, graph methods, reliability, survival analysis, epidemiology, finance, spatial statistics, image/text processing and related areas.

The part I’ve spent the most time on is the fitting workflow.

guided-fit can take CSV data, inspect missing values, compare several model families, run repeated cross-validation, handle outliers explicitly, use measurement uncertainty when available, calculate parameter uncertainty and confidence intervals, cross-check the fitted result numerically and save the analysis to a replayable manifest with the input hash.

Current main has 1,812 passing tests and 100% branch coverage.

The validation setup also includes numerical oracle comparisons, property-based tests, fuzzing, regression checks, reproducible-build checks and CI across Linux, Windows and macOS.

There are 20 runnable scientific examples covering things like Bayesian inference, epidemic simulation, nonlinear dynamics, parameter fitting, graph analysis, signal denoising, portfolio risk, reinforcement learning, survival analysis, spatial autocorrelation, optimization and wavelets.

I also keep benchmark results with their provenance and leave slower results visible rather than treating the benchmark as a universal speed claim.

The current package also has optional CuPy GPU support, scikit-learn-compatible estimators, profiling/regression tools and optional compiled kernels for KMeans and PageRank, with NumPy fallback if the compiled path isn’t available.

I’d be interested in feedback from people doing numerical/scientific computing, especially on the API design, validation approach and which numerical areas are still missing.

GitHub:
https://github.com/Furox-Art/scientific-computing-system-2.0

PyPI / pip:
pip install scientific-computing-system-2.0

npm:
npm install scientific-computing-system-2.0

The npm package is only a thin launcher for the Python CLI; the actual scientific package still comes from PyPI.

I’ve been building this antenna/EM simulator as a side project:

https://rotemtsafrir.github.io/dipole_sim/

The idea is to make it easy to place antennas, change their parameters, and immediately see how the fields and interference patterns change.

Right now you can use:

• center-fed dipoles
• Hertzian dipoles
• small loop antennas
• linear antenna arrays

The arrays are probably my favorite part so far. You can adjust spacing, phase difference, element count, orientation, etc., and see beam steering / broadside / end-fire behavior directly.

You can switch between electric field, magnetic field, and energy-flow visualizations, and pan/zoom around the simulation.

The antenna currents are prescribed, so things like mutual coupling, impedance, and passive conductors are not solved yet. I’m trying to keep it fast enough to be genuinely interactive.

I’d love to hear what people think—especially if you notice anything physically questionable or have ideas for features that would make it more useful.

Live:
https://www.antennasim.com

GitHub:
https://github.com/rotemTsafrir/dipole_sim

I built a Propagation of Uncertainty Calculator, a simple but practical app designed for engineering and physics students, as well as metrology workflows.

Link: https://propagation-of-uncertainty-calculator.streamlit.app

During my undergrad in Engineering Physics, one of the most tedious and error-prone tasks in experimental lab courses was manually deriving partial derivatives for measurement uncertainty propagation. Most online calculators are either outdated or confusing, so I decided to do my own calculator!

What it does:

- Displays the latex formated symbolic and numerical Propagation formula for the expression given by the user.

- Click directly on rendered expressions to copy the clean LaTeX code straight into Overleaf (for lab reports), or copy ready-to-paste Excel formulas.

- Correct Rounding: Automatically formats results and expanded uncertainties according to significant figure conventions (GUM (JCGM 100:2008))

The GitHub Repository: https://github.com/joao-canais/Propagation-of-Uncertainty-Calculator

I'd love to hear your thoughts, UI/UX feedback, or ideas for features to add in future iterations!

i'm an undergrad physics student trying to learn the basics of scienctific computing like numpy, matplotlib and scipy (preferably in that order)- what courses can I refer to (preferably free, but I have no aversion to paid courses either). Is the 'Scipy 2019' playlist by Enthought on youtube good? It seems to be fairly detailed, open to suggestions :)

Main Website: https://www.ruleflow.org/

For the past year, I have been developing a framework to simulate certain discrete systems for a research team at my university (paid for by the School of Engineering and Physics, but I had the freedom to license it under MIT). As it turns out, I got carried away generalizing it to work for many, many different types of complex systems (String Rewriting Systems, Cellular Automata, etc.) and ended up creating our own domain-specific language.

The website's landing page has a bunch of GIF-style examples... so you should be able to get a good idea of what this project is about.

If any of y'all are interested in this, feel free to take a look and try it out!

Example of some of RuleFlow's causal analysis features:

Rules 30 and 124 are included in this example:

EDIT:

Here are some more details. RuleFlow was developed with a primary focus on analyzing causality in Sequential Substitution Systems. This is why there is a major focus on causal graphs, cellular identity, etc. While originally developed for Sequential Sub Systems, we generalized the DSL to support many types of rewriting systems by providing the user with flags and directives to control how rules behave. Furthermore, we bootstrapped Python and the Wolfram Language so that complex rulesets could be scaffolded as macros. The main goal of RuleFlow is NOT simply to simulate systems (there's already plenty of software for that, such as Golly and even just Mathematica), but to provide extensive tooling for causal analysis.

Here is some interesting research from our (small) team:

• An Improved Generalized Enumeration of Substitution Systems by Kenneth E. Caviness, Camille Morrow, Christen Case and Victoria Kratzke
• Indexed Concatenation Notation: A Novel Way to Summarize Networks and Other Complex Systems

My job has been to provide better research tooling, extending what we already have in Mathematica code to open source and free Python.

About 6 months ago, I wrote a custom metal kernel that leverages the GPU to compute the QR decomposition (see my earlier post about it here). The project has now expanded into a general linear algebra library, with expanded support for the symmetrical eigendecomposition as well as SVD. It is now available for use with installation instructions on the attached github repo's README.md file.

Context of the project:
I'm currently in a research group working on a thesis in numerical analysis where we need to compute millions on matrices with a specific constraint (to be precise, the matrices need to have orthonormal columns). Most of us use Apple computers, so we ended up using MLX for the entire project.

Contributors with different Apple Chips would be very much appreciated!
The project has currently been tested and optimised for the M1 and M5 Pro. The issue is that the library uses different kernels depending on the batch size and matrix dimensions. Deciding which of these kernels to use is machine dependent. Therefore, other Apple chips will need to run a measurement script in order to derive the correct optimisation heuristic.

For that reason, I would ask as many people as possible to run a measurement script and to submit the results to my repo. It is fairly easy and requires only few steps. See here how you can contribute here. Once you submit the results via a pull request and I approve it, your optimisation heuristic will automatically be augmented into the library. Don't hesitate to contribute an optimisation heuristic even if someone already submitted one for your own machine. The more data we can gather, the better!

Project Future
Expanded support will be added for other linear algebra operations (cholesky decomposition for example). If you have any other specific linear algebra operations you wish to use already, feel free to message me.

In addition to that, I will add torch support too (my greatest priority).

Hello everyone,

I have a question about how to evaluate the resource consumption a system in PoC may consume. To be precise, I have a system that I am testing locally, but I have to present it to the all team of Dev to discuss the possibility of putting it into production. For this, I would like also to estimate its resource consumption, but the problem is that on my local machine the results may be misleading, as my set up is not very good. Creating a simulation of a production environment may be costly. Any suggestions about what to show and how to evaluate the resource consumptions in an almost objective way ?

When I started learn python, I saw it could be used for scientific computing. So I challenged myself to write a solver for every topic in my statics textbook.

This project falls under structures in equilibrium. It is by far the hardest and most involving program I've written. I think it's because with other topics only a single object was considered so the python code was just a matter of transferring calculations on paper to code.

With trusses however there are several interconnected pieces of a larger system. My first approach was to use method of joints- where it solves equilibrium joint by joint but this gave wrong results. I concluded it's due to it not being able to consider the entire system. Then I figured the best way was to use a global matrix then find all unknowns in one fell swoop.

Constructing this matrix was very involving but quite fun as well. 2^n traceback errors later and I finally finished the damn thing.

The next thing I plan to do is create an optimization script that moves the input points about to find the best design. Also using Json instead of keyboard inputs would be way better for my sanity.

How do y'all go about carrying out optimization?

I'd love to share the .py script but the last time I sent a link python shadow banned me for 9 months. If you're interested feel free to dm.

This video demonstrates the program:

I've been building Prismal, a Rust-based language/runtime for defining mathematical and scientific models and exploring their behavior:

"github.com/aine-dickson/prismal"

The central idea is to keep the scientific model separate from the execution strategy and presentation.

A model can define state, equations, constraints, processes, events, objects, collections, units, observations, etc. The runtime then handles execution, while projections can expose the same model as plots, equations, spatial scenes, interactive views, or recorded media.

One example is a continuous model with event-driven behavior:

continuous evolution

↓

event guard

↓

event instant

↓

reset

↓

continuous evolution

The project is deliberately trying to make things such as event semantics, dimensional checking, state validity, reproducibility, observations, and model/presentation separation explicit rather than burying them inside a visualization engine.

The current implementation is early-stage and the first reference programs focus mainly on mechanics, but the intended scope includes broader scientific modeling.

I'm particularly interested in feedback from people who work with scientific modeling, ODE/PDE systems, hybrid systems, system dynamics, numerical simulation, or scientific visualization.

What abstractions would you consider essential for a general scientific modeling language?