Complete C++ Scientific Programming Bundle - 21 Hours!

Explore the struct versus class distinction in C++, where struct has public data by default and class has private; use struct for data containers and class for encapsulated objects.

Explore how streams format and transmit data in c++ using ostream and cout, practice with manipulators for hex, octal, precision, and showbase, and leverage file streams and stream buffers.

Explore C++ string manipulation: constructors, capacity management (reserve, shrink_to_fit, resize), element access (at, operator[], front, back), modification (assign, append, insert, replace, erase, push_back, pop_back), and common string algorithms.

Explore the C++11 initialization features, including initialize a list, initialize list constructors for containers, aggregate and uniform initialization, and auto type inference with for-each style vector traversal.

Learn how rvalue references enable move semantics and perfect forwarding to avoid costly copies, with move constructors, universal references, and efficient overloading.

Explore shared, weak, and unique pointers in C++: manage ownership, prevent memory leaks and cyclic references with weak pointers, use make_shared and custom deleters, and safely transfer or release ownership.

Manage resources in C++ using copy constructors, copy assignment operators, and the delete keyword. Construct in place with emplace back and use shared_ptr or unique_ptr for ownership and move semantics.

Explore regular expressions and their grammar with the C++11 standard library. Learn to match and search text, use case-insensitive flags, groups, and anchors.

Explore the Crono library in C++11 for precision-neutral time and date handling, comparing system, steady, and high-resolution clocks, and mastering durations and time points.

Explore C++ random numbers with a random engine's internal state, seeds, and distributions—uniform, integer, real, Poisson, and normal—plus using them to shuffle vectors.

Explore how tuples extend pairs to hold multiple values of different types, and learn to create, access, modify, compare, and concatenate tuples using make_tuple, get, tie, and tuple_cat.

Learn const correctness in C++ by examining when data and pointers are immutable at compile time, and how const parameters, return values, and mutable members shape design.

Learn operator overloading for assignments in C++, focusing on self-assignment and exception-safe copying. Explore the initialization fiasco and apply the singleton design pattern for initialization on first use.

Explore implicit and explicit type conversions in C++, including standard and user defined conversions, and master safe casting with static_cast, dynamic_cast, const_cast, reinterpret_cast, and the C++ style casts.

Examine public, protected, and private inheritance, their access rules, and the tradeoffs between inheritance and composition, including virtual inheritance and pure abstract interfaces.

Explore how operator new and operator delete allocate and free memory, overload them for dog and yellow dog, and the role of set new handler and virtual destructors.

Examine std::vector, deque, and list as sequence containers, and map and multimap as associative containers; learn iterators, algorithms, and performance tradeoffs like contiguous memory, cache locality, and splice operations.

Explore associative containers like set and map, learn their sorted, logarithmic insert and search, understand unique vs duplicate keys, immutability of elements, and using insert hints to optimize placement.

Explore unordered associative containers, including set and map, and learn how hash tables store elements in buckets for constant-time lookups, with awareness of collisions and iterator validity.

Explore the five iterator categories in the C++ STL—random access, bidirectional, forward, input, and output—along with iterator adapters like insert and reverse, and using algorithms to operate on ranges.

Explore how function objects, or functors, extend regular functions by maintaining state, enabling parameterized behavior, and powering flexible algorithms with bind, transforms, and custom comparators.

Explore the C++ STL non-modifying algorithms, including count, count_if, max_element, min_element, and minmax_element, plus find, search, and adjacent_find with iterators, and their simplified and generalized forms.

Explore how the STL modifying algorithms change values and order, including copy, move, transform, swap, fill, remove, unique, reverse, rotate, permute, and shuffle.

Learn C++ STL sorting and searching, including custom comparators, partial sorts and heaps, binary search tools, merge operations, set operations, and numeric algorithms like accumulate.

Explore how reverse iterators work in the standard template library, convert to regular iterators with base, and print a vector in reverse, while noting iterator invalidation.

Explore removing elements from containers using the STL, focusing on vector and list techniques and erase-remove idiom. Understand iterator invalidation and removal for associative containers with algorithm-based and lambda-based removal.

Compare vector and deque in c++, detailing growth, reallocation, and usage rules: push front prefers deque; use vector for contiguous memory; consider data type, memory constraints, and pointer validity.

Explore object slicing in C++ when pushing derived objects by value, and learn to prevent it by using pointers and virtual functions.

Boost lexical_cast provides a safe, convenient and efficient way to convert between strings and types. It uses a single function name, supports int-to-string and string-to-int, and throws bad_lexical_cast on errors.

Discover how boost variant replaces unions in C++ to store int or string safely, use get and bad get exceptions, and apply visitors to operate on a vector of variants.

