quantdev.blog

This blog is a no-fluff collection of C++ code snippets, tips, puzzles and C++ projects. Here, I have also documented my deep-dives on concurrency, performance and computer architecture topics.

Container	`std::array`	`std::vector`	`std::list`
Low-level implementation	Fixed capacity array.	A contiguous array that can grow in capacity dynamically.	Doubly…

Categories

A CRTP Wrapper for overloading arithmetic operators

Linkers, Loaders and Shared Libraries

Setting up a modern C++ dev environment

Implementing std::visit

The Visitor pattern and multiple dispatch

Implementing std::variant

Implementing std::string

The differences between std::make_tuple, std::tie and std::forward_as_tuple

C++ 26 Reflections

Different ways to write a filter function

Runtime complexity cheatsheet

Constructing a 3D Array

Coding Exercise - Grouping lines together

const, constexpr, consteval and constinit

Hash Tables

Move semantics and perfect forwarding

Using std::variant

Storage Duration and Linkage in C++

auto type deduction rules

C++ Type erasure

Implementing LRU Cache

Header files and translation units

How libstdc++ std::unordered_map is implemented?

Implementing std::vector

Lambda Functions

Floating-point numbers

Objects, Pointers and References

The C++ casts

Lock-free SPSC Queue

Pymalloc - Down the rabit hole

Generators, iterators and asynchronous programming

Pythonic code

Creating a tiny C++ Task Library

A crash course in Rust - I

Memory Barriers

Coroutines

AAD(Adjoint Algorithmic Differentiation)

Uniformly sampling from the unit disk

Gaussian Processes

A short note on the Dupire PDE

Challenging exercises in Template Metaprogramming

deducing this

The virtual keyword

Quanto Options

Custom iterators and Iterator concepts

A note on make_shared<T>(Args&&...) and make_unique<T>(Args&&...)

Implementing std::shared_ptr

Implementing std::unique_ptr

numpy and pandas CheatSheet

DIY asyncio

A thread-safe queue implementation

Thread-Safe Stack Implementation

Margrabe’s formula

Levenberg-Marquardt Algorithm

C++ Ranges

Collateralized Discounting

IRS, Caps, Floors and Swaptions

CRTP(Curiously recurring template pattern)

Rule of Five

Currying and partial function application

Copy-and-swap idiom

SFINAE

C++20 concepts

A gentle introduction to the Girsanov Theorem - Back to the basics

Fun with numeraires!

Class Template Argument Deduction(CTAD)

Type Traits 101

Tridiagonal Systems

Interpolation and Approximation

Numerical Integration

Template programming

Norms

Singular Value Decomposition(SVD)

Eigenthingies and Diagonalizability

The Spectral Theorem

Ito Calculus

Martingales

The Markov Property

Ito Processes and Stochastic Differential Equations

Implementing `std::visit`

Implementing `std::variant`

Implementing `std::string`

The differences between `std::make_tuple`, `std::tie` and `std::forward_as_tuple`

`const`, `constexpr`, `consteval` and `constinit`

Using `std::variant`

`auto` type deduction rules

How libstdc++ `std::unordered_map` is implemented?

Implementing `std::vector`

deducing `this`

The `virtual` keyword

A note on `make_shared<T>(Args&&...)` and `make_unique<T>(Args&&...)`

Implementing `std::shared_ptr`

Implementing `std::unique_ptr`

`numpy` and `pandas` CheatSheet