BLIT: High-Performance Linear Solver for FEA, DOT, Electromagnetism & Acoustics

I built a 2D magnetotelluric modelling code from scratch using only AI [1]. From an empty folder, it took me five hours to create a fully functional, parallelised C++ code with a Python front end and tests. I did not write a single line of the code myself. Below are a few details and thoughts. Do you have any experience yourself? Limitations: - You need software engineering knowledge to guide the agent. It goes astray without sequential guidance, context prompts, and splitting the problem into smaller blocks. - Domain-specific expertise is crucial. The AI agent made a few subtle mistakes (mixing TE and TM modes), which only an expert in the field would spot.  - It strugles if you want to go beyond common knowledge in the field. Pros: - Fully eliminates the hassle of dealing with technical and low-level aspects by creating a container, configuring tests, managing the repository, and building the CI/CD infrastructure efficiently.  - It acts logically, proposes a reasonable development plan before acting, and creates a good code architecture (probably much better than most non-professional developers). - Feels like a natural iterative process that converges to the result one has in mind. In summary, it is an impressive and very powerful technology. Those who will greatly benefit from adopting it are domain experts with solid skills and a clear vision in their field. This technology will accelerate your progress and shorten your journey to the cutting edge by taking many routine tasks off your hands. It will not (yet!) help go beyond the frontier or come up with new creative ideas. Environment: VSCode + Cline + Codex.  Software stack: Ubuntu, C++, MPI, PETSc, and deal.II -- exactly the tools I have used for a decade to write my GoFEM EM modelling and inversion code. [1] https://lnkd.in/dpyn_4j4

I’m happy to share #pySLAM v2.10.0 🎉  This is a major update that moves the project forward on multiple fronts: • Runtime performance • Semantic segmentation tightly integrated with volumetric mapping • 3D scene inference pySLAM is now a hybrid Python/C++ Visual SLAM framework supporting monocular, stereo, and RGB-D pipelines, bringing together local features, loop closing, dense mapping, depth prediction, and semantic understanding in a single environment. 📌 New modular C++ SLAM core This release introduces a modular sparse SLAM core implemented in both Python and C++, exposed via pybind11. You’re free to use either implementation interchangeably: maps saved by one can be loaded and continued by the other. The key outcome is simple: run the full pipeline at the native tempo of standard datasets with the C++ core, while retaining the original Python core where it shines - configuration, integration, and rapid iteration. 📌  Expanded semantic segmentation and semantic volumetric mapping v2.10.0 significantly extends semantic segmentation support, integrating modern models such as #YOLO, #RFDETR, #DETIC, #ODISE, and #EOV_SEG directly into the SLAM pipeline. Semantic predictions are incrementally fused into volumetric map representations, enabling: • Semantic voxel grids with class-aware color maps • 3D object-level segmentation inside volumetric reconstructions • Joint reasoning over geometry, appearance, and semantics in 3D Semantic information is now a first-class component of both sparse and volumetric maps. 📌 New end-to-end multi-view 3D scene inference pipeline v2.10.0 adds a unified and modular pipeline for end-to-end inference of 3D scenes from multiple images, with support for: #DUSt3R / #Mast3r / #MV_DUSt3R, #VGGT (and #Robust_VGGT), #DepthFromAnythingV3, and #Fast3R. 📌 Plus: datasets, depth models, and visualization The release also includes upgrades across volumetric reconstruction, depth prediction models, dataset support, #ROS1 / #ROS2 handling (including a new #MCAP player), and visualization tools. 🔗 Repo: https://lnkd.in/dzqCmQA #OpenSource #AI #SLAM #VisualSLAM #ComputerVision #Robotics #3DVision #NeuralRendering #3DReconstruction #MultiViewGeometry #Cplusplus #Python #SemanticSLAM #3DMapping #SceneUnderstanding

