Added README.md

arithmetic_analysis/README.md

@@ -0,0 +1,7 @@
+# Arithmetic analysis
+
+It's a branch of mathematics that deal with solving linear equations.
+
+* <https://en.wikipedia.org/wiki/System_of_linear_equations>
+* <https://en.wikipedia.org/wiki/Gaussian_elimination>
+* <https://en.wikipedia.org/wiki/Root-finding_algorithms>

audio_filters/README.md

@@ -0,0 +1,9 @@
+# Audio Filter
+
+Audio filters work on the frequency of an audio signal to attenuate unwanted frequency and amplify wanted ones.
+They are used within anything related to sound, whether it's radio communication or a hi-fi system.
+
+* <https://www.masteringbox.com/filter-types/>
+* <http://ethanwiner.com/filters.html>
+* <https://en.wikipedia.org/wiki/Audio_filter>
+* <https://en.wikipedia.org/wiki/Electronic_filter>

backtracking/README.md

@@ -0,0 +1,8 @@
+# Backtracking
+
+Backtracking is a way to speed up the search process by removing candidate when they can't be the solution of a problem.
+
+* <https://en.wikipedia.org/wiki/Backtracking>
+* <https://en.wikipedia.org/wiki/Decision_tree_pruning>
+* <https://medium.com/@priyankmistry1999/backtracking-sudoku-6e4439e4825c>
+* <https://www.geeksforgeeks.org/sudoku-backtracking-7/>

bit_manipulation/README.md

@@ -1,6 +1,11 @@
-* https://docs.python.org/3/reference/expressions.html#binary-bitwise-operations
-* https://docs.python.org/3/reference/expressions.html#unary-arithmetic-and-bitwise-operations
-* https://docs.python.org/3/library/stdtypes.html#bitwise-operations-on-integer-types
-* https://wiki.python.org/moin/BitManipulation
-* https://wiki.python.org/moin/BitwiseOperators
-* https://www.tutorialspoint.com/python3/bitwise_operators_example.htm
+# Bit manipulation
+
+Bit manipulation is the act of manipulating bits to detect errors (hamming code), encrypts and decrypts messages (more on that in the 'ciphers' folder) or just do anything at the core level of your computer.
+
+* <https://en.wikipedia.org/wiki/Bit_manipulation>
+* <https://docs.python.org/3/reference/expressions.html#binary-bitwise-operations>
+* <https://docs.python.org/3/reference/expressions.html#unary-arithmetic-and-bitwise-operations>
+* <https://docs.python.org/3/library/stdtypes.html#bitwise-operations-on-integer-types>
+* <https://wiki.python.org/moin/BitManipulation>
+* <https://wiki.python.org/moin/BitwiseOperators>
+* <https://www.tutorialspoint.com/python3/bitwise_operators_example.htm>

blockchain/README.md

@@ -0,0 +1,4 @@
+# Blockchain
+
+* <https://en.wikipedia.org/wiki/Blockchain>
+* <https://www.ibm.com/topics/what-is-blockchain>

boolean_algebra/README.md

@@ -0,0 +1,7 @@
+# Boolean Algebra
+
+Boolean algebra is used to do arithmetic with bits of values True (1) or False (0).
+There are three basic operations: 'and', 'or' and 'not'.
+
+* <https://en.wikipedia.org/wiki/Boolean_algebra>
+* <https://plato.stanford.edu/entries/boolalg-math/>

cellular_automata/README.md

@@ -1,4 +1,8 @@
 # Cellular Automata
 
-* https://en.wikipedia.org/wiki/Cellular_automaton
-* https://mathworld.wolfram.com/ElementaryCellularAutomaton.html
+Cellular automata are a way to simulate the behavior of "life", whether it's a robot or cells.
+They usually follow simple rules but can lead to the creation of complex forms.
+The most popular cellular automaton is Conway's [Game of Life](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life).
+
+* <https://en.wikipedia.org/wiki/Cellular_automaton>
+* <https://mathworld.wolfram.com/ElementaryCellularAutomaton.html>

ciphers/README.md