Explore how boost optional signals valid versus invalid data by returning an initialized optional with the last queue item or an empty optional when the queue is empty.

Master boost arrays in c++ within the complete c++ scientific programming bundle, covering practical techniques for efficient data handling in scientific computing.

Learn to build graphs with the bushcraft adjacency list and attach vertex and edge properties. Use property maps to access these properties for algorithms like Dijkstra shortest path.

Compare multiprocessing and multithreading, noting lightweight threads and fast shared memory communication. Manage thread lifecycle with join and detach, ensure exception safety, and pass parameters safely.

Understand how race conditions emerge when threads compete for a shared resource. Use mutexes and lock guards to synchronize access, protect output, and prevent data races.

Learn how to use std::async, futures and promises to pass results between threads, replacing manual mutexes and condition variables, and leverage shared_future for broadcasting results.

Learn how to package a factorial task into a packaged task, bind its parameter with a function object, and retrieve the result via a future in multi-threading.

Explore adding time constraints to threads with the chrono library, and master thread creation, mutex synchronization via unique_lock, condition_variable, and futures through promise, future, async, and packaged_task.

Learn how OpenMP enables simple parallelization on multi-core systems, distinguish concurrent from true parallelism, and use a pragma to run code across multiple threads.

Learn to parallelize for loops in c++ openmp with pragma omp parallel for, use the reduction clause for safe collective updates, and apply collapse for nested loops and single-command optimizations.

Understand OpenMP scheduling with static and dynamic strategies, chunk sizing, and how a work pool assigns iterations to threads, influencing total runtime when workloads are uneven.

Learn how OpenMP handles data sharing before parallel regions, distinguishing shared and private data, and use firstprivate, lastprivate, default clauses and reduction to prevent race conditions and enable safe parallelization.

Explore OpenMP, a portable API for shared-memory parallel programming in C, C++, and Fortran, by building a basic hello world program that runs on multiple threads.

Discover how MPI enables distributing data across cluster servers to parallelize programs and speed up execution. Learn that MPI is a free, no-cost message passing interface API accessible to beginners.

Explore how MPI enables distributed memory parallelism through MPI_Init, MPI_Finalize, and using MPI_Comm_size and MPI_Comm_rank on the world communicator to determine process count and rank.

Submit an MPI job to a high-performance computing system and run a hello world on four nodes, using Intel MPI or Open MPI, and view per-node outputs.

Explore MPI send and receive primitives, using buffers, counts, data types, tags, and communicators to exchange values between processes, illustrated with a ring round-robin example and status checks.

Learn MPI simultaneous send and receive in C++, including buffer setup, data type, destination, tag, status, and a ring pattern, then introduce collective communication and broadcast.

Explore a rank-aware debug utility using variadic arguments and the underlying printf mechanism, and learn MPI collective operations like broadcast and barrier to synchronize all processes.

Explore non-blocking MPI communication that overlaps computation with sending and receiving data. Learn to use MPI_Isend and MPI_Irecv with MPI_Test or MPI_Wait, managing MPI_Request to reuse buffers after completion.

Overlay a two-dimensional Cartesian topology on an MPI communicator to map ranks to grid coordinates and use cart rank, cart coords, and cart shift for neighbor communication.

Explore how the gpu's parallel throughput powers data-parallel computations beyond cpu, and how kernels launch thousands of threads organized into grids, blocks, and threads on host-device systems via pci express.

Gain insight into the CUDA programming model by managing host and device memory, launching kernels with configurable grid and block dimensions, and transferring data between host and device.

Learn the kernel definition syntax with the global declaration to run on the device. Kernels return no value, use void, and threadIdx.x enables parallel indexing for operations like vector addition.

Learn how to compute a thread’s unique global index in a CUDA grid by combining blockIdx.x, blockDim.x, and threadIdx.x, with grid dimensions in x, y, and z.

Prevent race conditions by synchronizing threads with barriers in CUDA kernels, manage memory reads and writes safely, and use cudaDeviceSynchronize for host-device coordination with implicit barriers between kernel launches.

Learn to implement a CUDA vector addition using unified memory, launch a kernel with proper grid and block sizes, handle padding for non power-of-two inputs, and verify results.

Explore eigenvectors and eigenvalues using Intel MKL, with practical steps and examples, and see applications in stability analysis, vibration analysis, facial recognition, and computer vision.

Learn to manage HPC software modules to set up software environments and run jobs on a system using module load, unload, and list commands.

Learn to write a PBS job script from a bash script using '#PBS' comments to request wall time, resources, and memory, then run your HPC commands.

Learn to write a Slurm job script named hybrid, requesting five minutes, four nodes, ten CPUs, one GB memory, loading Intel MPI and MPLX, and submit via sbatch.