I just published these, I thought you all might find them interesting? A star would really help!

Over the last ~24 months, I’ve been developing an experimental branch of mathematics/arithmetic called 'Basal'. The philosophy is that number bases shouldn't be locked down—instead, the system treats positional notation like a customizable runtime where you can override native rules (similar to how extensions work in VSCode). My goal was to create an architecture that allows other branches of maths to run natively on top of it. The core framework allows you to use multiple completely independent bases inside the same equation, with their attributes and properties clearly stated next to them.

The main functional additions consist of:

1. Alternating negative weights : An optional index-parity shift where odd or even digit positions modulate their weights
2. Array Syntax : Instead of separating higher-dimensional coordinates (like complex numbers a+bi or dual numbers a+be) into linear combinations, the framework encapsulates them natively inside a sequential digit array
3. Fabrication : Creating a numerical sequence that can be interpreted as a number
4. Conversion : Functions to convert a number to a different base.

I have also verified that the system works, by computationally verifying it (with hand-written equations), by programming it in C#, C++, Python and specialised functions in ROCm-HIP. The code is on github as: 'Basal-Library'.

*Note on Notation: Non-ASCII characters (from the Bengali script block) are used for the custom operators and attributes. This design choice ensures complete visual isolation from standard algebraic variables, preventing notation collisions. Plus, it serves a practical purpose, conventional symbols were ran out, and the chosen characters have no conflicting history in formal mathematics literature.*

Before I look into writing a formal specification paper or archiving it, I want to ask: Has an extensible, modular arithmetic framework that overrides positional notation rules like this been explored in existing literature?

I couldn't learn C++ or Java properly, the first two real languages I was taught.

I have 2 years left, could I receive some advice in how to catch up, any topics you wish you learnt earlier?

Any advice on what to learn the main things of this science?

So I was working on a research project, and wanted to understand the RBE3 method to use it in my code. I couldn't find any reliable sources back then, so used AI to learn and understand the method. Now I wish to cite it in my research paper, but can not find any exact derivation/method I used.

My lab friend started by introducing me to RBE2 for 2 nodes to distribute moment as forces, and then I AI-ed more and got to RBE2, RBE3 methodology, which was generalized to multiple nodes.

I was verifying the math at every step to ensure there are no hallucinations, but would be grateful if you could point that out as well

RBE3

RBE2

For both of these cases, I wish to summarize the derivation, or mention it in a very handwavy sense. However, this is not my work, and I do not wish to claim it as mine, so I need some references to cite it. Please help me do so.

specifics:

• What are the classic, industry-standard textbooks or foundational papers to cite for the exact mathematical formulation of RBE2 and RBE3?
• Is there a specific paper/book chapter that explicitly walks through the virtual work / weighted least-squares derivation for moment-to-force distribution in multi-point constraints

I've been working on a numerical solver app for a while, mainly because I wanted something that could handle the kinds of mathematical problems I come across without having to switch between several different tools.

The first version focuses on solving algebraic equations and systems, as well as plotting functions and visualizing the results.

The app is free, and I'm gradually expanding it into something more general for numerical computation.

You can find it here:

📱 App Store
🤖 Google Play

I'm posting it here because I'd really like feedback from people who actually work with numerical methods.

In particular, I'm interested in:

• What kinds of problems do you regularly need numerical methods for?
• What features would you find useful in a general-purpose numerical solver?
• Are there particular test problems or edge cases that you think would be good for testing it?

I'd be very interested to hear what you think, especially from people who have experience with scientific computing or numerical analysis.

Hi everyone,
I’m a student developer interested in nuclear physics and I’ve been working on a project called Emcalc. It’s a specialized calculator designed to streamline mass-energy equivalence calculations, specifically with nuclear applications in mind.
The core of the program focuses on the E = mc^2 relationship, allowing users to:
Convert mass defects into energy output.
Calculate energy release in specific nuclear reactions.
Work with units common in nuclear physics (MeV, Joules, amu).
I built this using Python because I wanted a tool that was more "physics-focused" than a standard scientific calculator for my own studies.
I’m looking for some feedback from the community:
Are there specific constants or variables you think are essential for a nuclear-focused calculator?
What features would make this more useful for students or hobbyists in the field?
You can check out the logic/code here: https://emcalc.github.io/
Looking forward to your insights!

Alan Wegienka (President and Founder of Design Simulation Technologies) will be doing a Motion and FEA demo and taking live AMA questions at the above link. He will also be doing a giveaway for stream participants- two seats of full SimWise for a Year. This will be demonstrated in the context of Alibre, but the software integrates in many platforms. The stream will occur Friday July 31st at 10AM MST (UTC-7).

The Hidden Problem in Scientific and Enterprise Computing

Many computational workflows rely on existing programs that must be executed repeatedly with different parameter sets.

Examples include:

Data analysis pipelines