What is MATLAB? How it really works. Where to use it. Where not to. Most people say: “I know MATLAB.” What they mean is: They know how to type plot() and mean(). That’s not MATLAB. What MATLAB Actually Is MATLAB is not just a programming language. It is a numerical computation engine built around matrices. Everything inside it is a matrix. x = 4 Is stored as: 1×1 double 64-bit floating point 8 bytes in memory MATLAB was built by MathWorks to remove the pain of writing low-level mathematical code in C or Fortran. Under the hood: • You write a command • It gets parsed • JIT compiler optimizes it • BLAS / LAPACK numerical libraries execute it • Results stored in memory • Graphics engine renders it It is an optimized mathematical machine. Where MATLAB Dominates in Data Use MATLAB when: • Data is signal-based (ECG, RF, vibration, audio) • Heavy matrix operations are required • You need numerical stability • You are doing scientific computing • You are modelling systems • You need fast prototyping for engineering problems MATLAB shines in: • Signal processing • FFT and filtering • Statistical modelling • Control systems • Simulation • Research environments If your data problem is mathematical at its core, MATLAB feels natural. Where NOT to Use MATLAB Do NOT use MATLAB when: • You are building web apps • You are deploying scalable AI products • You need distributed big data pipelines • You are doing startup SaaS • Budget matters heavily For production systems → Python wins. For distributed data → Spark + cloud tools win. MATLAB is not built for mass-scale backend deployment. The Real Difference Most users know: How to call functions. Very few understand: • Floating point precision • Matrix memory layout • Numerical errors • Algorithm complexity • Stability conditions Knowing commands is not power. Understanding computation is. My View Use MATLAB to sharpen: Your mathematical thinking Your signal intelligence Your simulation mindset Use Python to build products. Different tools. Different layers. If you understand both — you shine -|(0XDL01) Nabharaj #MATLAB #NumericalComputing #SignalProcessing #EngineeringMindset #DataScience #SystemThinking

The next step in the AI journey -> Learn how the MATLAB MCP Core Server and a few well-crafted prompts, you can go from analysis to a beautifully documented GitHub repository in minutes https://spr.ly/6045hdmdb

🔢 New Launch: Power Set Calculator – Python Desktop App Excited to share a new combinatorics-focused project — a Power Set Calculator Desktop Application built using Python. This tool transforms a fundamental concept from discrete mathematics into a fully interactive desktop application. 📌 What It Does ✔ Accepts user-defined set elements ✔ Automatically removes duplicates ✔ Generates the complete power set ✔ Calculates total subsets (2ⁿ formula) ✔ Displays results in a structured GUI 🧠 The Mathematics Behind It For a set containing n elements, the size of the power set is: ∣P(S)∣=2n|P(S)| = 2^n∣P(S)∣=2nWhat starts as a simple formula quickly becomes computationally intensive as n increases. This application efficiently generates all subsets using combinatorial logic. 💻 Technical Stack Python Tkinter (Desktop GUI) itertools (Combinations engine) 🎓 Why This Project Matters Power sets are foundational in: Discrete Mathematics Algorithm design Bitmasking techniques Backtracking problems State-space modeling This project demonstrates how theoretical math concepts can be translated into practical, user-facing software. If you're interested in: Algorithmic problem solving Mathematical computing Python desktop development Educational software tools Let’s connect and discuss. #Python #DiscreteMathematics #Algorithms #SoftwareDevelopment #ComputerScience #PortfolioProject https://lnkd.in/ggyvk_CS https://lnkd.in/gE6qxU-v

