AI powered jupyter notebook.
Github

Rye: a Hassle-Free Python Experience

Rye is a comprehensive project and package management solution for Python. Born from its creator's desire to establish a one-stop-shop for all Python users, Rye provides a unified experience to install and manages Python installations, pyproject.toml based projects, dependencies and virtualenvs seamlessly. It's designed to accommodate complex projects, monorepos and to facilitate global tool installations.

Introduction video

This one looks good for a weekend

The 5 most important points explicitly mentioned in the document are:

1. Start doing research early: Begin research even if you don't know everything, as learning along the way is effective.

2. Engage with challenging areas: Pursue fields that may seem messy or unclear, as they offer opportunities for creative work.

3. Forgive yourself for wasting time: Recognize that in the real world, it's hard to identify which problems are important or solvable at a given time.

4. Dive into uncharted territories: Exploring unclear areas of science can lead to creativity and significant discoveries.

5. Learn the history of science: Understanding the history of science can provide context, make your work more meaningful, and help avoid oversimplified models of science.

CS229 Lecture Notes Andrew Ng and Tengyu Ma April 30, 2023

Still working on it, including Python scripts to reproduce some of the figures in the book.
GitHub

یه جلسه همخوانی برای مطالعه این کتاب برقراره و تا سه شنبه ۱۵ مرداد مهلت ثبت نام داره.
ویدیو جلسات هم ظبط میشه.
https://t.me/SystemBiologystudygroup

Kalimba note converter
Keep the punctuatuion unchanged.

https://datacamp.com/freeweek
DataCamp temporary free access.

GPU monitor

pip install nvitop

GitHub

Related posts:
https://t.me/scientific_programming/653

Panda methods
https://xmind.ai/share/ugVH30g4

# C++ Data Structures

(Landscape view shows better)
A detailed map of C++ data structures based on the latest updates, including both standard data structures from the Standard Template Library (STL) and newer features introduced in C++17, C++20, and C++23.

## 1. Primitive Data Types

- int
- char
- float
- double
- bool
- wchar_t (wide character type)
- char16_t, char32_t (introduced in C++11 for UTF-16 and UTF-32 encoding)

## 2. Compound Data Types

### Arrays

- Static: int arr[10];
- Dynamic: int* arr = new int[10];

### Pointers

- int* ptr;
- std::unique_ptr, std::shared_ptr, std::weak_ptr (introduced in C++11 for smart pointers)

### References

- int& ref = x;

## 3. Standard Containers (STL)

### Sequence Containers

- std::array (fixed-size array, introduced in C++11)
- std::vector (dynamic array)
- std::deque (double-ended queue)
- std::list (doubly linked list)
- std::forward_list (singly linked list, introduced in C++11)

### Container Adaptors

- std::stack (LIFO data structure, built on top of other containers)
- std::queue (FIFO data structure)
- std::priority_queue (heap data structure)

### Associative Containers

- std::set (ordered set)
- std::multiset (allows duplicate elements)
- std::map (key-value pairs, ordered by keys)
- std::multimap (allows duplicate keys)

### Unordered Containers (introduced in C++11)

- std::unordered_set (hash table-based set)
- std::unordered_multiset
- std::unordered_map (hash table-based key-value pairs)
- std::unordered_multimap

## 4. String Handling

### Basic Strings

- std::string (dynamic string of characters)
- std::wstring (wide string)
- std::u16string, std::u32string (for UTF-16 and UTF-32 encoding)

### String Views (introduced in C++17)

- std::string_view (lightweight, non-owning string reference)
- std::wstring_view, std::u16string_view, std::u32string_view

## 5. Iterators

### Types

- Input iterators
- Output iterators
- Forward iterators
- Bidirectional iterators
- Random-access iterators

### Iterator Adapters

- std::reverse_iterator
- std::move_iterator
- std::insert_iterator, std::back_insert_iterator, std::front_insert_iterator

### Range-based for loops (introduced in C++11)

- for (auto& item : container)

## 6. Utility Classes

### Pairs and Tuples

- std::pair
- std::tuple (introduced in C++11)
- Structured bindings (introduced in C++17): auto [x, y] = pair;

### Optional (introduced in C++17)

- std::optional<T>: stores an optional value.

### Variant (introduced in C++17)

- std::variant<Ts...>: type-safe union of multiple types.

### Any (introduced in C++17)

- std::any: holds any type of value.

## 7. Algorithms

### Sorting Algorithms

- std::sort, std::stable_sort
- std::partial_sort, std::nth_element
- std::is_sorted

### Searching Algorithms

- std::find, std::binary_search
- std::find_if, std::find_if_not

### Set Operations

- std::set_union, std::set_difference

### Other Algorithms

- std::transform, std::for_each, std::accumulate

## 8. Concurrency (C++11 and beyond)

### Thread Support

- std::thread (multi-threading support)
- std::mutex, std::shared_mutex (introduced in C++17)
- std::lock_guard, std::unique_lock

### Futures and Promises

- std::future, std::promise, std::async

### Coroutines (introduced in C++20)

- co_await, co_yield, co_return