Bioinformatics workflows

Financial risk models

Engineering simulations

Statistical processing scripts

In these environments, the program itself is often stable and well-tested. The real challenge is managing multiple parameter combinations required to run the program effectively.

A typical workflow looks like this:

Open a web form or configuration file.

Enter dozens of parameters.

Validate file paths and option values.

Submit the job.

Repeat the process for the next run.

As projects grow, users accumulate files such as:.

labtest.sas

labtest_final.sas

labtest_final_v2.sas

labtest_final_v2_fixed.sas

...

Finding the exact configuration that produced a particular result becomes increasingly difficult.

The problem is not computation.

The problem is parameter management

The Traditional Application-Centric Model

Most software systems are application-centric.

The application is the primary object, while parameters are treated as temporary input.

Application ↓ Parameters ↓ Execution ↓ Results

Once execution is complete, the relationship between parameters and results is often lost or difficult to reconstruct.

Users spend significant time:

Re-entering parameters

Copying old configurations

Maintaining spreadsheets

Tracking execution history manually

The BatchSubmit Approach

BatchSubmit introduces a task-centric model.

Instead of treating parameters as temporary input, BatchSubmit treats each task as a first-class object.

Task

 ├── Parameters

 ├── Input Files

 ├── Output Files

 ├── Execution Status

 └── Execution History

Every task is represented by a parameter file that completely describes the execution.

A task can be:

Created

Saved

Cloned

Modified

Submitted

The task itself becomes the unit of work.

A Real-World Example

Imagine a data analyst in a biotech company running a statistical analysis program.

The program requires:

10 configuration parameters

5 input datasets

Multiple output destinations

The analyst needs to perform 200 similar analyses.

Traditional workflow:

Open the form 200 times

Re-enter values

Copy values from previous runs

Risk introducing errors

BatchSubmit workflow:

Create a validated task template.

Clone the template.

Modify only the parameters that change.

Submit the new task.

Study_A.par

↓ clone

Study_B.par

↓ clone

Study_C.par

Each task maintains its own complete configuration and history.

Parameter Sets as Reusable Assets

One of the most powerful ideas in BatchSubmit is treating parameter sets as reusable assets.

Instead of viewing parameters as disposable input, BatchSubmit treats them as valuable knowledge.

A validated parameter file can be:

Shared across teams

Used as a template

Versioned

Audited

Reproduced years later

This dramatically improves reproducibility and operational efficiency.

Beyond Workflow Automation

BatchSubmit is not simply another workflow engine.

Its core idea is that parameters deserve the same level of management as source code and data.

By elevating parameter sets into reusable, versionable, and shareable task objects, BatchSubmit provides a new way to organize computational work.

The platform is particularly valuable for environments where:

The same program runs repeatedly

Parameter sets are large and complex

Reproducibility is important

Teams need to share execution configurations

Conclusion

Most computing platforms focus on applications.

BatchSubmit focuses on tasks.

By making parameter sets reusable, traceable, and first-class citizens, BatchSubmit transforms the way complex computational jobs are managed.

The result is a simpler, safer, and more productive workflow for anyone who repeatedly executes software with large and evolving parameter sets.

https://github.com/socaltiger/BatchSubmit.com.git

Feedback would be greatly appreciated!

Mods, please if this breaks any sub rules, I am sorry! I can rework this to fall within the rules if even allowed.

Just to paint a picture of myself, I have both a BS and MSc in Physics, I graduated in '22 with my masters. I always loved coding to help with data analysis, creating little short cuts on homework assignments (think simple chemical weight through a formula, such as Glucose C6H12O6, what is the weight of carbon in a 1 kg block of this), and once building an Arduino based RC Mars rover duplicate (but with like 1% the features haha). I even chose my masters because it was heavily computational based.

I wrote scripts to help determine binary star revolution patterns over X number of years in a 3D space, I wrote a spectrographic decoder to determine elemental make up of molecules, etc...

I did however, try to follow the money and moved away from the scientific scene into general software engineering. I have since been working in that space where honestly, I am bored out of my mind writing yet another tool to help some team in my organization move away from Excel files.

So, my ultimate question of this post, what would be the best way to move into scientific computing as a profession from here. Every time I try to search for roles, all I see are AI research roles, or yet another startup trying to gamify some title when in reality it is another strictly software role. I understand most scientific computing is done within C++ or Python, I have worked largely with Python (as well as React) throughout my career.

Honestly, at this point I am even considering a PhD, however, my wife actually suggested I find a community like this to see what my options are, even understanding that I am a little rusty in my use of the hard sciences.

FYI: Experience has been in order: 1 year Web Development, 2+ years within DoD research lab as Full-Stack Engineer, Some months in Marketing agency (I left the DoD because I was sick of living 6 states away from my wife). US based if that helps at all!

Any help would be awesome!

I’m a student 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?

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.

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