I wasted 9 months learning stochastic calculus the wrong way. Here’s what they don’t tell you about quant interviews The interviewer asked me: “Simulate 10,000 paths of geometric Brownian motion. Now.” I froze. I knew the theory: ✓ Itô’s Lemma? Check. ✓ Girsanov’s Theorem? Memorized. ✓ Black–Scholes derivation? Could do it in my sleep. But I couldn’t write one line of working code. That’s when it clicked: The quant finance education system is broken. We train students to: → Prove theorems → Memorize formulas → Grind problem sets But not to: → Simulate processes → Debug implementations → Build real pricing engines It’s like teaching someone to drive using only a physics textbook. After that disaster, I spent 6 months building what should’ve existed in the first place: The Stochastic Calculus Visual Lab 20 interactive Jupyter notebooks where you don’t just read about: • Brownian motion → You generate 10,000 paths and watch them evolve • Itô’s Lemma → You verify what breaks when you ignore the convexity term • Delta hedging → You simulate a full replication strategy and watch P&L converge Every. Single. Formula. Becomes. A. Simulation. what makes this different: Textbooks: “The quadratic variation of dW is dt (proof omitted)” This Lab: slider widget “Change dt from 0.1 to 0.001 and watch convergence happen.” Courses: “Heston model generates volatility smile” This Lab: interactive plot “Adjust kappa and watch the smile morph in real time.” Theory: “Euler–Maruyama has strong order 0.5” This Lab: log–log convergence plot “See the 0.5 slope emerge from your simulation.” This is for you if: You’re preparing for quant interviews (dev or trading) You understand theory but freeze at “okay, now code this” You’re tired of “implementation left as an exercise” You learn by doing, not passive reading What’s inside: 17 Pro Modules Module 0: Brownian motion from scratch Module 5: Itô’s Lemma verification suite Module 7: Black–Scholes via Monte Carlo Module 13: Delta hedging simulator (my favorite) Module 16: Full Heston stochastic volatility model 170 Hands-On Exercises Not multiple choice. Not “prove theorem X Real coding challenges. Interactive Widgets Sliders, buttons, real-time plots Parameter exploration like a sandbox Visual intuition before full rigor Zero to Hero Path Beginner-friendly → Interview-ready 2–4 weeks at your own pace The honest truth: This won’t replace Shreve or Joshi. It’s the missing link between them and getting hired. Theory → Simulation → Intuition → Interview Success That’s the real learning path. Link: https://lnkd.in/d7gS23FH Early Bird Launch: ₹599 ( < $8) → Cheaper than one hour of tutoring → Lifetime access to all updates → Full Python implementation of every concept code: SLAB10 for 10% off #quantfinance #stochasticcalculus #quantinterviews #python #jupyternotebooks #derivatives #financialengineering #blackscholes #hestonmodel #finance

⚙️ From Analysis to Documentation — Automatically Learn how the MATLAB MCP Core Server can turn your analysis workflow into a fully documented, ready‑to‑share GitHub repository in minutes. With just a few well‑crafted prompts, agentic automation takes care of structure, formatting, and consistency so you can stay focused on engineering. 🤖 ✅ Generate clean, consistent documentation directly from your MATLAB analysis ✅ Automate repo creation, structure, and content population ✅ Use prompt‑driven workflows to accelerate reporting and sharing ✅ Move from exploration to publish‑ready output in minutes 👉 See how agentic automation can streamline your documentation workflow. 📎 https://spr.ly/6045hTbdB #AgenticAI #EngineeringProductivity #MATLAB #Automation #MathWorks

New Launch: Set Membership Tester – Python Desktop App Excited to share another logic-driven project — a Set Membership Tester Desktop Application built using Python. This application transforms a fundamental concept from discrete mathematics into an interactive, real-world software tool. 📌 What It Does ✔ Accepts a user-defined set (comma-separated values) ✔ Automatically removes duplicates ✔ Tests whether an element belongs to the set ✔ Displays clear mathematical results ( ∈ or ∉ ) ✔ Provides instant lookup using efficient data structures 🧠 The Concept Behind It In set theory: x∈Sx \in Sx∈Smeans x is an element of set S. Under the hood, this app uses Python’s hash-based set structure, enabling O(1) average time complexity for membership testing. That same principle powers: Database filtering systems Access control mechanisms Search optimization algorithms Spam detection filters Data validation engines 💻 Tech Stack Python Tkinter (GUI) Native set data structures 🎯 Why This Project Matters This project demonstrates: Applied discrete mathematics Efficient algorithm design Hash table fundamentals GUI-based desktop development Translating theory into practical tools Simple concept. Strong computational foundation. If you're interested in: Mathematical computing Algorithm design Python desktop applications Educational software tools Let’s connect and exchange ideas. #Python #DiscreteMathematics #Algorithms #SoftwareDevelopment #ComputerScience #DataStructures #PortfolioProject https://lnkd.in/gn4dpWVY https://lnkd.in/gKSJsdnb

