memory-graph 0.3.61__tar.gz → 0.3.62__tar.gz

{memory_graph-0.3.61/memory_graph.egg-info → memory_graph-0.3.62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.61
+Version: 0.3.62
 Summary: Teaching tool and debugging aid in context of references, mutable data types, and shallow and deep copy.
 Author-email: Bas Terwijn <bterwijn@gmail.com>
 License-Expression: BSD-2-Clause
@@ -121,6 +121,12 @@ A better way to understand what values are shared is to draw a graph using [memo
 
 [Data Structure Examples](#data-structure-examples)
 
+[Sorting Algorithms](#sorting-algorithms)
+
+[Bitwise Operators](#bitwise-operators)
+
+[Sliding Puzzle Solver](#sliding-puzzle-solver)
+
 [Configuration](#configuration)
 
 [Introspection](#introspection)
@@ -218,7 +224,7 @@ a = [ [1, 2], ['x', 'y'] ]  # a nested list (a list containing lists)
 
 # three different ways to make a "copy" of 'a':
 c1 = a
-c2 = copy.copy(a)  # equivalent to:  a.copy() a[:] list(a)
+c2 = copy.copy(a)  # for list equivalent to:  a.copy() a[:] list(a)
 c3 = copy.deepcopy(a)
 
 mg.show(locals())
@@ -261,7 +267,7 @@ mg.show(locals())
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/custom_copy.py&breakpoints=15&continues=1&play).
 
 ## Name Rebinding ##
-When `a` and `b` share a mutable value, then changing the value of `b` changes the value of `a` and vice versa. However, reassigning `b` does not change `a`. When you reassign `b`, you only **rebind** the name `b` to another value without affecting any other variables.
+When `a` and `b` share a mutable value, then changing the value of `b` changes the value of `a` and vice versa. However, reassigning `b` does not change `a`. When you reassign `b`, you only **rebind** the name `b` to another value without affecting any other variable.
 
 ```python
 import memory_graph as mg
@@ -316,7 +322,7 @@ mg.show(locals())
 ![copy_mix.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/copy_mix.png)
 
 # Call Stack #
-The `mg.stack()` function retrieves the entire call stack, including the local variables for each function on the stack. This enables us to understand function calls, variable scope, and the **complete program state** through call stack visualization. By examining the graph, we can determine whether any local variables from different functions share data. For instance, consider the function `add_one()` which adds the value `1` to each of its parameters `a`, `b`, and `c`.
+The `mg.stack()` function retrieves the entire call stack, including the local variables for each function on the stack. This enables us to understand function calls, variable scope, and the **complete program state** through call stack visualization. By examining the graph, we can see whether local variables from different function calls share data. For instance, consider the function `add_one()` which adds the value `1` to each of its parameters `a`, `b`, and `c`.
 
 ```python
 import memory_graph as mg
@@ -342,7 +348,7 @@ In the printed output we see that only `a` is changed as a result of the functio
 ```
 a:[4, 3, 2, 1] b:(4, 3, 2) c:[4, 3, 2]
 ```
-This is because `b` is of immutable type 'tuple' so its value gets copied automatically when it is changed. And because the function is called with a copy of `c`, its original value is not changed by the function. The value of variable `a` is the only value of mutable type that is shared between the root stack frame **'0: \<module>'** and the **'1: add_one'** stack frame of the function so only that variable is affected as a result of the function call. The other changes remain confined to the local variables of the ```add_one()``` function.
+This is because `b` is of immutable type 'tuple' so its value gets copied automatically when it is changed. And because the function is called with a copy of `c`, its original value is not changed by the function. The value of variable `a` is the only value of mutable type that is shared between the root stack frame **'0: \<module>'** and the **'1: add_one'** stack frame of the function call so only that variable is affected as a result of calling the function. The other changes remain confined to the local variables of the ```add_one()``` function.
 
 ## Function Call That Changes 'int' Value ##
 Even though `int` is an immutable type, so an `int` value can not be changed by directly passing it to a function, we can still change it by wrapping it in a mutable container.
@@ -371,7 +377,7 @@ The effect of calling `add_one()` is that `b[0]` increases by 1, while `a` is un
 
 ## Exercises ##
 
-Now is a good time to practice with the Python Data Model. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls.
+Now is a good time to practice with Python Data Model concepts. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls.
 
 ## Block ##
 It is often helpful to temporarily block program execution to inspect the graph. For this we can use the `mg.block()` function:
@@ -669,6 +675,35 @@ Here we show values being inserted in a HashSet in PyCharm. When inserting the l
 
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/hash_set.py&breakpoints=32&continues=1&timestep=0.5&play).
 
+
+# Sorting Algorithms #
+
+Visualization of different sorting algorithms in Memory Graph Web Debugger.
+![selections_sort.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/selection_sort.gif)
+
+- [selection sort](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/selection_sort.py&breakpoints=13,27&continues=1&timestep=0.2&play)
+- [insertion sort](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/insertion_sort.py&breakpoints=13,29&continues=1&timestep=0.2&play)
+- [bubble sort](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bubble_sort.py&breakpoints=29,38&continues=1&timestep=0.2&play)
+- [cocktail shaker sort](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/cocktail_sort.py&breakpoints=16,45&continues=1&timestep=0.2&play)
+
+
+# Bitwise Operators #
+In this configuration example we show the decimal, binary and [two's complement representation](https://www.cs.cornell.edu/~tomf/notes/cps104/twoscomp.html) representation of `int` values of dictionary subclass `Bits` to show the result of [bitwise operators](https://docs.python.org/3/library/stdtypes.html?utm_source=chatgpt.com#bitwise-operations-on-integer-types). The `~` (inverse) operator can be a bit confusing if not shown with two's complement representation.
+
+- [bitwise operators](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bitwise_operators.py&breakpoints=22&continues=1&play)
+
+![bitwise_operators.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bitwise_operators.png)
+
+
+# Sliding Puzzle Solver #
+
+A sliding puzzle solver as a challenging example showing how memory_graph deals with large amounts of data. Click "Continue" to step through the breadth-first search generations until a solution path is found:
+
+- [sliding puzzle solver](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/sliding_puzzle.py&breakpoints=17,27,29,40&continues=1)
+
+![sliding_puzzle.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/sliding_puzzle.png)
+
+
 # Configuration #
 Different aspects of memory_graph can be configured. The default configuration can be reset by calling 'mg.config_default.reset()'. The Memory Graph Web Debugger gives examples of the [most important configurations](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/config.py&play).
 
@@ -940,54 +975,6 @@ mg.config.type_to_node[List_View] = lambda data: mg.Node_Linear(data,
 ```
 ![bin_search_linear.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_search_linear.png)
 
-## Bitwise Operators ##
-In this configuration example we show the decimal, binary and [two's complement representation](https://www.cs.cornell.edu/~tomf/notes/cps104/twoscomp.html) representation of `int` values of dictionary subclass `Bits` to show the result of [bitwise operators](https://docs.python.org/3/library/stdtypes.html?utm_source=chatgpt.com#bitwise-operations-on-integer-types). The `~` (inverse) operator can be a bit confusing if not shown with two's complement representation.
-
-```python
-import memory_graph as mg
-
-class Bits(dict):
-   """ Dictionary subclass that we will configure to show binary representations. """
-
-def twos_complement(x: int, bits: int) -> str:
-    """Return the two's complement bit string of x in `bits` bits."""
-    mask = (1 << bits) - 1
-    return format(x & mask, f"0{bits}b")
-
-# configure memory_graph to show binary representations of values of type Bits
-mg.config.type_to_node[Bits] = lambda x : mg.Node_Table(x,
-    [ ["expression", "decimal", "bin(expression)", "16bit two's complement"] ] +
-    [ [k, f'{v:>10}', f'{bin(v):>19}', twos_complement(v,16)] for k, v in x.items()] )
-mg.config.type_to_slicer[Bits] = (mg.Slicer(), mg.Slicer())  # no slicing
-mg.config.type_to_color[Bits] = 'gold'
-mg.config.fontname = 'Courier' # monospace font
-
-bits = Bits()
-
-# now add some some variables and expressions
-bits['a'] = 1
-bits['b'] = 48
-bits['c'] = 127
-bits['a << 3'] = bits['a'] << 3         # bit shift left by 3
-bits['b >> 3'] = bits['b'] >> 3         # bit shift right by 3
-bits['a | b']  = bits['a'] | bits['b']  # bitwise or
-bits['b & c']  = bits['b'] & bits['c']  # bitwise and
-bits['b ^ c']  = bits['b'] ^ bits['c']  # bitwise exclusive or
-
-# negative numbers, inverse, and two's complement
-bits['d'] = 240
-bits['e'] = -240
-bits['f'] = -241                        # -(d+1)
-bits['~d'] = ~ bits['d']                # inverse -(x+1)
-bits['~e'] = ~ bits['e']                # inverse -(x+1)
-bits['~f'] = ~ bits['f']                # inverse -(x+1)
-
-mg.s()
-```
-![bitwise_operators.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bitwise_operators.png)
-
-Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bitwise_operators.py&breakpoints=22&continues=1&play)
-
 # Graph Depth #
 To limit the size of the graph the maximum depth of the graph is set by `mg.config.max_graph_depth`. Additionally for each type a depth can be set to further limit the graph, as is done for type `B` in the example below. Scissors indicate where the graph is cut short. Alternatively the `id()` of a data elements can be used to limit the graph for that specific element, as is done for the value referenced by variable `c`.
 

{memory_graph-0.3.61 → memory_graph-0.3.62}/README.md

@@ -101,6 +101,12 @@ A better way to understand what values are shared is to draw a graph using [memo
 
 [Data Structure Examples](#data-structure-examples)
 
+[Sorting Algorithms](#sorting-algorithms)
+
+[Bitwise Operators](#bitwise-operators)
+
+[Sliding Puzzle Solver](#sliding-puzzle-solver)
+
 [Configuration](#configuration)
 
 [Introspection](#introspection)
@@ -198,7 +204,7 @@ a = [ [1, 2], ['x', 'y'] ]  # a nested list (a list containing lists)
 
 # three different ways to make a "copy" of 'a':
 c1 = a
-c2 = copy.copy(a)  # equivalent to:  a.copy() a[:] list(a)
+c2 = copy.copy(a)  # for list equivalent to:  a.copy() a[:] list(a)
 c3 = copy.deepcopy(a)
 
 mg.show(locals())
@@ -241,7 +247,7 @@ mg.show(locals())
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/custom_copy.py&breakpoints=15&continues=1&play).
 
 ## Name Rebinding ##
-When `a` and `b` share a mutable value, then changing the value of `b` changes the value of `a` and vice versa. However, reassigning `b` does not change `a`. When you reassign `b`, you only **rebind** the name `b` to another value without affecting any other variables.
+When `a` and `b` share a mutable value, then changing the value of `b` changes the value of `a` and vice versa. However, reassigning `b` does not change `a`. When you reassign `b`, you only **rebind** the name `b` to another value without affecting any other variable.
 
 ```python
 import memory_graph as mg
@@ -296,7 +302,7 @@ mg.show(locals())
 ![copy_mix.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/copy_mix.png)
 
 # Call Stack #
-The `mg.stack()` function retrieves the entire call stack, including the local variables for each function on the stack. This enables us to understand function calls, variable scope, and the **complete program state** through call stack visualization. By examining the graph, we can determine whether any local variables from different functions share data. For instance, consider the function `add_one()` which adds the value `1` to each of its parameters `a`, `b`, and `c`.
+The `mg.stack()` function retrieves the entire call stack, including the local variables for each function on the stack. This enables us to understand function calls, variable scope, and the **complete program state** through call stack visualization. By examining the graph, we can see whether local variables from different function calls share data. For instance, consider the function `add_one()` which adds the value `1` to each of its parameters `a`, `b`, and `c`.
 
 ```python
 import memory_graph as mg
@@ -322,7 +328,7 @@ In the printed output we see that only `a` is changed as a result of the functio
 ```
 a:[4, 3, 2, 1] b:(4, 3, 2) c:[4, 3, 2]
 ```
-This is because `b` is of immutable type 'tuple' so its value gets copied automatically when it is changed. And because the function is called with a copy of `c`, its original value is not changed by the function. The value of variable `a` is the only value of mutable type that is shared between the root stack frame **'0: \<module>'** and the **'1: add_one'** stack frame of the function so only that variable is affected as a result of the function call. The other changes remain confined to the local variables of the ```add_one()``` function.
+This is because `b` is of immutable type 'tuple' so its value gets copied automatically when it is changed. And because the function is called with a copy of `c`, its original value is not changed by the function. The value of variable `a` is the only value of mutable type that is shared between the root stack frame **'0: \<module>'** and the **'1: add_one'** stack frame of the function call so only that variable is affected as a result of calling the function. The other changes remain confined to the local variables of the ```add_one()``` function.
 
 ## Function Call That Changes 'int' Value ##
 Even though `int` is an immutable type, so an `int` value can not be changed by directly passing it to a function, we can still change it by wrapping it in a mutable container.
@@ -351,7 +357,7 @@ The effect of calling `add_one()` is that `b[0]` increases by 1, while `a` is un
 
 ## Exercises ##
 
-Now is a good time to practice with the Python Data Model. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls.
+Now is a good time to practice with Python Data Model concepts. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls.
 
 ## Block ##
 It is often helpful to temporarily block program execution to inspect the graph. For this we can use the `mg.block()` function:
@@ -649,6 +655,35 @@ Here we show values being inserted in a HashSet in PyCharm. When inserting the l
 
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/hash_set.py&breakpoints=32&continues=1&timestep=0.5&play).
 
+
+# Sorting Algorithms #
+
+Visualization of different sorting algorithms in Memory Graph Web Debugger.
+![selections_sort.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/selection_sort.gif)
+
+- [selection sort](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/selection_sort.py&breakpoints=13,27&continues=1&timestep=0.2&play)
+- [insertion sort](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/insertion_sort.py&breakpoints=13,29&continues=1&timestep=0.2&play)
+- [bubble sort](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bubble_sort.py&breakpoints=29,38&continues=1&timestep=0.2&play)
+- [cocktail shaker sort](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/cocktail_sort.py&breakpoints=16,45&continues=1&timestep=0.2&play)
+
+
+# Bitwise Operators #
+In this configuration example we show the decimal, binary and [two's complement representation](https://www.cs.cornell.edu/~tomf/notes/cps104/twoscomp.html) representation of `int` values of dictionary subclass `Bits` to show the result of [bitwise operators](https://docs.python.org/3/library/stdtypes.html?utm_source=chatgpt.com#bitwise-operations-on-integer-types). The `~` (inverse) operator can be a bit confusing if not shown with two's complement representation.
+
+- [bitwise operators](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bitwise_operators.py&breakpoints=22&continues=1&play)
+
+![bitwise_operators.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bitwise_operators.png)
+
+
+# Sliding Puzzle Solver #
+
+A sliding puzzle solver as a challenging example showing how memory_graph deals with large amounts of data. Click "Continue" to step through the breadth-first search generations until a solution path is found:
+
+- [sliding puzzle solver](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/sliding_puzzle.py&breakpoints=17,27,29,40&continues=1)
+
+![sliding_puzzle.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/sliding_puzzle.png)
+
+
 # Configuration #
 Different aspects of memory_graph can be configured. The default configuration can be reset by calling 'mg.config_default.reset()'. The Memory Graph Web Debugger gives examples of the [most important configurations](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/config.py&play).
 
@@ -920,54 +955,6 @@ mg.config.type_to_node[List_View] = lambda data: mg.Node_Linear(data,
 ```
 ![bin_search_linear.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_search_linear.png)
 
-## Bitwise Operators ##
-In this configuration example we show the decimal, binary and [two's complement representation](https://www.cs.cornell.edu/~tomf/notes/cps104/twoscomp.html) representation of `int` values of dictionary subclass `Bits` to show the result of [bitwise operators](https://docs.python.org/3/library/stdtypes.html?utm_source=chatgpt.com#bitwise-operations-on-integer-types). The `~` (inverse) operator can be a bit confusing if not shown with two's complement representation.
-
-```python
-import memory_graph as mg
-
-class Bits(dict):
-   """ Dictionary subclass that we will configure to show binary representations. """
-
-def twos_complement(x: int, bits: int) -> str:
-    """Return the two's complement bit string of x in `bits` bits."""
-    mask = (1 << bits) - 1
-    return format(x & mask, f"0{bits}b")
-
-# configure memory_graph to show binary representations of values of type Bits
-mg.config.type_to_node[Bits] = lambda x : mg.Node_Table(x,
-    [ ["expression", "decimal", "bin(expression)", "16bit two's complement"] ] +
-    [ [k, f'{v:>10}', f'{bin(v):>19}', twos_complement(v,16)] for k, v in x.items()] )
-mg.config.type_to_slicer[Bits] = (mg.Slicer(), mg.Slicer())  # no slicing
-mg.config.type_to_color[Bits] = 'gold'
-mg.config.fontname = 'Courier' # monospace font
-
-bits = Bits()
-
-# now add some some variables and expressions
-bits['a'] = 1
-bits['b'] = 48
-bits['c'] = 127
-bits['a << 3'] = bits['a'] << 3         # bit shift left by 3
-bits['b >> 3'] = bits['b'] >> 3         # bit shift right by 3
-bits['a | b']  = bits['a'] | bits['b']  # bitwise or
-bits['b & c']  = bits['b'] & bits['c']  # bitwise and
-bits['b ^ c']  = bits['b'] ^ bits['c']  # bitwise exclusive or
-
-# negative numbers, inverse, and two's complement
-bits['d'] = 240
-bits['e'] = -240
-bits['f'] = -241                        # -(d+1)
-bits['~d'] = ~ bits['d']                # inverse -(x+1)
-bits['~e'] = ~ bits['e']                # inverse -(x+1)
-bits['~f'] = ~ bits['f']                # inverse -(x+1)
-
-mg.s()
-```
-![bitwise_operators.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bitwise_operators.png)
-
-Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bitwise_operators.py&breakpoints=22&continues=1&play)
-
 # Graph Depth #
 To limit the size of the graph the maximum depth of the graph is set by `mg.config.max_graph_depth`. Additionally for each type a depth can be set to further limit the graph, as is done for type `B` in the example below. Scissors indicate where the graph is cut short. Alternatively the `id()` of a data elements can be used to limit the graph for that specific element, as is done for the value referenced by variable `c`.
 

{memory_graph-0.3.61 → memory_graph-0.3.62}/memory_graph/__init__.py

@@ -2,7 +2,7 @@
 # Copyright (c) 2023, Bas Terwijn.
 # SPDX-License-Identifier: BSD-2-Clause
 
-__version__ = "0.3.61"
+__version__ = "0.3.62"
 __author__ = 'Bas Terwijn'
 
 import memory_graph.memory_to_nodes as memory_to_nodes

{memory_graph-0.3.61 → memory_graph-0.3.62}/memory_graph/utils.py

@@ -48,6 +48,8 @@ def make_sliceable(data):
         return data
     except TypeError:
         return list(data)
+    except Exception:
+        return []
 
 def is_finite_iterable(data):
     """ Returns 'True' if 'data' is finite iterable. """

{memory_graph-0.3.61 → memory_graph-0.3.62/memory_graph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memory_graph
-Version: 0.3.61
+Version: 0.3.62
 Summary: Teaching tool and debugging aid in context of references, mutable data types, and shallow and deep copy.
 Author-email: Bas Terwijn <bterwijn@gmail.com>
 License-Expression: BSD-2-Clause
@@ -121,6 +121,12 @@ A better way to understand what values are shared is to draw a graph using [memo
 
 [Data Structure Examples](#data-structure-examples)
 
+[Sorting Algorithms](#sorting-algorithms)
+
+[Bitwise Operators](#bitwise-operators)
+
+[Sliding Puzzle Solver](#sliding-puzzle-solver)
+
 [Configuration](#configuration)
 
 [Introspection](#introspection)
@@ -218,7 +224,7 @@ a = [ [1, 2], ['x', 'y'] ]  # a nested list (a list containing lists)
 
 # three different ways to make a "copy" of 'a':
 c1 = a
-c2 = copy.copy(a)  # equivalent to:  a.copy() a[:] list(a)
+c2 = copy.copy(a)  # for list equivalent to:  a.copy() a[:] list(a)
 c3 = copy.deepcopy(a)
 
 mg.show(locals())
@@ -261,7 +267,7 @@ mg.show(locals())
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/custom_copy.py&breakpoints=15&continues=1&play).
 
 ## Name Rebinding ##
-When `a` and `b` share a mutable value, then changing the value of `b` changes the value of `a` and vice versa. However, reassigning `b` does not change `a`. When you reassign `b`, you only **rebind** the name `b` to another value without affecting any other variables.
+When `a` and `b` share a mutable value, then changing the value of `b` changes the value of `a` and vice versa. However, reassigning `b` does not change `a`. When you reassign `b`, you only **rebind** the name `b` to another value without affecting any other variable.
 
 ```python
 import memory_graph as mg
@@ -316,7 +322,7 @@ mg.show(locals())
 ![copy_mix.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/copy_mix.png)
 
 # Call Stack #
-The `mg.stack()` function retrieves the entire call stack, including the local variables for each function on the stack. This enables us to understand function calls, variable scope, and the **complete program state** through call stack visualization. By examining the graph, we can determine whether any local variables from different functions share data. For instance, consider the function `add_one()` which adds the value `1` to each of its parameters `a`, `b`, and `c`.
+The `mg.stack()` function retrieves the entire call stack, including the local variables for each function on the stack. This enables us to understand function calls, variable scope, and the **complete program state** through call stack visualization. By examining the graph, we can see whether local variables from different function calls share data. For instance, consider the function `add_one()` which adds the value `1` to each of its parameters `a`, `b`, and `c`.
 
 ```python
 import memory_graph as mg
@@ -342,7 +348,7 @@ In the printed output we see that only `a` is changed as a result of the functio
 ```
 a:[4, 3, 2, 1] b:(4, 3, 2) c:[4, 3, 2]
 ```
-This is because `b` is of immutable type 'tuple' so its value gets copied automatically when it is changed. And because the function is called with a copy of `c`, its original value is not changed by the function. The value of variable `a` is the only value of mutable type that is shared between the root stack frame **'0: \<module>'** and the **'1: add_one'** stack frame of the function so only that variable is affected as a result of the function call. The other changes remain confined to the local variables of the ```add_one()``` function.
+This is because `b` is of immutable type 'tuple' so its value gets copied automatically when it is changed. And because the function is called with a copy of `c`, its original value is not changed by the function. The value of variable `a` is the only value of mutable type that is shared between the root stack frame **'0: \<module>'** and the **'1: add_one'** stack frame of the function call so only that variable is affected as a result of calling the function. The other changes remain confined to the local variables of the ```add_one()``` function.
 
 ## Function Call That Changes 'int' Value ##
 Even though `int` is an immutable type, so an `int` value can not be changed by directly passing it to a function, we can still change it by wrapping it in a mutable container.
@@ -371,7 +377,7 @@ The effect of calling `add_one()` is that `b[0]` increases by 1, while `a` is un
 
 ## Exercises ##
 
-Now is a good time to practice with the Python Data Model. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls.
+Now is a good time to practice with Python Data Model concepts. Here are [some exercises](https://github.com/bterwijn/memory_graph_videos/blob/main/exercises/exercises.md) on references, mutability, copies, and function calls.
 
 ## Block ##
 It is often helpful to temporarily block program execution to inspect the graph. For this we can use the `mg.block()` function:
@@ -669,6 +675,35 @@ Here we show values being inserted in a HashSet in PyCharm. When inserting the l
 
 Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/hash_set.py&breakpoints=32&continues=1&timestep=0.5&play).
 
+
+# Sorting Algorithms #
+
+Visualization of different sorting algorithms in Memory Graph Web Debugger.
+![selections_sort.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/selection_sort.gif)
+
+- [selection sort](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/selection_sort.py&breakpoints=13,27&continues=1&timestep=0.2&play)
+- [insertion sort](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/insertion_sort.py&breakpoints=13,29&continues=1&timestep=0.2&play)
+- [bubble sort](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bubble_sort.py&breakpoints=29,38&continues=1&timestep=0.2&play)
+- [cocktail shaker sort](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/cocktail_sort.py&breakpoints=16,45&continues=1&timestep=0.2&play)
+
+
+# Bitwise Operators #
+In this configuration example we show the decimal, binary and [two's complement representation](https://www.cs.cornell.edu/~tomf/notes/cps104/twoscomp.html) representation of `int` values of dictionary subclass `Bits` to show the result of [bitwise operators](https://docs.python.org/3/library/stdtypes.html?utm_source=chatgpt.com#bitwise-operations-on-integer-types). The `~` (inverse) operator can be a bit confusing if not shown with two's complement representation.
+
+- [bitwise operators](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bitwise_operators.py&breakpoints=22&continues=1&play)
+
+![bitwise_operators.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bitwise_operators.png)
+
+
+# Sliding Puzzle Solver #
+
+A sliding puzzle solver as a challenging example showing how memory_graph deals with large amounts of data. Click "Continue" to step through the breadth-first search generations until a solution path is found:
+
+- [sliding puzzle solver](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/sliding_puzzle.py&breakpoints=17,27,29,40&continues=1)
+
+![sliding_puzzle.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/sliding_puzzle.png)
+
+
 # Configuration #
 Different aspects of memory_graph can be configured. The default configuration can be reset by calling 'mg.config_default.reset()'. The Memory Graph Web Debugger gives examples of the [most important configurations](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/config.py&play).
 
@@ -940,54 +975,6 @@ mg.config.type_to_node[List_View] = lambda data: mg.Node_Linear(data,
 ```
 ![bin_search_linear.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bin_search_linear.png)
 
-## Bitwise Operators ##
-In this configuration example we show the decimal, binary and [two's complement representation](https://www.cs.cornell.edu/~tomf/notes/cps104/twoscomp.html) representation of `int` values of dictionary subclass `Bits` to show the result of [bitwise operators](https://docs.python.org/3/library/stdtypes.html?utm_source=chatgpt.com#bitwise-operations-on-integer-types). The `~` (inverse) operator can be a bit confusing if not shown with two's complement representation.
-
-```python
-import memory_graph as mg
-
-class Bits(dict):
-   """ Dictionary subclass that we will configure to show binary representations. """
-
-def twos_complement(x: int, bits: int) -> str:
-    """Return the two's complement bit string of x in `bits` bits."""
-    mask = (1 << bits) - 1
-    return format(x & mask, f"0{bits}b")
-
-# configure memory_graph to show binary representations of values of type Bits
-mg.config.type_to_node[Bits] = lambda x : mg.Node_Table(x,
-    [ ["expression", "decimal", "bin(expression)", "16bit two's complement"] ] +
-    [ [k, f'{v:>10}', f'{bin(v):>19}', twos_complement(v,16)] for k, v in x.items()] )
-mg.config.type_to_slicer[Bits] = (mg.Slicer(), mg.Slicer())  # no slicing
-mg.config.type_to_color[Bits] = 'gold'
-mg.config.fontname = 'Courier' # monospace font
-
-bits = Bits()
-
-# now add some some variables and expressions
-bits['a'] = 1
-bits['b'] = 48
-bits['c'] = 127
-bits['a << 3'] = bits['a'] << 3         # bit shift left by 3
-bits['b >> 3'] = bits['b'] >> 3         # bit shift right by 3
-bits['a | b']  = bits['a'] | bits['b']  # bitwise or
-bits['b & c']  = bits['b'] & bits['c']  # bitwise and
-bits['b ^ c']  = bits['b'] ^ bits['c']  # bitwise exclusive or
-
-# negative numbers, inverse, and two's complement
-bits['d'] = 240
-bits['e'] = -240
-bits['f'] = -241                        # -(d+1)
-bits['~d'] = ~ bits['d']                # inverse -(x+1)
-bits['~e'] = ~ bits['e']                # inverse -(x+1)
-bits['~f'] = ~ bits['f']                # inverse -(x+1)
-
-mg.s()
-```
-![bitwise_operators.png](https://raw.githubusercontent.com/bterwijn/memory_graph/main/images/bitwise_operators.png)
-
-Or see it in the [Memory Grah Web Debugger](https://memory-graph.com/#codeurl=https://raw.githubusercontent.com/bterwijn/memory_graph/refs/heads/main/src/bitwise_operators.py&breakpoints=22&continues=1&play)
-
 # Graph Depth #
 To limit the size of the graph the maximum depth of the graph is set by `mg.config.max_graph_depth`. Additionally for each type a depth can be set to further limit the graph, as is done for type `B` in the example below. Scissors indicate where the graph is cut short. Alternatively the `id()` of a data elements can be used to limit the graph for that specific element, as is done for the value referenced by variable `c`.
 

{memory_graph-0.3.61 → memory_graph-0.3.62}/memory_graph.egg-info/SOURCES.txt

@@ -74,6 +74,8 @@ images/power_set.gif
 images/power_set.py
 images/rebinding1.png
 images/rebinding2.png
+images/selection_sort.gif
+images/sliding_puzzle.png
 images/uva.png
 images/vscode_copying.gif
 images/wrap_int.png

{memory_graph-0.3.61 → memory_graph-0.3.62}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memory_graph"
-version = "0.3.61"
+version = "0.3.62"
 description = "Teaching tool and debugging aid in context of references, mutable data types, and shallow and deep copy."
 authors = [
     {name = "Bas Terwijn", email = "bterwijn@gmail.com"}