@@ -0,0 +1,8 @@
+# Ciphers
+
+Ciphers have a long story behind them.
+It is used to protect data from people that are not allowed to have it. They are everywhere on the internet to protect your connections.
+
+* <https://en.wikipedia.org/wiki/Cipher>
+* <http://practicalcryptography.com/ciphers/>
+* <https://practicalcryptography.com/ciphers/classical-era/>

compression/README.md

@@ -0,0 +1,10 @@
+# Compression
+
+Data compression is everywhere, you need it to store data without taking too much space.
+Either the compression lose some data (such as images in .jpg) or it can be lossless (.png).
+
+Lossless compression is mainly used for archive purpose as it allow storing more data without losing information about the file archived. On the other hand, lossy compression is used for transfer of file where quality isn't necessarily what is required (i.e: images on Twitter).
+
+* <https://www.sciencedirect.com/topics/computer-science/compression-algorithm>
+* <https://en.wikipedia.org/wiki/Data_compression>
+* <https://en.wikipedia.org/wiki/Pigeonhole_principle>

computer_vision/README.md

@@ -1,7 +1,11 @@
-### Computer Vision
+# Computer Vision
+
+Computer vision is a field of computer science that works on enabling computers to see, identify and process images in the same way that human vision does, and then provide appropriate output.
 
-Computer vision is a field of computer science that works on enabling computers to see,
-identify and process images in the same way that human vision does, and then provide appropriate output.
 It is like imparting human intelligence and instincts to a computer.
 Image processing and computer vision are a little different from each other. Image processing means applying some algorithms for transforming image from one form to the other like smoothing, contrasting, stretching, etc.
+
 While computer vision comes from modelling image processing using the techniques of machine learning, computer vision applies machine learning to recognize patterns for interpretation of images (much like the process of visual reasoning of human vision).
+
+* <https://en.wikipedia.org/wiki/Computer_vision>
+* <https://www.algorithmia.com/blog/introduction-to-computer-vision>

conversions/README.md

@@ -0,0 +1,7 @@
+# Conversion
+
+The act to convert a type of data, a number from a numerical base or a unit into one of another type, base, unit.
+(binary to decimal, integer to string or foot to meters)
+
+* <https://en.wikipedia.org/wiki/Data_conversion>
+* <https://en.wikipedia.org/wiki/Transcoding>

data_structures/README.md

