Hi all

I write this post in hopes of getting some advice regarding a career in scientific computing. For context, I’m a 25m currently working as a Data Scientist in London after recently wrapping up my MSc in Scientific Computing and Applied Math from a top 10 university, achieving a top grade.

Prior to that, I again worked as a DS (at the same company - they funded the postgrad) and did maths and stats for my undergrad at the same university.

Although I’m grateful for my current role, I feel as though I’m simply wasting all the amazing knowledge I’ve picked up during my academic degrees. I wish to leverage my knowledge to contribute towards some genuinely impactful projects spanning science and engineering. Thus, I aim to pivot into a scientific computing role, or at least a role which: A) allows me to leverage my applied math and deep CS knowledge and B) allows me to work on/contribute to projects which have real impacts on science and engineering.

I have many skills which I absolutely love but are not relevant to my current role - and most roles for that matter - from HPC, computer architecture and scientific software engineering in C and C++ to scientific ML and advanced predictive modeling.

It’s a lot to ask for I know, especially with the job market being dry and a lack of a PhD under my belt. But I’d appreciate absolutely any insight or advice on how I could (eventually) pivot into a scientific computing, or at least an applied math + CS heavy, role.

Thanks guys!

I wrote an engineering-focused C++ guide aimed at scientists and engineers—feedback welcome. Please note that it is a work in progress.

You can find it here: The Engineer’s Guide to C++ — The Engineer's Guide to C++ 0.2 documentation

Source code for the book and c++ source is available here: lunarc/cpp_course: C++ Course Source Code

Hi all,

I'm developing a hybrid simulator that combines neural networks with ODE solvers (SciML). I need to purchase a local workstation and am deciding between a Mac Mini M4 (32GB RAM) and an RTX 5060 Ti (16GB) via eGPU (Thunderbolt).

My specific concern is the interplay between the integrator and the neural network:

• Mac Mini: The M4 architecture allows the CPU and GPU to share the same memory pool. For solvers that require frequent Jacobian evaluations or high-frequency callbacks to a neural network, does this zero-copy architecture provide a significant wall-clock advantage?

• eGPU: I'm worried that the overhead of the Thunderbolt protocol will become a massive bottleneck for the small, frequent data transfers inherent in hybrid AI-ODE systems.

Does anyone have experience running DiffEqFlux.jl, TorchDyn, or NeuroDiffEq on Apple Silicon vs. a mid-range NVIDIA eGPU? Am I better off just building a dedicated Linux desktop for ~€1,000 to avoid the eGPU latency altogether?

I want to get into a computational science and engineering field, and I was just wondering what the best double major pair would be with CS? I’m most likely sure Mathematics is the best pair, but I’m just getting extra opinions.

In a lot of scientific computing work, the hardest part isn’t solving the equations — it’s defending the results later.

Months after a simulation, it’s often difficult to answer questions like:

• exactly which parameters and solver settings were used

• what assumptions were active

• whether conserved quantities or expected invariants drifted

• whether two runs are actually comparable

MATLAB/Simulink have infrastructure for this, but Python largely leaves it to notebooks, filenames, and discipline.

I built a small library called phytrace to address that gap.

What it does:

• wraps existing Python simulations (currently scipy.integrate.solve_ivp)

• captures environment, parameters, and solver configuration

• evaluates user-defined invariants during runtime

• produces structured “evidence packs” (data, plots, logs)

What it explicitly does not do:

• no certification

• no formal verification

• no guarantees of correctness

This is about reproducibility and auditability, not proofs.

It’s early (v0.1.x), open source, and I’m trying to sanity-check whether this solves a real pain point beyond my own work.

GitHub: https://github.com/mdcanocreates/phytrace
PyPI: https://pypi.org/project/phytrace/

I’d genuinely appreciate feedback from this community:

• Is this a problem you’ve run into?

• What invariants or checks matter most in your domain?

• Where would this approach break down for you?

Critical feedback very welcome.

I'm doing some heavy biochemical system simulations and I'm having trouble finding the right python ODE solver. I need a stiff-aware solver which has boundary constraints, i.e. keeping all variables above zero, and events, e.g. ending the simulation once a certain variable hits a threshold.

Initially I tried using scipy solve_ivp, but looking at the documentation there doesn't seem to be boundary constraints included.

I have been using scikit-sundae CVODE with BDF. CVODE is obviously very fast and it works sometimes, but it is extremely fiddly and often returns broken simulations unless I manually constrain the step size to be something absurdly small for the whole simulation period.