Matlab Code 3 % --- Signal Parameters --- Fs = 1000;                        % Sampling frequency T = 0:1/fs:1-1/fs;                % Time vector Signal = sin(2*pi*50*t);         % Pure sine wave (50 Hz) Noise = 0.5 * randn(size(t));    % Additive white Gaussian noise Received = signal + noise;       % Noisy signal % --- Time Domain SNR --- Signal_power = mean(signal.^2); Noise_power_time = mean((received – signal).^2); Snr_time = 10 * log10(signal_power / noise_power_time); % --- Frequency Domain SNR --- N = length(t); F_signal = abs(fft(signal)); F_received = abs(fft(received)); F_noise = abs(f_received – f_signal); Signal_power_freq = sum(f_signal.^2)/N; Noise_power_freq = sum(f_noise.^2)/N; Snr_freq = 10 * log10(signal_power_freq / noise_power_freq); % --- Plot Time Domain --- Subplot(2,1,1); Plot(t, received, ‘b’); hold on; Plot(t, signal, ‘r—‘); Legend(‘Noisy Signal’,’Original Signal’); Xlabel(‘Time (s)’); Ylabel(‘Amplitude’); Title([‘Time Domain Signal – SNR = ‘ num2str(snr_time, ‘%.2f’) ‘ dB’]); % --- Plot Frequency Domain --- F = (0:N-1)*(fs/N); Subplot(2,1,2);plot(f, abs(fft(received)), ‘b’); hold on; Plot(f, abs(fft(signal)), ‘r—‘); Legend(‘Noisy Spectrum’,’Original Spectrum’); Xlabel(‘Frequency (Hz)’); Ylabel(‘|FFT|’); Title([‘Frequency Domain – SNR = ‘ num2str(snr_freq, ‘%.2f’) ‘ dB’]);

✅ Now available: Manufacturing Toolkit 2026.1 💡 The new version introduces unified MTKCore naming, Workbench and projector improvements, Wall Thickness visualization improvements, and more. 🚀 Highlights: • Renamed binaries from CadExMTK to MTKCore; corresponding packages and wrappers are also renamed. • Improved Poly Projector algorithm performance (up to 5x faster) and extended the API to return projection regions as polylines or mesh. • Fixed missing normals in meshes generated from solids, ensuring that the MTKConverter Wall Thickness process now exports normals to MTKWEB. • Removed support for Python 3.7, 3.8 and 3.9; supported Python versions are now 3.10-3.13. ⚙️General:       • Renamed binaries from CadExMTK to MTKCore following the CMake package rename from CadEx::MTK to MTK::Core.       • Updated all language wrappers to use the new package/binary naming:         - Python: manufacturingtoolkit.CadExMTK to manufacturingtoolkit.MTKCore         - C#: CadExMTKNet.dll to MTKCoreNet.dll         - Java: CadExMTKJava.jar to MTKCoreJava.jar       • Removed support for Python 3.7, 3.8 and 3.9; Supported Python versions are now 3.10-3.13.     📐Projector:       • Projector_PolyData was replaced with Projector_Projection, which provides the new projection API.       • Added Projector_ProjectionContour to describe a contour (outer or inner) of a projection region.       • Added Projector_ProjectionRegion class that represents a continuous projection region (typically a solid projection) with one outer contour and zero or more inner contours.       • Projection regions as polylines or mesh can now be accessed via Projector_Projection::ProjectionRegionList().       • Improved Poly Projector algorithm performance (up to 5x faster on large models).     🔍 Examples:       • Updated MTKConverter example for Wall Thickness process to export normals to MTKWEB for meshes generated from solids.       • Fixed an issue in the MTK Converter example where the Wall Thickness process did not handle mesh-only models (STL files).       • Updated C#/Java/Python MTKConverter examples for Wall Thickness process to generate the data required for MTK Web visualization.       • Updated Poly Projector example to match the new Projector_Projection API.     🖥️  Workbench:       • Added Shaded Without Boundaries display mode.       • Reworked Turning Face grouping so faces are now grouped by their actual Machining_FaceType.     📖 Documentation:       • Fixed an issue where some API descriptions were not shown in the Python documentation. 👉  Learn all the details of the new release in our blog post: https://lnkd.in/dGnBP84y #SoftwareRelease #ProjectionAPI #MaaSPlatforms #DFM #CADTools