@@ -0,0 +1,9 @@
+# Data Structures
+
+There exist [many](https://en.wikipedia.org/wiki/List_of_data_structures) types of data structures, but some structures are more prone to keep some type of data over another type.
+The types used everywhere when programming is the boolean, the integer, the character and the floating point number. Those can lead to more advanced type, such as list, array, set, tuple, stack etc.
+
+(If this subject has your interest, you should do your own research because it's a vast subject. As often, the starting point should Wikipedia page.)
+
+* <https://en.wikipedia.org/wiki/Data_structure>
+* <https://www.tommyds.it/doc/benchmark.html>

digital_image_processing/README.md

@@ -0,0 +1,7 @@
+# Digital Image Processing
+
+It's when you are processing and applying changes to an image with a computer.
+Because an image can be considered as a signal, this is a subcategory of digital signal processing. Similar algorithms can be applied in digital signal processing with few tweaks to make.
+
+* <https://en.wikipedia.org/wiki/Digital_image_processing>
+* <https://en.wikipedia.org/wiki/Digital_data>

divide_and_conquer/README.md

@@ -0,0 +1,6 @@
+# Divide and Conquer
+
+A collection of algorithms that use the divide and conquer strategy to solve problems efficiently and fast.
+It consists of solving directly simpler sub-problems, to combine the solutions and find the solution of the bigger problem. (much like dynamic programming)
+
+* <https://en.wikipedia.org/wiki/Divide-and-conquer_algorithm>

dynamic_programming/README.md

@@ -0,0 +1,6 @@
+# Dynamic Programming
+
+Dynamic programming refers to the practice of simplifying a problem by breaking it into simpler sub-problems (much like divide-and-conquer)
+
+* <https://en.wikipedia.org/wiki/Dynamic_programming>
+* <https://en.wikipedia.org/wiki/Bellman_equation>

electronics/README.md

@@ -0,0 +1,6 @@
+# Electronics
+
+A collection of programs to compute results for electronic equations.
+Need to add how compute Maxwell's equations
+
+* <https://en.wikipedia.org/wiki/Electronics>

financial/ABOUT.md → financial/README.md

@@ -1,4 +1,4 @@
-### Interest
+# Interest
 
 * Compound Interest: "Compound interest is calculated by multiplying the initial principal amount by one plus the annual interest rate raised to the number of compound periods minus one." [Compound Interest](https://www.investopedia.com/)
 * Simple Interest: "Simple interest paid or received over a certain period is a fixed percentage of the principal amount that was borrowed or lent. " [Simple Interest](https://www.investopedia.com/)

fractals/README.md

@@ -0,0 +1,9 @@
+# Fractals
+
+Fractals are self-similar objects and appear the same at different levels of 'zoom'.
+
+As fractalfoundation.org say:
+> "A fractal is a never-ending pattern. [...] They are created by repeating a simple process over and over in an ongoing feedback loop. Driven by recursion, fractals are images of dynamic systems – the pictures of Chaos."
+
+* <https://en.wikipedia.org/wiki/Fractal>
+* <https://fractalfoundation.org/resources/what-are-fractals/>

fuzzy_logic/README.md

@@ -0,0 +1,6 @@
+# Fuzzy Logic
+
+Fuzzy logic is used when manipulating the concept of partial truth.
+
+* <https://plato.stanford.edu/entries/logic-fuzzy/>
+* <https://en.wikipedia.org/wiki/Fuzzy_logic>

genetic_algorithm/README.md

@@ -0,0 +1,6 @@
+# Genetic algorithms
+
+In a genetic algorithm, candidate solutions are evolved toward better one by evaluating their individual fitness and tweaking randomly the more fit to reproduce how evolution work.
+Those new solutions are then evaluated again to continue the algorithm.
+
+* <https://en.wikipedia.org/wiki/Genetic_algorithm>

geodesy/README.md

@@ -0,0 +1,5 @@
+# Geodesy
+
+Geodesy is the science of "accurately measuring and understanding Earth's geometric shape, orientation in space, and gravitational field."
+
+* <https://en.wikipedia.org/wiki/Geodesy>

graphics/REAME.md

@@ -0,0 +1,5 @@
+# Graphics
+
+Algorithms used to render graphics.
+
+* <https://en.wikipedia.org/wiki/B%C3%A9zier_curve>

graphs/README.md

@@ -0,0 +1,7 @@
+# Graphs
+
+Graphs are a type of data structure that are studied in graph theory.
+There exist many type of graphs, but the one most used are oriented, complete, finite, path and tree graphs.
+
+* <https://en.wikipedia.org/wiki/Graph_(discrete_mathematics)>
+* <https://en.wikipedia.org/wiki/Graph_theory>

greedy_methods/README.md

@@ -0,0 +1,6 @@
+# Greedy Methods
+
+Rather than trying to make the best possible choices for the problems, a greedy algorithm will make the best locally possible choice.
+Most of the time it will not produce the best result, but it will produce them within a reasonable amount of time, and they will still be good enough.
+
+* <https://en.wikipedia.org/wiki/Greedy_algorithm>

hashes/README.md

@@ -0,0 +1,8 @@
+# Hashes
+
+Hashes are a way to generate a string of characters (both letters and numbers) from an input (another string or a file) and are designed in such a way that even the barest change in the input will completely change the output.
+
+Nowadays, they are used to ensure that the file you received is indeed the one sent by the other party. It is still possible that two completely different input will produce the same output, but such cases are extremely unlikely to happen
+
+* <https://en.wikipedia.org/wiki/Hash_function>
+* <https://en.wikipedia.org/wiki/Checksum>

linear_algebra/README.md

@@ -7,53 +7,55 @@ This module contains classes and functions for doing linear algebra.
 ## Overview
 
 ### class Vector
--
-    - This class represents a vector of arbitrary size and related operations.
+
+- This class represents a vector of arbitrary size and related operations.
 
     **Overview of the methods:**
 
-    - constructor(components) : init the vector
-    - set(components) : changes the vector components.
-    - \_\_str\_\_() : toString method
-    - component(i): gets the i-th component (0-indexed)
-    - \_\_len\_\_() : gets the size / length of the vector (number of components)
-    - euclidean_length() : returns the eulidean length of the vector
-    - operator + : vector addition
-    - operator - : vector subtraction
-    - operator * : scalar multiplication and dot product
-    - copy() : copies this vector and returns it
-    - change_component(pos,value) : changes the specified component
+  - constructor(components) : init the vector
+  - set(components) : changes the vector components.
+  - `__str__`() : toString method
+  - component(i): gets the i-th component (0-indexed)
+  - `__len__`() : gets the size / length of the vector (number of components)
+  - euclidean_length() : returns the eulidean length of the vector
+  - operator + : vector addition
+  - operator - : vector subtraction
+  - operator * : scalar multiplication and dot product
+  - copy() : copies this vector and returns it
+  - change_component(pos, value) : changes the specified component
 
 - function zero_vector(dimension)
-    - returns a zero vector of 'dimension'
+  - returns a zero vector of 'dimension'
 - function unit_basis_vector(dimension, pos)
-    - returns a unit basis vector with a one at index 'pos' (0-indexed)
+  - returns a unit basis vector with a one at index 'pos' (0-indexed)
 - function axpy(scalar, vector1, vector2)
-    - computes the axpy operation
+  - computes the axpy operation
 - function random_vector(N, a, b)
-    - returns a random vector of size N, with random integer components between 'a' and 'b' inclusive
+  - returns a random vector of size N, with random integer components between 'a' and 'b' inclusive
 
 ### class Matrix
--
-    - This class represents a matrix of arbitrary size and operations on it.
+
+- This class represents a matrix of arbitrary size and operations on it.
 
     **Overview of the methods:**
 
-    -  \_\_str\_\_() : returns a string representation
-    - operator * : implements the matrix vector multiplication
-                   implements the matrix-scalar multiplication.
-    - change_component(x, y, value) : changes the specified component.
-    - component(x, y) : returns the specified component.
-    - width() : returns the width of the matrix
-    - height() : returns the height of the matrix
-    - determinant() : returns the determinant of the matrix if it is square
-    - operator + : implements the matrix-addition.
-    - operator - : implements the matrix-subtraction
+  - `__str__`() : returns a string representation
+  - operator * :
+    - implements the matrix vector multiplication
+    - implements the matrix-scalar multiplication.
+  - change_component(x, y, value) : changes the specified component.
+  - component(x, y) : returns the specified component.
+  - width() : returns the width of the matrix
+  - height() : returns the height of the matrix
+  - determinant() : returns the determinant of the matrix if it is square
+  - operator + : implements the matrix-addition.
+  - operator - : implements the matrix-subtraction
 
 - function square_zero_matrix(N)
-    - returns a square zero-matrix of dimension NxN
+  - returns a square zero-matrix of dimension NxN
 - function random_matrix(W, H, a, b)
-    - returns a random matrix WxH with integer components between 'a' and 'b' inclusive
+  - returns a random matrix WxH with integer components between 'a' and 'b' inclusive
+
 ---
 
 ## Documentation

machine_learning/README.md

@@ -0,0 +1,6 @@
+# Machine Learning
+
+Machine learning is a way to create AI using sample ('training') data.
+It works by making the computer build a model based on this data in order to predict the outcome when given unknown input.
+
+* <https://en.wikipedia.org/wiki/Machine_learning>

maths/README.md

@@ -0,0 +1,6 @@
+# Math
+
+A large collection of algorithms used in math, as well as some standard functions.
+
+* <https://en.wikipedia.org/wiki/Mathematics>
+* <https://en.wikipedia.org/wiki/Function_(mathematics)>

matrix/README.md

@@ -0,0 +1,6 @@
+# Matrix
+
+A matrix is a rectangular array of objects and a matrix represent a mathematical object such as a system of linear differential equations, geometric transformations or graphs.
+
+* <https://en.wikipedia.org/wiki/Matrix_(mathematics)>
+* <https://en.wikipedia.org/wiki/Linear_differential_equation>

networking_flow/README.md

@@ -0,0 +1,6 @@
+# Networking flow
+
+>In graph theory, a flow network is a directed graph. [...] A network can be used to model traffic in a computer network, circulation with demands, fluids in pipes, currents in an electrical circuit, or anything similar in which something travels through a network of nodes.
+
+* <https://en.wikipedia.org/wiki/Flow_network>
+* <https://en.wikipedia.org/wiki/Maximum_flow_problem>

neural_network/README.md

@@ -0,0 +1,8 @@
+# Neural Network
+
+A neural network is a network of neurons (nodes) arranged in layers and connected by synapses with a weight affected to each of those connections.
+The weight of the synapses will change the behavior of the network.
+
+They are typically used in applications where they can be trained with a dataset of information and expected output.
+
+* <https://en.wikipedia.org/wiki/Neural_network>

physics/README.md

@@ -0,0 +1,3 @@
+# Physics
+
+Algorithm(s) with direct use in physics

project_euler/README.md

@@ -1,13 +1,12 @@
 # Project Euler
 
-Problems are taken from https://projecteuler.net/, the Project Euler. [Problems are licensed under CC BY-NC-SA 4.0](https://projecteuler.net/copyright).
+Problems are taken from <https://projecteuler.net/>, the Project Euler. [Problems are licensed under CC BY-NC-SA 4.0](https://projecteuler.net/copyright).
 
 Project Euler is a series of challenging mathematical/computer programming problems that require more than just mathematical
 insights to solve. Project Euler is ideal for mathematicians who are learning to code.
 
 The solutions will be checked by our [automated testing on Travis CI](https://travis-ci.com/github/TheAlgorithms/Python/pull_requests) with the help of [this script](https://github.com/TheAlgorithms/Python/blob/master/scripts/validate_solutions.py). The efficiency of your code is also checked. You can view the top 10 slowest solutions on Travis CI logs (under `slowest 10 durations`) and open a pull request to improve those solutions.
 
-
 ## Solution Guidelines
 
 Welcome to [TheAlgorithms/Python](https://github.com/TheAlgorithms/Python)! Before reading the solution guidelines, make sure you read the whole [Contributing Guidelines](https://github.com/TheAlgorithms/Python/blob/master/CONTRIBUTING.md) as it won't be repeated in here. If you have any doubt on the guidelines, please feel free to [state it clearly in an issue](https://github.com/TheAlgorithms/Python/issues/new) or ask the community in [Gitter](https://gitter.im/TheAlgorithms). You can use the [template](https://github.com/TheAlgorithms/Python/blob/master/project_euler/README.md#solution-template) we have provided below as your starting point but be sure to read the [Coding Style](https://github.com/TheAlgorithms/Python/blob/master/project_euler/README.md#coding-style) part first.
@@ -23,7 +22,7 @@ Welcome to [TheAlgorithms/Python](https://github.com/TheAlgorithms/Python)! Befo
 
 * All imports should come ***after*** the module-level docstring.
 
-* You can have as many helper functions as you want but there should be one main function called `solution` which should satisfy the conditions as stated below:
+* You can have as many helper functions as you want, but there should be one main function called `solution` which should satisfy the conditions as stated below:
   * It should contain positional argument(s) whose default value is the question input. Example: Please take a look at [Problem 1](https://projecteuler.net/problem=1) where the question is to *Find the sum of all the multiples of 3 or 5 below 1000.* In this case the main solution function will be `solution(limit: int = 1000)`.
   * When the `solution` function is called without any arguments like so: `solution()`, it should return the answer to the problem.
 
@@ -49,7 +48,7 @@ Welcome to [TheAlgorithms/Python](https://github.com/TheAlgorithms/Python)! Befo
 
 ### Solution Template
 
-You can use the below template as your starting point but please read the [Coding Style](https://github.com/TheAlgorithms/Python/blob/master/project_euler/README.md#coding-style) first to understand how the template works.
+You can use the below template as your starting point, but please read the [Coding Style](https://github.com/TheAlgorithms/Python/blob/master/project_euler/README.md#coding-style) first to understand how the template works.
 
 Please change the name of the helper functions accordingly, change the parameter names with a descriptive one, replace the content within `[square brackets]` (including the brackets) with the appropriate content.