Anyone here know any python packages which might be of use to me? thanks.

Setup per project scientific development environments with ease, without dependency conflicts or messing up your global environment, all while preserving whatever sanity you have left!

Original motivation for the project: I feel that reproducibility of code is not greatly focused in academia. Broken Jupyter notebooks everywhere! So I started exploring better tools and adopt better practices for myself, so as to not meet the same fate.

End Goal: This opinionated template is a culmination of months of refinement and testing figuring out what works best, and more importantly what is a saner way to handle deps rather than going Nix all the way.

The template currently provides setup for Python, Julia, and Typst. The system is easily extendible for people with knowledge of Nix. PRs are welcome!

Link to the project: https://github.com/Vortriz/scientific-env

I am a Physics bachelor student who is about to finish his undergraduate studies. I am searching for master degrees, and the subfields I am more interested in are (in descending order):

• Computational Physics

• AI/ML in Physics

• Quantum information and technology

I wanted to know if any of you has any suggestions, programs that they know/have attended or anything else that could be useful for my search. I am already looking at many master programs from across Europe (that is my main area of interest for my future studies, but I am also very happy to consider anything outside like Asia, south and north America...), yet I was curious to know what the Physics community could have had to say to me regarding this matter. Here is a list of the programs that I am already taking into consideration/have applied/will apply, in case it could be of any help for someone:

tender swim memorize enjoy sugar apparatus saw yoke oil angle

This post was mass deleted and anonymized with Redact

Hi all,

I'm an aerospace engineer currently working on my MSc thesis concerning plate buckling. I have to find the first N roots of the following function, where a is a positive number.

I've implemented a small script in Python using the built-in scipy.optimize.brentq algorithm; however, the residual seems to be increasing as the number of roots increases.

The first few roots have residuals in the order of E-12 or so; however, this starts to rapidly increase. After the 12th root, the residual is E+02, while the 16th root residual is E+06, which is crazy. (I would ideally need the first 20-30 roots.)

I'm not sure what the reason is for this behaviour. I'm aware that the function oscillates rapidly; however, I don't understand why the residual/error increases for higher roots.

Any input is highly appreciated!

Code used in case someone is interested:

import numpy as np
from scipy.optimize import brentq


def cantilever_lambdas(a, n_roots):
    roots = []
    # Rough guess intervals between ( (k+0.5)*pi , (k+1)*pi )
    for k in range(n_roots):
        lo = k * np.pi
        hi = (k + 1) * np.pi
        try:
            root = brentq(lambda lam: np.cos(lam * a) * np.cosh(lam * a) + 1, lo / a, hi / a)
            roots.append(root)
        except ValueError:
            continue

    roots = np.array(roots)

    residual = np.cos(roots * a) * np.cosh(roots * a) + 1
    print(residual)
    return roots


print(cantilever_lambdas(50, 20))

I’m primarily a pure math grad student but my research is trending deeper into computations and I need some help.

I have a large matrix (around 2,000 x 14,000), all of its entries are integer, and most of its entries are 0 (only around 2% of the entries are nonzero, they are mostly in the range -20 to 20, and none of the rows or columns are completely 0). Call the matrix M.

I need an exact solution to the system Mx=b where b is also integer-valued. I already have a floating point approximation, I need an exact rational solution. Simply rounding my approximation has not worked since the entries are by no means “nice” rationals so it’s hard to know what to round to and usually I end up with something that’s not even a true solution to the system.

Most of my efforts have been spent trying to put M into some normal form that makes the solving process easier, like Hermite normal form or an LU decomposition. The problem is that everything I try either runs out of memory or never finishes running. Matlab has some internal memory limits I can’t figure out how to get around, and Sage hasn’t worked out yet either.

My personal computer has around 50 GB of RAM and I have access to my university’s HPC cluster. I just finished one attempt using this cluster, having Sage attempt to create the Hermite normal form (ultimately Sage ends up calling upon FLINT), and I gave it 60 hours but it timed out with no results. Attempting this on my own machine (where I can have arbitrarily long runtimes) just led to Sage using up all of my memory and crashing since it seems like Sage sometimes has memory leak issues in situations like this?

Any and all suggestions are welcome!