## 9. Ranges (Introduced in C++20)

Provides a new way to handle ranges of data, offering a more modern alternative to traditional iterator-based algorithms.

- std::ranges::begin(), std::ranges::end()
- std::views::filter, std::views::transform

## 10. Concepts (Introduced in C++20)

Used to specify the requirements on template arguments, making template code easier to write and understand.

- template<typename T> requires std::integral<T>

## 11. Smart Pointers

### Ownership Models

- std::unique_ptr: Exclusive ownership of an object.
- std::shared_ptr: Shared ownership of an object.
- std::weak_ptr: Weak reference to a shared pointer, preventing circular dependencies.

## 12. Custom Data Structures

### Class/Struct

- class MyClass { /* ... */ };
- struct MyStruct { /* ... */ };

### Union

- union MyUnion { /* ... */ }

Search for CPP to find related posts, also practicing each section is a proper method to improve the programming skills in C++.

# Python Data Structures

## 1. Primitive Data Types
- int: Integer values.

  x = 10

float: Floating-point numbers.

y = 10.5

bool: Boolean values (True/False).

z = True

str: Strings (immutable sequences of Unicode characters).

s = "Hello, World!"

2. Sequence Types

a. List

A mutable, ordered collection of elements.

lst = [1, 2, 3, 4]
lst.append(5)

b. Tuple

An immutable, ordered collection of elements.

tpl = (1, 2, 3)

c. Range

A sequence of numbers, often used in loops.

r = range(1, 10)

d. String

A sequence of characters, treated as a list of characters.

s = "Hello"
first_char = s[0]

e. Byte/Bytearray

Immutable (bytes) or mutable (bytearray) sequences of bytes.

b = bytes([65, 66, 67])  # A, B, C
ba = bytearray([65, 66, 67])

3. Set Types

a. Set

An unordered, mutable collection of unique elements.

s = {1, 2, 3, 4}
s.add(5)

b. Frozen Set

An immutable version of a set.

fs = frozenset([1, 2, 3])

4. Mapping Type

Dictionary

An unordered, mutable collection of key-value pairs.

d = {'name': 'Alice', 'age': 25}
d['location'] = 'Wonderland'

5. Specialized Data Structures

a. Deque (Double-Ended Queue)

A thread-safe, general-purpose, double-ended queue.

from collections import deque
dq = deque([1, 2, 3])
dq.appendleft(0)

b. Defaultdict

A dictionary that provides a default value for non-existent keys.

from collections import defaultdict
dd = defaultdict(int)
dd['a'] += 1  # If 'a' doesn't exist, its value will default to 0

c. OrderedDict

A dictionary that remembers the order of key insertions (introduced in Python 3.1).

from collections import OrderedDict
od = OrderedDict()
od['a'] = 1
od['b'] = 2

6. Stack and Queue

a. Stack (List-based)

A last-in, first-out (LIFO) structure.

stack = []
stack.append(10)
stack.pop()

b. Queue (List or deque-based)

A first-in, first-out (FIFO) structure.

queue = deque()
queue.append(10)
queue.popleft()

7. Linked List

Python doesn't have a built-in linked list, but you can implement one using classes.

# Node class to represent a single node in the linked list
class Node:
    def __init__(self, data):
        self.data = data  # Data held by the node
        self.next = None  # Pointer to the next node in the list

# LinkedList class to manage the linked list
class LinkedList:
    def __init__(self):
        self.head = None  # Initialize the head of the list as None

    # Method to append a new node to the end of the list
    def append(self, data):
        new_node = Node(data)  # Create a new node with the given data
        if self.head is None:
            self.head = new_node  # If the list is empty, set the new node as the head
            return
        last = self.head
        while last.next:  # Traverse to the end of the list
            last = last.next
        last.next = new_node  # Set the next of the last node to the new node

    # Method to print the linked list
    def print_list(self):
        current = self.head
        while current:
            print(current.data, end=" -> ")
            current = current.next
        print("None")

    # Method to delete the first occurrence of a node with the given data
    def delete(self, data):
        current = self.head

        # If the head node holds the data to be deleted
        if current and current.data == data:
            self.head = current.next  # Change the head to the next node
            current = None  # Free the old head node
            return

        # Search for the node to be deleted, keeping track of the previous node
        prev = None
        while current and current.data != data:
            prev = current
            current = current.next

        # If the data was not present in the list
        if current is None:
            print("Node not found in the list.")
            return

        # Unlink the node from the list
        prev.next = current.next
        current = None

# Example usage:
if __name__ == "__main__":
    # Create a linked list
    linked_list = LinkedList()

    # Append some elements to the list
    linked_list.append(1)
    linked_list.append(2)
    linked_list.append(3)

    # Print the list
    print("Original Linked List:")
    linked_list.print_list()

    # Delete a node
    linked_list.delete(2)

    # Print the list after deletion
    print("Linked List after deleting 2:")
    linked_list.print_list()

8. Heap (Priority Queue)

Python’s heapq module implements a binary heap.

import heapq
heap = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
heapq.heapify(heap)
smallest = heapq.heappop(heap)