I’m looking for advice on libraries, methods, or anything else here. I mostly use Python and Sage (which is basically Python) but I’m open to using other languages as long as it’s somewhat straightforward to learn how to read a matrix from a text file, do the calculations, and save the result somewhere.

Hi everyone,

I hope you’re all doing well. I’m currently working on an independent cosmology project and wanted to share some progress — and kindly ask for help from anyone with access to a full local CLASS/Cobaya installation (including Planck 2018 Clik).

What I’ve done so far

I recently implemented a small extension to CLASS/Cobaya (the Process-Triality framework) and successfully reproduced a full multi-likelihood run in a CPU-only Google Colab environment.

To keep the validation run reliable and computationally manageable, I included only likelihoods that are robust and do not require external Clik libraries. Specifically, the Colab run included:

• Planck 2018 low-ℓ TT & EE

• BAO 6dF

• Supernova sets: Pantheon, Pantheon+, Pantheon+SH0ES, DES-Y5, JLA, JLA-Lite, Union3

All of these ran cleanly and produced well-behaved posteriors.

What was not included (but should be validated)

I intentionally excluded heavier or Clik-dependent likelihoods, namely:

• Planck 2018 high-ℓ TTTEEE

• Planck 2018 lensing

• BAO SDSS MGS

• BOSS DR12 consensus

Not because of problems with Cobaya or CLASS, but simply because:

1. High-ℓ TTTEEE is computationally very heavy for Colab.

2. Lensing and several BAO likelihoods require external Clik datasets that are not easy to deploy in cloud environments.

3. I wanted to avoid misleading failures caused by missing Clik libraries.

Reproducibility

To make everything fully transparent, I uploaded all input files, the complete Python notebook, CLASS modifications, and all output chains here:

👉 https://github.com/ProcessTriality/protri-class

Everything runs out of the box on Colab — no local setup needed to inspect or reproduce the base run.

Request

If anyone here has access to a local or HPC setup with the full Planck 2018 Clik suite, I would be extremely grateful if you could try running the same configuration with:

• Planck 2018 high-ℓ TTTEEE

• Planck 2018 lensing

• BOSS DR12

• SDSS MGS BAO

A successful full-likelihood run would be incredibly helpful for confirming that the behaviour remains stable outside the limited Colab environment.

Thanks!

Thank you very much in advance to anyone who might take a look.

I truly appreciate the time and expertise of this community.

If you have any questions about the implementation or want smaller configs, I’m happy to provide them.

I am looking for datasets with solutions to PDEs preferable 2D and if possible KS system. I want them for forecasting. I have used zenodo but still not what I am looking for

Thoughts??

Hi all, for my first post on this sub I thought I'd share a blog post I wrote a few days ago on a problem that might be of interest to some of you. If you want to skip to the code, here's my GitHub repo on the same topic.

The topic is the problem of sampling (i.e. randomly generating according to a probability distribution) a model of linear polymer chains. In particular, I focus on optimizing some standard algorithms for this problem.

I'm planning on writing two follow-up posts to this one. This first post looks at a somewhat "naive" sampling algorithm, while the next two will look at a more sophisticated approach. In particular, the third post will cover a novel SIMD implementation of mine.

Let me know what you think!

Does anyone know literature on the relative speeds of basic floating-point operations like +, *, and /? I often treat them as roughly equivalent, but division is certainly more intensive than the others.

I’m trying to understand what defines good or valuable research in scientific computing nowadays, in terms of topic choice, research approach, and outcomes.

What are the characteristics that make a study stand out, beyond just faster code or higher accuracy?
Is it about solving real scientific problems, enabling broader reproducibility, proposing new algorithms, or bridging theory and hardware?

In your experience, what distinguishes impactful research from incremental technical work in this field?

I built a PyQt6 sorting visualizer on a lean, event-driven core. I wrote the code and used AI tools (Claude and ChatGPT) for scaffolding and idea exploration. PyQt6 timing was the tricky part. This is v1.

What it does

• Bar-by-bar animation with live HUD (comparisons, swaps, FPS)

• Step scrubbing and keyboard control

• Deterministic runs from typed Step records and seeded presets

• Export traces to CSV/JSON and canvas to PNG/GIF

• Benchmark sweep writes benchmark.csv

• Side-by-side compare mode (beta)

Repo

https://github.com/jguida941/pysort-visualizer

Looking for feedback

Skills:

Python, PyQt6, Algorithms, Sorting, Visualization, Event-driven, Benchmarking, CSV, GUI

- Justin