diff --git a/.coveragerc b/.coveragerc
deleted file mode 100644
index f7e6eb212bc8..000000000000
--- a/.coveragerc
+++ /dev/null
@@ -1,4 +0,0 @@
-[report]
-sort = Cover
-omit =
- .env/*
diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
new file mode 100644
index 000000000000..a0bd05f47ec8
--- /dev/null
+++ b/.devcontainer/Dockerfile
@@ -0,0 +1,8 @@
+# https://github.com/microsoft/vscode-dev-containers/blob/main/containers/python-3/README.md
+ARG VARIANT=3.13-bookworm
+FROM mcr.microsoft.com/vscode/devcontainers/python:${VARIANT}
+COPY requirements.txt /tmp/pip-tmp/
+RUN python3 -m pip install --upgrade pip \
+ && python3 -m pip install --no-cache-dir install -r /tmp/pip-tmp/requirements.txt \
+ && pipx install pre-commit ruff \
+ && pre-commit install
diff --git a/.devcontainer/README.md b/.devcontainer/README.md
new file mode 100644
index 000000000000..ec3cdb61de7a
--- /dev/null
+++ b/.devcontainer/README.md
@@ -0,0 +1 @@
+https://code.visualstudio.com/docs/devcontainers/tutorial
diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
new file mode 100644
index 000000000000..e23263f5b9de
--- /dev/null
+++ b/.devcontainer/devcontainer.json
@@ -0,0 +1,42 @@
+{
+ "name": "Python 3",
+ "build": {
+ "dockerfile": "Dockerfile",
+ "context": "..",
+ "args": {
+ // Update 'VARIANT' to pick a Python version: 3, 3.11, 3.10, 3.9, 3.8
+ // Append -bullseye or -buster to pin to an OS version.
+ // Use -bullseye variants on local on arm64/Apple Silicon.
+ "VARIANT": "3.13-bookworm",
+ }
+ },
+
+ // Configure tool-specific properties.
+ "customizations": {
+ // Configure properties specific to VS Code.
+ "vscode": {
+ // Set *default* container specific settings.json values on container create.
+ "settings": {
+ "python.defaultInterpreterPath": "/usr/local/bin/python",
+ "python.linting.enabled": true,
+ "python.formatting.blackPath": "/usr/local/py-utils/bin/black",
+ "python.linting.mypyPath": "/usr/local/py-utils/bin/mypy"
+ },
+
+ // Add the IDs of extensions you want installed when the container is created.
+ "extensions": [
+ "ms-python.python",
+ "ms-python.vscode-pylance"
+ ]
+ }
+ },
+
+ // Use 'forwardPorts' to make a list of ports inside the container available locally.
+ // "forwardPorts": [],
+
+ // Use 'postCreateCommand' to run commands after the container is created.
+ // "postCreateCommand": "pip3 install --user -r requirements.txt",
+
+ // Comment out to connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
+ "remoteUser": "vscode"
+}
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 260b9704eda7..3cc25d1bae1c 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -7,9 +7,7 @@
# Order is important. The last matching pattern has the most precedence.
-/.* @cclauss @dhruvmanila
-
-# /arithmetic_analysis/
+/.* @cclauss
# /backtracking/
@@ -21,21 +19,21 @@
# /cellular_automata/
-# /ciphers/ @cclauss # TODO: Uncomment this line after Hacktoberfest
+# /ciphers/
# /compression/
# /computer_vision/
-# /conversions/ @cclauss # TODO: Uncomment this line after Hacktoberfest
+# /conversions/
-# /data_structures/ @cclauss # TODO: Uncomment this line after Hacktoberfest
+# /data_structures/
-/digital_image_processing/ @mateuszz0000
+# /digital_image_processing/
# /divide_and_conquer/
-/dynamic_programming/ @Kush1101
+# /dynamic_programming/
# /file_transfer/
@@ -59,7 +57,7 @@
# /machine_learning/
-/maths/ @Kush1101
+# /maths/
# /matrix/
@@ -67,9 +65,9 @@
# /neural_network/
-# /other/ @cclauss # TODO: Uncomment this line after Hacktoberfest
+# /other/
-/project_euler/ @dhruvmanila @Kush1101
+# /project_euler/
# /quantum/
@@ -79,9 +77,9 @@
# /searches/
-/sorts/ @mateuszz0000
+# /sorts/
-# /strings/ @cclauss # TODO: Uncomment this line after Hacktoberfest
+# /strings/
# /traversals/
diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
new file mode 100644
index 000000000000..4ccdb52cad24
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -0,0 +1,54 @@
+name: Bug report
+description: Create a bug report to help us address errors in the repository
+labels: [bug]
+body:
+ - type: markdown
+ attributes:
+ value: >
+ Before requesting please search [existing issues](https://github.com/TheAlgorithms/Python/labels/bug).
+ Usage questions such as "How do I...?" belong on the
+ [Discord](https://discord.gg/c7MnfGFGa6) and will be closed.
+
+ - type: input
+ attributes:
+ label: "Repository commit"
+ description: >
+ The commit hash for `TheAlgorithms/Python` repository. You can get this
+ by running the command `git rev-parse HEAD` locally.
+ placeholder: "a0b0f414ae134aa1772d33bb930e5a960f9979e8"
+ validations:
+ required: true
+
+ - type: input
+ attributes:
+ label: "Python version (python --version)"
+ placeholder: "Python 3.10.7"
+ validations:
+ required: true
+
+ - type: textarea
+ attributes:
+ label: "Dependencies version (pip freeze)"
+ description: >
+ This is the output of the command `pip freeze --all`. Note that the
+ actual output might be different as compared to the placeholder text.
+ placeholder: |
+ appnope==0.1.3
+ asttokens==2.0.8
+ backcall==0.2.0
+ ...
+ validations:
+ required: true
+
+ - type: textarea
+ attributes:
+ label: "Expected behavior"
+ description: "Describe the behavior you expect. May include images or videos."
+ validations:
+ required: true
+
+ - type: textarea
+ attributes:
+ label: "Actual behavior"
+ validations:
+ required: true
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 000000000000..62019bb08938
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+ - name: Discord community
+ url: https://discord.gg/c7MnfGFGa6
+ about: Have any questions or need any help? Please contact us via Discord
diff --git a/.github/ISSUE_TEMPLATE/feature_request.yml b/.github/ISSUE_TEMPLATE/feature_request.yml
new file mode 100644
index 000000000000..20823bd58ab1
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.yml
@@ -0,0 +1,19 @@
+name: Feature request
+description: Suggest features, propose improvements, discuss new ideas.
+labels: [enhancement]
+body:
+ - type: markdown
+ attributes:
+ value: >
+ Before requesting please search [existing issues](https://github.com/TheAlgorithms/Python/labels/enhancement).
+ Do not create issues to implement new algorithms as these will be closed.
+ Usage questions such as "How do I...?" belong on the
+ [Discord](https://discord.gg/c7MnfGFGa6) and will be closed.
+
+ - type: textarea
+ attributes:
+ label: "Feature description"
+ description: >
+ This could include new topics or improving any existing implementations.
+ validations:
+ required: true
diff --git a/.github/ISSUE_TEMPLATE/other.yml b/.github/ISSUE_TEMPLATE/other.yml
new file mode 100644
index 000000000000..44d6ff541506
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/other.yml
@@ -0,0 +1,19 @@
+name: Other
+description: Use this for any other issues. PLEASE do not create blank issues
+labels: ["awaiting triage"]
+body:
+ - type: textarea
+ id: issuedescription
+ attributes:
+ label: What would you like to share?
+ description: Provide a clear and concise explanation of your issue.
+ validations:
+ required: true
+
+ - type: textarea
+ id: extrainfo
+ attributes:
+ label: Additional information
+ description: Is there anything else we should know about this issue?
+ validations:
+ required: false
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 000000000000..15e494ec867e
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,8 @@
+# Keep GitHub Actions up to date with Dependabot...
+# https://docs.github.com/en/code-security/dependabot/working-with-dependabot/keeping-your-actions-up-to-date-with-dependabot
+version: 2
+updates:
+ - package-ecosystem: "github-actions"
+ directory: "/"
+ schedule:
+ interval: "daily"
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 103ecf7c288a..e2ae0966cda5 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,12 +1,13 @@
-### **Describe your change:**
+### Describe your change:
* [ ] Add an algorithm?
* [ ] Fix a bug or typo in an existing algorithm?
+* [ ] Add or change doctests? -- Note: Please avoid changing both code and tests in a single pull request.
* [ ] Documentation change?
-### **Checklist:**
+### Checklist:
* [ ] I have read [CONTRIBUTING.md](https://github.com/TheAlgorithms/Python/blob/master/CONTRIBUTING.md).
* [ ] This pull request is all my own work -- I have not plagiarized.
* [ ] I know that pull requests will not be merged if they fail the automated tests.
@@ -16,5 +17,5 @@
* [ ] All functions and variable names follow Python naming conventions.
* [ ] All function parameters and return values are annotated with Python [type hints](https://docs.python.org/3/library/typing.html).
* [ ] All functions have [doctests](https://docs.python.org/3/library/doctest.html) that pass the automated testing.
-* [ ] All new algorithms have a URL in its comments that points to Wikipedia or other similar explanation.
-* [ ] If this pull request resolves one or more open issues then the commit message contains `Fixes: #{$ISSUE_NO}`.
+* [ ] All new algorithms include at least one URL that points to Wikipedia or another similar explanation.
+* [ ] If this pull request resolves one or more open issues then the description above includes the issue number(s) with a [closing keyword](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue): "Fixes #ISSUE-NUMBER".
diff --git a/.github/stale.yml b/.github/stale.yml
index ba6fd155d7a3..0939e1f223ff 100644
--- a/.github/stale.yml
+++ b/.github/stale.yml
@@ -27,7 +27,7 @@ exemptAssignees: false
staleLabel: stale
# Limit the number of actions per hour, from 1-30. Default is 30
-limitPerRun: 30
+limitPerRun: 5
# Comment to post when removing the stale label.
# unmarkComment: >
@@ -45,7 +45,7 @@ pulls:
closeComment: >
Please reopen this pull request once you commit the changes requested
or make improvements on the code. If this is not the case and you need
- some help, feel free to seek help from our [Gitter](https://gitter.im/TheAlgorithms)
+ some help, feel free to seek help from our [Gitter](https://gitter.im/TheAlgorithms/community)
or ping one of the reviewers. Thank you for your contributions!
issues:
@@ -59,5 +59,5 @@ issues:
closeComment: >
Please reopen this issue once you add more information and updates here.
If this is not the case and you need some help, feel free to seek help
- from our [Gitter](https://gitter.im/TheAlgorithms) or ping one of the
+ from our [Gitter](https://gitter.im/TheAlgorithms/community) or ping one of the
reviewers. Thank you for your contributions!
diff --git a/.github/workflows/auto_close_empty_issues.yml b/.github/workflows/auto_close_empty_issues.yml
deleted file mode 100644
index a6334d6ade32..000000000000
--- a/.github/workflows/auto_close_empty_issues.yml
+++ /dev/null
@@ -1,20 +0,0 @@
-# GitHub Action that uses close-issue auto-close empty issues after they are opened.
-# If the issue body text is empty the Action auto-closes it and sends a notification.
-# Otherwise if the issue body is not empty, it does nothing and the issue remains open.
-# https://github.com/marketplace/actions/close-issue
-
-name: auto_close_empty_issues
-on:
- issues:
- types: [opened]
-jobs:
- check-issue-body-not-empty:
- runs-on: ubuntu-latest
- steps:
- - if: github.event.issue.body == 0
- name: Close Issue
- uses: peter-evans/close-issue@v1
- with:
- comment: |
- Issue body must contain content.
- Auto-closing this issue.
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 01ac9aea7a7c..62829b2b45a5 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -9,19 +9,28 @@ jobs:
build:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@v2
- - uses: actions/setup-python@v2
+ - uses: actions/checkout@v4
+ - uses: astral-sh/setup-uv@v5
with:
- python-version: "3.8"
- - uses: actions/cache@v2
+ enable-cache: true
+ cache-dependency-glob: uv.lock
+ - uses: actions/setup-python@v5
with:
- path: ~/.cache/pip
- key: ${{ runner.os }}-pip-${{ hashFiles('requirements.txt') }}
- - name: Install dependencies
- run: |
- python -m pip install --upgrade pip setuptools six
- python -m pip install pytest-cov -r requirements.txt
+ python-version: 3.13
+ allow-prereleases: true
+ - run: uv sync --group=test
- name: Run tests
- run: pytest --doctest-modules --ignore=project_euler/ --cov-report=term-missing:skip-covered --cov=. .
+ # TODO: #8818 Re-enable quantum tests
+ run: uv run pytest
+ --ignore=computer_vision/cnn_classification.py
+ --ignore=docs/conf.py
+ --ignore=dynamic_programming/k_means_clustering_tensorflow.py
+ --ignore=machine_learning/lstm/lstm_prediction.py
+ --ignore=neural_network/input_data.py
+ --ignore=project_euler/
+ --ignore=quantum/q_fourier_transform.py
+ --ignore=scripts/validate_solutions.py
+ --cov-report=term-missing:skip-covered
+ --cov=. .
- if: ${{ success() }}
run: scripts/build_directory_md.py 2>&1 | tee DIRECTORY.md
diff --git a/.github/workflows/directory_writer.yml b/.github/workflows/directory_writer.yml
index be8154a32696..55d89f455a25 100644
--- a/.github/workflows/directory_writer.yml
+++ b/.github/workflows/directory_writer.yml
@@ -6,13 +6,17 @@ jobs:
build:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@v1 # v1, NOT v2
- - uses: actions/setup-python@v2
+ - uses: actions/checkout@v4
+ with:
+ fetch-depth: 0
+ - uses: actions/setup-python@v5
+ with:
+ python-version: 3.x
- name: Write DIRECTORY.md
run: |
scripts/build_directory_md.py 2>&1 | tee DIRECTORY.md
- git config --global user.name github-actions
- git config --global user.email '${GITHUB_ACTOR}@users.noreply.github.com'
+ git config --global user.name "$GITHUB_ACTOR"
+ git config --global user.email "$GITHUB_ACTOR@users.noreply.github.com"
git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
- name: Update DIRECTORY.md
run: |
diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml
deleted file mode 100644
index 96175cfecea5..000000000000
--- a/.github/workflows/pre-commit.yml
+++ /dev/null
@@ -1,21 +0,0 @@
-name: pre-commit
-
-on: [push, pull_request]
-
-jobs:
- pre-commit:
- runs-on: ubuntu-latest
- steps:
- - uses: actions/checkout@v2
- - uses: actions/cache@v2
- with:
- path: |
- ~/.cache/pre-commit
- ~/.cache/pip
- key: ${{ runner.os }}-pre-commit-${{ hashFiles('.pre-commit-config.yaml') }}
- - uses: actions/setup-python@v2
- - name: Install pre-commit
- run: |
- python -m pip install --upgrade pip
- python -m pip install --upgrade pre-commit
- - run: pre-commit run --verbose --all-files --show-diff-on-failure
diff --git a/.github/workflows/project_euler.yml b/.github/workflows/project_euler.yml
index e8b011af20a6..8d51ad8850cf 100644
--- a/.github/workflows/project_euler.yml
+++ b/.github/workflows/project_euler.yml
@@ -1,31 +1,35 @@
on:
pull_request:
- # only check if a file is changed within the project_euler directory and related files
+ # Run only if a file is changed within the project_euler directory and related files
paths:
- - 'project_euler/**'
- - '.github/workflows/project_euler.yml'
- - 'scripts/validate_solutions.py'
+ - "project_euler/**"
+ - ".github/workflows/project_euler.yml"
+ - "scripts/validate_solutions.py"
+ schedule:
+ - cron: "0 0 * * *" # Run everyday
-name: 'Project Euler'
+name: "Project Euler"
jobs:
project-euler:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@v2
- - uses: actions/setup-python@v2
- - name: Install pytest and pytest-cov
- run: |
- python -m pip install --upgrade pip
- python -m pip install --upgrade pytest pytest-cov
- - run: pytest --doctest-modules --cov-report=term-missing:skip-covered --cov=project_euler/ project_euler/
+ - uses: actions/checkout@v4
+ - uses: astral-sh/setup-uv@v5
+ - uses: actions/setup-python@v5
+ with:
+ python-version: 3.x
+ - run: uv sync --group=euler-validate --group=test
+ - run: uv run pytest --doctest-modules --cov-report=term-missing:skip-covered --cov=project_euler/ project_euler/
validate-solutions:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@v2
- - uses: actions/setup-python@v2
- - name: Install pytest
- run: |
- python -m pip install --upgrade pip
- python -m pip install --upgrade pytest
- - run: pytest scripts/validate_solutions.py
+ - uses: actions/checkout@v4
+ - uses: astral-sh/setup-uv@v5
+ - uses: actions/setup-python@v5
+ with:
+ python-version: 3.x
+ - run: uv sync --group=euler-validate --group=test
+ - run: uv run pytest scripts/validate_solutions.py
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/ruff.yml b/.github/workflows/ruff.yml
new file mode 100644
index 000000000000..cfe127b3521f
--- /dev/null
+++ b/.github/workflows/ruff.yml
@@ -0,0 +1,16 @@
+# https://beta.ruff.rs
+name: ruff
+on:
+ push:
+ branches:
+ - master
+ pull_request:
+ branches:
+ - master
+jobs:
+ ruff:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - uses: astral-sh/setup-uv@v5
+ - run: uvx ruff check --output-format=github .
diff --git a/.github/workflows/sphinx.yml b/.github/workflows/sphinx.yml
new file mode 100644
index 000000000000..16ff284a74f2
--- /dev/null
+++ b/.github/workflows/sphinx.yml
@@ -0,0 +1,50 @@
+name: sphinx
+
+on:
+ # Triggers the workflow on push or pull request events but only for the "master" branch
+ push:
+ branches: ["master"]
+ pull_request:
+ branches: ["master"]
+ # Or manually from the Actions tab
+ workflow_dispatch:
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+ contents: read
+ pages: write
+ id-token: write
+
+# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
+# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
+concurrency:
+ group: "pages"
+ cancel-in-progress: false
+
+jobs:
+ build_docs:
+ runs-on: ubuntu-24.04-arm
+ steps:
+ - uses: actions/checkout@v4
+ - uses: astral-sh/setup-uv@v5
+ - uses: actions/setup-python@v5
+ with:
+ python-version: 3.13
+ allow-prereleases: true
+ - run: uv sync --group=docs
+ - uses: actions/configure-pages@v5
+ - run: uv run sphinx-build -c docs . docs/_build/html
+ - uses: actions/upload-pages-artifact@v3
+ with:
+ path: docs/_build/html
+
+ deploy_docs:
+ environment:
+ name: github-pages
+ url: ${{ steps.deployment.outputs.page_url }}
+ if: github.event_name != 'pull_request'
+ needs: build_docs
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/deploy-pages@v4
+ id: deployment
diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml
deleted file mode 100644
index 42353d233a29..000000000000
--- a/.github/workflows/stale.yml
+++ /dev/null
@@ -1,31 +0,0 @@
-# name: Mark/Close stale issues and pull requests
-# on:
-# schedule:
-# - cron: "0 * * * *" # Run every hour
-# jobs:
-# stale:
-# runs-on: ubuntu-latest
-# steps:
-# - uses: actions/stale@v3.0.13
-# with:
-# repo-token: ${{ secrets.GITHUB_TOKEN }}
-# days-before-stale: 30
-# days-before-close: 7
-# stale-issue-message: >
-# This issue has been automatically marked as stale because it has not had
-# recent activity. It will be closed if no further activity occurs. Thank you
-# for your contributions.
-# close-issue-message: >
-# Please reopen this issue once you add more information and updates here.
-# If this is not the case and you need some help, feel free to seek help
-# from our [Gitter](https://gitter.im/TheAlgorithms) or ping one of the
-# reviewers. Thank you for your contributions!
-# stale-pr-message: >
-# This pull request has been automatically marked as stale because it has not had
-# recent activity. It will be closed if no further activity occurs. Thank you
-# for your contributions.
-# close-pr-message: >
-# Please reopen this pull request once you commit the changes requested
-# or make improvements on the code. If this is not the case and you need
-# some help, feel free to seek help from our [Gitter](https://gitter.im/TheAlgorithms)
-# or ping one of the reviewers. Thank you for your contributions!
diff --git a/.gitignore b/.gitignore
index 574cdf312836..baea84b8d1f1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -107,3 +107,4 @@ venv.bak/
.idea
.try
.vscode/
+.vs/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index a3288e1c5eef..0fc8b2b14e07 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,56 +1,38 @@
repos:
- repo: https://github.com/pre-commit/pre-commit-hooks
- rev: v3.2.0
+ rev: v5.0.0
hooks:
- id: check-executables-have-shebangs
+ - id: check-toml
- id: check-yaml
- id: end-of-file-fixer
types: [python]
- id: trailing-whitespace
- exclude: |
- (?x)^(
- data_structures/heap/binomial_heap.py
- )$
- id: requirements-txt-fixer
- - repo: https://github.com/psf/black
- rev: stable
+
+ - repo: https://github.com/MarcoGorelli/auto-walrus
+ rev: 0.3.4
hooks:
- - id: black
- - repo: https://github.com/PyCQA/isort
- rev: 5.5.3
+ - id: auto-walrus
+
+ - repo: https://github.com/astral-sh/ruff-pre-commit
+ rev: v0.11.2
hooks:
- - id: isort
- args:
- - --profile=black
- - repo: https://gitlab.com/pycqa/flake8
- rev: 3.8.3
- hooks:
- - id: flake8
- args:
- - --ignore=E203,W503
- - --max-complexity=25
- - --max-line-length=88
-# FIXME: fix mypy errors and then uncomment this
-# - repo: https://github.com/pre-commit/mirrors-mypy
-# rev: v0.782
-# hooks:
-# - id: mypy
-# args:
-# - --ignore-missing-imports
+ - id: ruff
+ - id: ruff-format
+
- repo: https://github.com/codespell-project/codespell
- rev: v1.17.1
+ rev: v2.4.1
hooks:
- id: codespell
- args:
- - --ignore-words-list=ans,fo,followings,hist,iff,mater,secant,som,tim
- - --skip="./.*,./other/dictionary.txt,./other/words,./project_euler/problem_022/p022_names.txt"
- - --quiet-level=2
- exclude: |
- (?x)^(
- other/dictionary.txt |
- other/words |
- project_euler/problem_022/p022_names.txt
- )$
+ additional_dependencies:
+ - tomli
+
+ - repo: https://github.com/tox-dev/pyproject-fmt
+ rev: "v2.5.1"
+ hooks:
+ - id: pyproject-fmt
+
- repo: local
hooks:
- id: validate-filenames
@@ -58,3 +40,25 @@ repos:
entry: ./scripts/validate_filenames.py
language: script
pass_filenames: false
+
+ - repo: https://github.com/abravalheri/validate-pyproject
+ rev: v0.24.1
+ hooks:
+ - id: validate-pyproject
+
+ - repo: https://github.com/pre-commit/mirrors-mypy
+ rev: v1.15.0
+ hooks:
+ - id: mypy
+ args:
+ - --explicit-package-bases
+ - --ignore-missing-imports
+ - --install-types # See mirrors-mypy README.md
+ - --non-interactive
+ additional_dependencies: [types-requests]
+
+ - repo: https://github.com/pre-commit/mirrors-prettier
+ rev: "v4.0.0-alpha.8"
+ hooks:
+ - id: prettier
+ types_or: [toml, yaml]
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 000000000000..ef16fa1aa7ac
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,5 @@
+{
+ "githubPullRequests.ignoredPullRequestBranches": [
+ "master"
+ ]
+}
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index eedcb0250169..3df39f95b784 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,30 +2,41 @@
## Before contributing
-Welcome to [TheAlgorithms/Python](https://github.com/TheAlgorithms/Python)! Before sending your pull requests, make sure that you **read the whole guidelines**. If you have any doubt on the contributing guide, 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).
+Welcome to [TheAlgorithms/Python](https://github.com/TheAlgorithms/Python)! Before submitting your pull requests, please ensure that you __read the whole guidelines__. If you have any doubts about the contributing guide, please feel free to [state it clearly in an issue](https://github.com/TheAlgorithms/Python/issues/new) or ask the community on [Gitter](https://gitter.im/TheAlgorithms/community).
## Contributing
### Contributor
-We are very happy that you consider implementing algorithms and data structure for others! This repository is referenced and used by learners from all over the globe. Being one of our contributors, you agree and confirm that:
+We are delighted that you are considering implementing algorithms and data structures for others! This repository is referenced and used by learners from all over the globe. By being one of our contributors, you agree and confirm that:
-- You did your work - no plagiarism allowed
+- You did your work - no plagiarism allowed.
- Any plagiarized work will not be merged.
-- Your work will be distributed under [MIT License](LICENSE.md) once your pull request is merged
-- You submitted work fulfils or mostly fulfils our styles and standards
+- Your work will be distributed under [MIT License](LICENSE.md) once your pull request is merged.
+- Your submitted work fulfills or mostly fulfills our styles and standards.
-**New implementation** is welcome! For example, new solutions for a problem, different representations for a graph data structure or algorithm designs with different complexity but **identical implementation** of an existing implementation is not allowed. Please check whether the solution is already implemented or not before submitting your pull request.
+__New implementation__ is welcome! For example, new solutions for a problem, different representations for a graph data structure or algorithm designs with different complexity, but __identical implementation__ of an existing implementation is not allowed. Please check whether the solution is already implemented or not before submitting your pull request.
-**Improving comments** and **writing proper tests** are also highly welcome.
+__Improving comments__ and __writing proper tests__ are also highly welcome.
### Contribution
We appreciate any contribution, from fixing a grammar mistake in a comment to implementing complex algorithms. Please read this section if you are contributing your work.
-Your contribution will be tested by our [automated testing on Travis CI](https://travis-ci.org/TheAlgorithms/Python/pull_requests) to save time and mental energy. After you have submitted your pull request, you should see the Travis tests start to run at the bottom of your submission page. If those tests fail, then click on the ___details___ button try to read through the Travis output to understand the failure. If you do not understand, please leave a comment on your submission page and a community member will try to help.
+Your contribution will be tested by our [automated testing on GitHub Actions](https://github.com/TheAlgorithms/Python/actions) to save time and mental energy. After you have submitted your pull request, you should see the GitHub Actions tests start to run at the bottom of your submission page. If those tests fail, then click on the ___details___ button to read through the GitHub Actions output to understand the failure. If you do not understand, please leave a comment on your submission page and a community member will try to help.
-Please help us keep our issue list small by adding fixes: #{$ISSUE_NO} to the commit message of pull requests that resolve open issues. GitHub will use this tag to auto close the issue when the PR is merged.
+#### Issues
+
+If you are interested in resolving an [open issue](https://github.com/TheAlgorithms/Python/issues), simply make a pull request with your proposed fix. __We do not assign issues in this repo__ so please do not ask for permission to work on an issue.
+
+__Do not__ create an issue to contribute an algorithm. Please submit a pull request instead.
+
+Please help us keep our issue list small by adding `Fixes #{$ISSUE_NUMBER}` to the description of pull requests that resolve open issues.
+For example, if your pull request fixes issue #10, then please add the following to its description:
+```
+Fixes #10
+```
+GitHub will use this tag to [auto-close the issue](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue) if and when the PR is merged.
#### What is an Algorithm?
@@ -33,7 +44,7 @@ An Algorithm is one or more functions (or classes) that:
* take one or more inputs,
* perform some internal calculations or data manipulations,
* return one or more outputs,
-* have minimal side effects (Ex. print(), plot(), read(), write()).
+* have minimal side effects (Ex. `print()`, `plot()`, `read()`, `write()`).
Algorithms should be packaged in a way that would make it easy for readers to put them into larger programs.
@@ -42,21 +53,34 @@ Algorithms should:
* use Python naming conventions and intuitive variable names to ease comprehension
* be flexible to take different input values
* have Python type hints for their input parameters and return values
-* raise Python exceptions (ValueError, etc.) on erroneous input values
+* raise Python exceptions (`ValueError`, etc.) on erroneous input values
* have docstrings with clear explanations and/or URLs to source materials
* contain doctests that test both valid and erroneous input values
* return all calculation results instead of printing or plotting them
-Algorithms in this repo should not be how-to examples for existing Python packages. Instead, they should perform internal calculations or manipulations to convert input values into different output values. Those calculations or manipulations can use data types, classes, or functions of existing Python packages but each algorithm in this repo should add unique value.
+Algorithms in this repo should not be how-to examples for existing Python packages. Instead, they should perform internal calculations or manipulations to convert input values into different output values. Those calculations or manipulations can use data types, classes, or functions of existing Python packages but each algorithm in this repo should add unique value.
+
+#### Pre-commit plugin
+Use [pre-commit](https://pre-commit.com/#installation) to automatically format your code to match our coding style:
+
+```bash
+python3 -m pip install pre-commit # only required the first time
+pre-commit install
+```
+That's it! The plugin will run every time you commit any changes. If there are any errors found during the run, fix them and commit those changes. You can even run the plugin manually on all files:
+
+```bash
+pre-commit run --all-files --show-diff-on-failure
+```
#### Coding Style
We want your work to be readable by others; therefore, we encourage you to note the following:
-- Please write in Python 3.7+. For instance: __print()__ is a function in Python 3 so __print "Hello"__ will _not_ work but __print("Hello")__ will.
-- Please focus hard on naming of functions, classes, and variables. Help your reader by using __descriptive names__ that can help you to remove redundant comments.
- - Single letter variable names are _old school_ so please avoid them unless their life only spans a few lines.
- - Expand acronyms because __gcd()__ is hard to understand but __greatest_common_divisor()__ is not.
+- Please write in Python 3.13+. For instance: `print()` is a function in Python 3 so `print "Hello"` will *not* work but `print("Hello")` will.
+- Please focus hard on the naming of functions, classes, and variables. Help your reader by using __descriptive names__ that can help you to remove redundant comments.
+ - Single letter variable names are *old school* so please avoid them unless their life only spans a few lines.
+ - Expand acronyms because `gcd()` is hard to understand but `greatest_common_divisor()` is not.
- Please follow the [Python Naming Conventions](https://pep8.org/#prescriptive-naming-conventions) so variable_names and function_names should be lower_case, CONSTANTS in UPPERCASE, ClassNames should be CamelCase, etc.
- We encourage the use of Python [f-strings](https://realpython.com/python-f-strings/#f-strings-a-new-and-improved-way-to-format-strings-in-python) where they make the code easier to read.
@@ -64,15 +88,15 @@ We want your work to be readable by others; therefore, we encourage you to note
- Please consider running [__psf/black__](https://github.com/python/black) on your Python file(s) before submitting your pull request. This is not yet a requirement but it does make your code more readable and automatically aligns it with much of [PEP 8](https://www.python.org/dev/peps/pep-0008/). There are other code formatters (autopep8, yapf) but the __black__ formatter is now hosted by the Python Software Foundation. To use it,
```bash
- pip3 install black # only required the first time
+ python3 -m pip install black # only required the first time
black .
```
-- All submissions will need to pass the test __flake8 . --ignore=E203,W503 --max-line-length=88__ before they will be accepted so if possible, try this test locally on your Python file(s) before submitting your pull request.
+- All submissions will need to pass the test `ruff .` before they will be accepted so if possible, try this test locally on your Python file(s) before submitting your pull request.
```bash
- pip3 install flake8 # only required the first time
- flake8 . --ignore=E203,W503 --max-line-length=88 --show-source
+ python3 -m pip install ruff # only required the first time
+ ruff check
```
- Original code submission require docstrings or comments to describe your work.
@@ -89,7 +113,7 @@ We want your work to be readable by others; therefore, we encourage you to note
This is too trivial. Comments are expected to be explanatory. For comments, you can write them above, on or below a line of code, as long as you are consistent within the same piece of code.
- We encourage you to put docstrings inside your functions but please pay attention to indentation of docstrings. The following is a good example:
+ We encourage you to put docstrings inside your functions but please pay attention to the indentation of docstrings. The following is a good example:
```python
def sum_ab(a, b):
@@ -121,7 +145,7 @@ We want your work to be readable by others; therefore, we encourage you to note
python3 -m doctest -v my_submission.py
```
- The use of the Python builtin __input()__ function is **not** encouraged:
+ The use of the Python built-in `input()` function is __not__ encouraged:
```python
input('Enter your input:')
@@ -129,7 +153,7 @@ We want your work to be readable by others; therefore, we encourage you to note
input = eval(input("Enter your input: "))
```
- However, if your code uses __input()__ then we encourage you to gracefully deal with leading and trailing whitespace in user input by adding __.strip()__ as in:
+ However, if your code uses `input()` then we encourage you to gracefully deal with leading and trailing whitespace in user input by adding `.strip()` as in:
```python
starting_value = int(input("Please enter a starting value: ").strip())
@@ -142,10 +166,12 @@ We want your work to be readable by others; therefore, we encourage you to note
return a + b
```
+ Instructions on how to install mypy can be found [here](https://github.com/python/mypy). Please use the command `mypy --ignore-missing-imports .` to test all files or `mypy --ignore-missing-imports path/to/file.py` to test a specific file.
+
- [__List comprehensions and generators__](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions) are preferred over the use of `lambda`, `map`, `filter`, `reduce` but the important thing is to demonstrate the power of Python in code that is easy to read and maintain.
- Avoid importing external libraries for basic algorithms. Only use those libraries for complicated algorithms.
-- If you need a third party module that is not in the file __requirements.txt__, please add it to that file as part of your submission.
+- If you need a third-party module that is not in the file __requirements.txt__, please add it to that file as part of your submission.
#### Other Requirements for Submissions
- If you are submitting code in the `project_euler/` directory, please also read [the dedicated Guideline](https://github.com/TheAlgorithms/Python/blob/master/project_euler/README.md) before contributing to our Project Euler library.
@@ -155,13 +181,13 @@ We want your work to be readable by others; therefore, we encourage you to note
- If possible, follow the standard *within* the folder you are submitting to.
- If you have modified/added code work, make sure the code compiles before submitting.
- If you have modified/added documentation work, ensure your language is concise and contains no grammar errors.
-- Do not update the README.md or DIRECTORY.md file which will be periodically autogenerated by our Travis CI processes.
+- Do not update the README.md or DIRECTORY.md file which will be periodically autogenerated by our GitHub Actions processes.
- Add a corresponding explanation to [Algorithms-Explanation](https://github.com/TheAlgorithms/Algorithms-Explanation) (Optional but recommended).
-- All submissions will be tested with [__mypy__](http://www.mypy-lang.org) so we encourage to add [__Python type hints__](https://docs.python.org/3/library/typing.html) where it makes sense to do so.
+- All submissions will be tested with [__mypy__](http://www.mypy-lang.org) so we encourage you to add [__Python type hints__](https://docs.python.org/3/library/typing.html) where it makes sense to do so.
- Most importantly,
- - **Be consistent in the use of these guidelines when submitting.**
- - **Join** [Gitter](https://gitter.im/TheAlgorithms) **now!**
+ - __Be consistent in the use of these guidelines when submitting.__
+ - __Join__ us on [Discord](https://discord.com/invite/c7MnfGFGa6) and [Gitter](https://gitter.im/TheAlgorithms/community) __now!__
- Happy coding!
Writer [@poyea](https://github.com/poyea), Jun 2019.
diff --git a/DIRECTORY.md b/DIRECTORY.md
index cd8f6fb8578c..1c02c191bd14 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -1,873 +1,1379 @@
-## Arithmetic Analysis
- * [Bisection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/bisection.py)
- * [Gaussian Elimination](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/gaussian_elimination.py)
- * [In Static Equilibrium](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/in_static_equilibrium.py)
- * [Intersection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/intersection.py)
- * [Lu Decomposition](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/lu_decomposition.py)
- * [Newton Forward Interpolation](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_forward_interpolation.py)
- * [Newton Method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_method.py)
- * [Newton Raphson](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_raphson.py)
- * [Secant Method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/secant_method.py)
+## Audio Filters
+ * [Butterworth Filter](audio_filters/butterworth_filter.py)
+ * [Iir Filter](audio_filters/iir_filter.py)
+ * [Show Response](audio_filters/show_response.py)
## Backtracking
- * [All Combinations](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_combinations.py)
- * [All Permutations](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_permutations.py)
- * [All Subsequences](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_subsequences.py)
- * [Coloring](https://github.com/TheAlgorithms/Python/blob/master/backtracking/coloring.py)
- * [Hamiltonian Cycle](https://github.com/TheAlgorithms/Python/blob/master/backtracking/hamiltonian_cycle.py)
- * [Knight Tour](https://github.com/TheAlgorithms/Python/blob/master/backtracking/knight_tour.py)
- * [Minimax](https://github.com/TheAlgorithms/Python/blob/master/backtracking/minimax.py)
- * [N Queens](https://github.com/TheAlgorithms/Python/blob/master/backtracking/n_queens.py)
- * [N Queens Math](https://github.com/TheAlgorithms/Python/blob/master/backtracking/n_queens_math.py)
- * [Rat In Maze](https://github.com/TheAlgorithms/Python/blob/master/backtracking/rat_in_maze.py)
- * [Sudoku](https://github.com/TheAlgorithms/Python/blob/master/backtracking/sudoku.py)
- * [Sum Of Subsets](https://github.com/TheAlgorithms/Python/blob/master/backtracking/sum_of_subsets.py)
+ * [All Combinations](backtracking/all_combinations.py)
+ * [All Permutations](backtracking/all_permutations.py)
+ * [All Subsequences](backtracking/all_subsequences.py)
+ * [Coloring](backtracking/coloring.py)
+ * [Combination Sum](backtracking/combination_sum.py)
+ * [Crossword Puzzle Solver](backtracking/crossword_puzzle_solver.py)
+ * [Generate Parentheses](backtracking/generate_parentheses.py)
+ * [Hamiltonian Cycle](backtracking/hamiltonian_cycle.py)
+ * [Knight Tour](backtracking/knight_tour.py)
+ * [Match Word Pattern](backtracking/match_word_pattern.py)
+ * [Minimax](backtracking/minimax.py)
+ * [N Queens](backtracking/n_queens.py)
+ * [N Queens Math](backtracking/n_queens_math.py)
+ * [Power Sum](backtracking/power_sum.py)
+ * [Rat In Maze](backtracking/rat_in_maze.py)
+ * [Sudoku](backtracking/sudoku.py)
+ * [Sum Of Subsets](backtracking/sum_of_subsets.py)
+ * [Word Break](backtracking/word_break.py)
+ * [Word Ladder](backtracking/word_ladder.py)
+ * [Word Search](backtracking/word_search.py)
## Bit Manipulation
- * [Binary And Operator](https://github.com/TheAlgorithms/Python/blob/master/bit_manipulation/binary_and_operator.py)
- * [Binary Or Operator](https://github.com/TheAlgorithms/Python/blob/master/bit_manipulation/binary_or_operator.py)
- * [Binary Xor Operator](https://github.com/TheAlgorithms/Python/blob/master/bit_manipulation/binary_xor_operator.py)
- * [Single Bit Manipulation Operations](https://github.com/TheAlgorithms/Python/blob/master/bit_manipulation/single_bit_manipulation_operations.py)
+ * [Binary And Operator](bit_manipulation/binary_and_operator.py)
+ * [Binary Coded Decimal](bit_manipulation/binary_coded_decimal.py)
+ * [Binary Count Setbits](bit_manipulation/binary_count_setbits.py)
+ * [Binary Count Trailing Zeros](bit_manipulation/binary_count_trailing_zeros.py)
+ * [Binary Or Operator](bit_manipulation/binary_or_operator.py)
+ * [Binary Shifts](bit_manipulation/binary_shifts.py)
+ * [Binary Twos Complement](bit_manipulation/binary_twos_complement.py)
+ * [Binary Xor Operator](bit_manipulation/binary_xor_operator.py)
+ * [Bitwise Addition Recursive](bit_manipulation/bitwise_addition_recursive.py)
+ * [Count 1S Brian Kernighan Method](bit_manipulation/count_1s_brian_kernighan_method.py)
+ * [Count Number Of One Bits](bit_manipulation/count_number_of_one_bits.py)
+ * [Excess 3 Code](bit_manipulation/excess_3_code.py)
+ * [Find Previous Power Of Two](bit_manipulation/find_previous_power_of_two.py)
+ * [Gray Code Sequence](bit_manipulation/gray_code_sequence.py)
+ * [Highest Set Bit](bit_manipulation/highest_set_bit.py)
+ * [Index Of Rightmost Set Bit](bit_manipulation/index_of_rightmost_set_bit.py)
+ * [Is Even](bit_manipulation/is_even.py)
+ * [Is Power Of Two](bit_manipulation/is_power_of_two.py)
+ * [Largest Pow Of Two Le Num](bit_manipulation/largest_pow_of_two_le_num.py)
+ * [Missing Number](bit_manipulation/missing_number.py)
+ * [Numbers Different Signs](bit_manipulation/numbers_different_signs.py)
+ * [Power Of 4](bit_manipulation/power_of_4.py)
+ * [Reverse Bits](bit_manipulation/reverse_bits.py)
+ * [Single Bit Manipulation Operations](bit_manipulation/single_bit_manipulation_operations.py)
+ * [Swap All Odd And Even Bits](bit_manipulation/swap_all_odd_and_even_bits.py)
## Blockchain
- * [Chinese Remainder Theorem](https://github.com/TheAlgorithms/Python/blob/master/blockchain/chinese_remainder_theorem.py)
- * [Diophantine Equation](https://github.com/TheAlgorithms/Python/blob/master/blockchain/diophantine_equation.py)
- * [Modular Division](https://github.com/TheAlgorithms/Python/blob/master/blockchain/modular_division.py)
+ * [Diophantine Equation](blockchain/diophantine_equation.py)
## Boolean Algebra
- * [Quine Mc Cluskey](https://github.com/TheAlgorithms/Python/blob/master/boolean_algebra/quine_mc_cluskey.py)
+ * [And Gate](boolean_algebra/and_gate.py)
+ * [Imply Gate](boolean_algebra/imply_gate.py)
+ * [Karnaugh Map Simplification](boolean_algebra/karnaugh_map_simplification.py)
+ * [Multiplexer](boolean_algebra/multiplexer.py)
+ * [Nand Gate](boolean_algebra/nand_gate.py)
+ * [Nimply Gate](boolean_algebra/nimply_gate.py)
+ * [Nor Gate](boolean_algebra/nor_gate.py)
+ * [Not Gate](boolean_algebra/not_gate.py)
+ * [Or Gate](boolean_algebra/or_gate.py)
+ * [Quine Mc Cluskey](boolean_algebra/quine_mc_cluskey.py)
+ * [Xnor Gate](boolean_algebra/xnor_gate.py)
+ * [Xor Gate](boolean_algebra/xor_gate.py)
## Cellular Automata
- * [One Dimensional](https://github.com/TheAlgorithms/Python/blob/master/cellular_automata/one_dimensional.py)
+ * [Conways Game Of Life](cellular_automata/conways_game_of_life.py)
+ * [Game Of Life](cellular_automata/game_of_life.py)
+ * [Langtons Ant](cellular_automata/langtons_ant.py)
+ * [Nagel Schrekenberg](cellular_automata/nagel_schrekenberg.py)
+ * [One Dimensional](cellular_automata/one_dimensional.py)
+ * [Wa Tor](cellular_automata/wa_tor.py)
## Ciphers
- * [A1Z26](https://github.com/TheAlgorithms/Python/blob/master/ciphers/a1z26.py)
- * [Affine Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/affine_cipher.py)
- * [Atbash](https://github.com/TheAlgorithms/Python/blob/master/ciphers/atbash.py)
- * [Base16](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base16.py)
- * [Base32](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base32.py)
- * [Base64 Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base64_cipher.py)
- * [Base85](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base85.py)
- * [Beaufort Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/beaufort_cipher.py)
- * [Brute Force Caesar Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/brute_force_caesar_cipher.py)
- * [Caesar Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/caesar_cipher.py)
- * [Cryptomath Module](https://github.com/TheAlgorithms/Python/blob/master/ciphers/cryptomath_module.py)
- * [Decrypt Caesar With Chi Squared](https://github.com/TheAlgorithms/Python/blob/master/ciphers/decrypt_caesar_with_chi_squared.py)
- * [Deterministic Miller Rabin](https://github.com/TheAlgorithms/Python/blob/master/ciphers/deterministic_miller_rabin.py)
- * [Diffie](https://github.com/TheAlgorithms/Python/blob/master/ciphers/diffie.py)
- * [Elgamal Key Generator](https://github.com/TheAlgorithms/Python/blob/master/ciphers/elgamal_key_generator.py)
- * [Enigma Machine2](https://github.com/TheAlgorithms/Python/blob/master/ciphers/enigma_machine2.py)
- * [Hill Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/hill_cipher.py)
- * [Mixed Keyword Cypher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/mixed_keyword_cypher.py)
- * [Mono Alphabetic Ciphers](https://github.com/TheAlgorithms/Python/blob/master/ciphers/mono_alphabetic_ciphers.py)
- * [Morse Code Implementation](https://github.com/TheAlgorithms/Python/blob/master/ciphers/morse_code_implementation.py)
- * [Onepad Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/onepad_cipher.py)
- * [Playfair Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/playfair_cipher.py)
- * [Porta Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/porta_cipher.py)
- * [Rabin Miller](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rabin_miller.py)
- * [Rail Fence Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rail_fence_cipher.py)
- * [Rot13](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rot13.py)
- * [Rsa Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_cipher.py)
- * [Rsa Factorization](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_factorization.py)
- * [Rsa Key Generator](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_key_generator.py)
- * [Shuffled Shift Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/shuffled_shift_cipher.py)
- * [Simple Keyword Cypher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/simple_keyword_cypher.py)
- * [Simple Substitution Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/simple_substitution_cipher.py)
- * [Trafid Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/trafid_cipher.py)
- * [Transposition Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/transposition_cipher.py)
- * [Transposition Cipher Encrypt Decrypt File](https://github.com/TheAlgorithms/Python/blob/master/ciphers/transposition_cipher_encrypt_decrypt_file.py)
- * [Vigenere Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/vigenere_cipher.py)
- * [Xor Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/xor_cipher.py)
+ * [A1Z26](ciphers/a1z26.py)
+ * [Affine Cipher](ciphers/affine_cipher.py)
+ * [Atbash](ciphers/atbash.py)
+ * [Autokey](ciphers/autokey.py)
+ * [Baconian Cipher](ciphers/baconian_cipher.py)
+ * [Base16](ciphers/base16.py)
+ * [Base32](ciphers/base32.py)
+ * [Base64 Cipher](ciphers/base64_cipher.py)
+ * [Base85](ciphers/base85.py)
+ * [Beaufort Cipher](ciphers/beaufort_cipher.py)
+ * [Bifid](ciphers/bifid.py)
+ * [Brute Force Caesar Cipher](ciphers/brute_force_caesar_cipher.py)
+ * [Caesar Cipher](ciphers/caesar_cipher.py)
+ * [Cryptomath Module](ciphers/cryptomath_module.py)
+ * [Decrypt Caesar With Chi Squared](ciphers/decrypt_caesar_with_chi_squared.py)
+ * [Deterministic Miller Rabin](ciphers/deterministic_miller_rabin.py)
+ * [Diffie](ciphers/diffie.py)
+ * [Diffie Hellman](ciphers/diffie_hellman.py)
+ * [Elgamal Key Generator](ciphers/elgamal_key_generator.py)
+ * [Enigma Machine2](ciphers/enigma_machine2.py)
+ * [Fractionated Morse Cipher](ciphers/fractionated_morse_cipher.py)
+ * [Gronsfeld Cipher](ciphers/gronsfeld_cipher.py)
+ * [Hill Cipher](ciphers/hill_cipher.py)
+ * [Mixed Keyword Cypher](ciphers/mixed_keyword_cypher.py)
+ * [Mono Alphabetic Ciphers](ciphers/mono_alphabetic_ciphers.py)
+ * [Morse Code](ciphers/morse_code.py)
+ * [Onepad Cipher](ciphers/onepad_cipher.py)
+ * [Permutation Cipher](ciphers/permutation_cipher.py)
+ * [Playfair Cipher](ciphers/playfair_cipher.py)
+ * [Polybius](ciphers/polybius.py)
+ * [Porta Cipher](ciphers/porta_cipher.py)
+ * [Rabin Miller](ciphers/rabin_miller.py)
+ * [Rail Fence Cipher](ciphers/rail_fence_cipher.py)
+ * [Rot13](ciphers/rot13.py)
+ * [Rsa Cipher](ciphers/rsa_cipher.py)
+ * [Rsa Factorization](ciphers/rsa_factorization.py)
+ * [Rsa Key Generator](ciphers/rsa_key_generator.py)
+ * [Running Key Cipher](ciphers/running_key_cipher.py)
+ * [Shuffled Shift Cipher](ciphers/shuffled_shift_cipher.py)
+ * [Simple Keyword Cypher](ciphers/simple_keyword_cypher.py)
+ * [Simple Substitution Cipher](ciphers/simple_substitution_cipher.py)
+ * [Transposition Cipher](ciphers/transposition_cipher.py)
+ * [Transposition Cipher Encrypt Decrypt File](ciphers/transposition_cipher_encrypt_decrypt_file.py)
+ * [Trifid Cipher](ciphers/trifid_cipher.py)
+ * [Vernam Cipher](ciphers/vernam_cipher.py)
+ * [Vigenere Cipher](ciphers/vigenere_cipher.py)
+ * [Xor Cipher](ciphers/xor_cipher.py)
## Compression
- * [Burrows Wheeler](https://github.com/TheAlgorithms/Python/blob/master/compression/burrows_wheeler.py)
- * [Huffman](https://github.com/TheAlgorithms/Python/blob/master/compression/huffman.py)
- * [Lempel Ziv](https://github.com/TheAlgorithms/Python/blob/master/compression/lempel_ziv.py)
- * [Lempel Ziv Decompress](https://github.com/TheAlgorithms/Python/blob/master/compression/lempel_ziv_decompress.py)
- * [Peak Signal To Noise Ratio](https://github.com/TheAlgorithms/Python/blob/master/compression/peak_signal_to_noise_ratio.py)
+ * [Burrows Wheeler](compression/burrows_wheeler.py)
+ * [Huffman](compression/huffman.py)
+ * [Lempel Ziv](compression/lempel_ziv.py)
+ * [Lempel Ziv Decompress](compression/lempel_ziv_decompress.py)
+ * [Lz77](compression/lz77.py)
+ * [Peak Signal To Noise Ratio](compression/peak_signal_to_noise_ratio.py)
+ * [Run Length Encoding](compression/run_length_encoding.py)
## Computer Vision
- * [Harriscorner](https://github.com/TheAlgorithms/Python/blob/master/computer_vision/harriscorner.py)
- * [Meanthreshold](https://github.com/TheAlgorithms/Python/blob/master/computer_vision/meanthreshold.py)
+ * [Cnn Classification](computer_vision/cnn_classification.py)
+ * [Flip Augmentation](computer_vision/flip_augmentation.py)
+ * [Haralick Descriptors](computer_vision/haralick_descriptors.py)
+ * [Harris Corner](computer_vision/harris_corner.py)
+ * [Horn Schunck](computer_vision/horn_schunck.py)
+ * [Intensity Based Segmentation](computer_vision/intensity_based_segmentation.py)
+ * [Mean Threshold](computer_vision/mean_threshold.py)
+ * [Mosaic Augmentation](computer_vision/mosaic_augmentation.py)
+ * [Pooling Functions](computer_vision/pooling_functions.py)
## Conversions
- * [Binary To Decimal](https://github.com/TheAlgorithms/Python/blob/master/conversions/binary_to_decimal.py)
- * [Binary To Octal](https://github.com/TheAlgorithms/Python/blob/master/conversions/binary_to_octal.py)
- * [Decimal To Any](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_any.py)
- * [Decimal To Binary](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_binary.py)
- * [Decimal To Binary Recursion](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_binary_recursion.py)
- * [Decimal To Hexadecimal](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_hexadecimal.py)
- * [Decimal To Octal](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_octal.py)
- * [Hexadecimal To Decimal](https://github.com/TheAlgorithms/Python/blob/master/conversions/hexadecimal_to_decimal.py)
- * [Molecular Chemistry](https://github.com/TheAlgorithms/Python/blob/master/conversions/molecular_chemistry.py)
- * [Prefix Conversions](https://github.com/TheAlgorithms/Python/blob/master/conversions/prefix_conversions.py)
- * [Roman To Integer](https://github.com/TheAlgorithms/Python/blob/master/conversions/roman_to_integer.py)
- * [Temperature Conversions](https://github.com/TheAlgorithms/Python/blob/master/conversions/temperature_conversions.py)
+ * [Astronomical Length Scale Conversion](conversions/astronomical_length_scale_conversion.py)
+ * [Binary To Decimal](conversions/binary_to_decimal.py)
+ * [Binary To Hexadecimal](conversions/binary_to_hexadecimal.py)
+ * [Binary To Octal](conversions/binary_to_octal.py)
+ * [Convert Number To Words](conversions/convert_number_to_words.py)
+ * [Decimal To Any](conversions/decimal_to_any.py)
+ * [Decimal To Binary](conversions/decimal_to_binary.py)
+ * [Decimal To Hexadecimal](conversions/decimal_to_hexadecimal.py)
+ * [Decimal To Octal](conversions/decimal_to_octal.py)
+ * [Energy Conversions](conversions/energy_conversions.py)
+ * [Excel Title To Column](conversions/excel_title_to_column.py)
+ * [Hex To Bin](conversions/hex_to_bin.py)
+ * [Hexadecimal To Decimal](conversions/hexadecimal_to_decimal.py)
+ * [Ipv4 Conversion](conversions/ipv4_conversion.py)
+ * [Length Conversion](conversions/length_conversion.py)
+ * [Molecular Chemistry](conversions/molecular_chemistry.py)
+ * [Octal To Binary](conversions/octal_to_binary.py)
+ * [Octal To Decimal](conversions/octal_to_decimal.py)
+ * [Octal To Hexadecimal](conversions/octal_to_hexadecimal.py)
+ * [Prefix Conversions](conversions/prefix_conversions.py)
+ * [Prefix Conversions String](conversions/prefix_conversions_string.py)
+ * [Pressure Conversions](conversions/pressure_conversions.py)
+ * [Rectangular To Polar](conversions/rectangular_to_polar.py)
+ * [Rgb Cmyk Conversion](conversions/rgb_cmyk_conversion.py)
+ * [Rgb Hsv Conversion](conversions/rgb_hsv_conversion.py)
+ * [Roman Numerals](conversions/roman_numerals.py)
+ * [Speed Conversions](conversions/speed_conversions.py)
+ * [Temperature Conversions](conversions/temperature_conversions.py)
+ * [Time Conversions](conversions/time_conversions.py)
+ * [Volume Conversions](conversions/volume_conversions.py)
+ * [Weight Conversion](conversions/weight_conversion.py)
## Data Structures
+ * Arrays
+ * [Equilibrium Index In Array](data_structures/arrays/equilibrium_index_in_array.py)
+ * [Find Triplets With 0 Sum](data_structures/arrays/find_triplets_with_0_sum.py)
+ * [Index 2D Array In 1D](data_structures/arrays/index_2d_array_in_1d.py)
+ * [Kth Largest Element](data_structures/arrays/kth_largest_element.py)
+ * [Median Two Array](data_structures/arrays/median_two_array.py)
+ * [Monotonic Array](data_structures/arrays/monotonic_array.py)
+ * [Pairs With Given Sum](data_structures/arrays/pairs_with_given_sum.py)
+ * [Permutations](data_structures/arrays/permutations.py)
+ * [Prefix Sum](data_structures/arrays/prefix_sum.py)
+ * [Product Sum](data_structures/arrays/product_sum.py)
+ * [Sparse Table](data_structures/arrays/sparse_table.py)
+ * [Sudoku Solver](data_structures/arrays/sudoku_solver.py)
* Binary Tree
- * [Avl Tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/avl_tree.py)
- * [Basic Binary Tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/basic_binary_tree.py)
- * [Binary Search Tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/binary_search_tree.py)
- * [Binary Search Tree Recursive](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/binary_search_tree_recursive.py)
- * [Binary Tree Mirror](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/binary_tree_mirror.py)
- * [Binary Tree Traversals](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/binary_tree_traversals.py)
- * [Fenwick Tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/fenwick_tree.py)
- * [Lazy Segment Tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/lazy_segment_tree.py)
- * [Lowest Common Ancestor](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/lowest_common_ancestor.py)
- * [Non Recursive Segment Tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/non_recursive_segment_tree.py)
- * [Number Of Possible Binary Trees](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/number_of_possible_binary_trees.py)
- * [Red Black Tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/red_black_tree.py)
- * [Segment Tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/segment_tree.py)
- * [Segment Tree Other](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/segment_tree_other.py)
- * [Treap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/treap.py)
+ * [Avl Tree](data_structures/binary_tree/avl_tree.py)
+ * [Basic Binary Tree](data_structures/binary_tree/basic_binary_tree.py)
+ * [Binary Search Tree](data_structures/binary_tree/binary_search_tree.py)
+ * [Binary Search Tree Recursive](data_structures/binary_tree/binary_search_tree_recursive.py)
+ * [Binary Tree Mirror](data_structures/binary_tree/binary_tree_mirror.py)
+ * [Binary Tree Node Sum](data_structures/binary_tree/binary_tree_node_sum.py)
+ * [Binary Tree Path Sum](data_structures/binary_tree/binary_tree_path_sum.py)
+ * [Binary Tree Traversals](data_structures/binary_tree/binary_tree_traversals.py)
+ * [Diameter Of Binary Tree](data_structures/binary_tree/diameter_of_binary_tree.py)
+ * [Diff Views Of Binary Tree](data_structures/binary_tree/diff_views_of_binary_tree.py)
+ * [Distribute Coins](data_structures/binary_tree/distribute_coins.py)
+ * [Fenwick Tree](data_structures/binary_tree/fenwick_tree.py)
+ * [Flatten Binarytree To Linkedlist](data_structures/binary_tree/flatten_binarytree_to_linkedlist.py)
+ * [Floor And Ceiling](data_structures/binary_tree/floor_and_ceiling.py)
+ * [Inorder Tree Traversal 2022](data_structures/binary_tree/inorder_tree_traversal_2022.py)
+ * [Is Sorted](data_structures/binary_tree/is_sorted.py)
+ * [Is Sum Tree](data_structures/binary_tree/is_sum_tree.py)
+ * [Lazy Segment Tree](data_structures/binary_tree/lazy_segment_tree.py)
+ * [Lowest Common Ancestor](data_structures/binary_tree/lowest_common_ancestor.py)
+ * [Maximum Fenwick Tree](data_structures/binary_tree/maximum_fenwick_tree.py)
+ * [Maximum Sum Bst](data_structures/binary_tree/maximum_sum_bst.py)
+ * [Merge Two Binary Trees](data_structures/binary_tree/merge_two_binary_trees.py)
+ * [Mirror Binary Tree](data_structures/binary_tree/mirror_binary_tree.py)
+ * [Non Recursive Segment Tree](data_structures/binary_tree/non_recursive_segment_tree.py)
+ * [Number Of Possible Binary Trees](data_structures/binary_tree/number_of_possible_binary_trees.py)
+ * [Red Black Tree](data_structures/binary_tree/red_black_tree.py)
+ * [Segment Tree](data_structures/binary_tree/segment_tree.py)
+ * [Segment Tree Other](data_structures/binary_tree/segment_tree_other.py)
+ * [Serialize Deserialize Binary Tree](data_structures/binary_tree/serialize_deserialize_binary_tree.py)
+ * [Symmetric Tree](data_structures/binary_tree/symmetric_tree.py)
+ * [Treap](data_structures/binary_tree/treap.py)
+ * [Wavelet Tree](data_structures/binary_tree/wavelet_tree.py)
* Disjoint Set
- * [Alternate Disjoint Set](https://github.com/TheAlgorithms/Python/blob/master/data_structures/disjoint_set/alternate_disjoint_set.py)
- * [Disjoint Set](https://github.com/TheAlgorithms/Python/blob/master/data_structures/disjoint_set/disjoint_set.py)
+ * [Alternate Disjoint Set](data_structures/disjoint_set/alternate_disjoint_set.py)
+ * [Disjoint Set](data_structures/disjoint_set/disjoint_set.py)
* Hashing
- * [Double Hash](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/double_hash.py)
- * [Hash Table](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/hash_table.py)
- * [Hash Table With Linked List](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/hash_table_with_linked_list.py)
+ * [Bloom Filter](data_structures/hashing/bloom_filter.py)
+ * [Double Hash](data_structures/hashing/double_hash.py)
+ * [Hash Map](data_structures/hashing/hash_map.py)
+ * [Hash Table](data_structures/hashing/hash_table.py)
+ * [Hash Table With Linked List](data_structures/hashing/hash_table_with_linked_list.py)
* Number Theory
- * [Prime Numbers](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/number_theory/prime_numbers.py)
- * [Quadratic Probing](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/quadratic_probing.py)
+ * [Prime Numbers](data_structures/hashing/number_theory/prime_numbers.py)
+ * [Quadratic Probing](data_structures/hashing/quadratic_probing.py)
+ * Tests
+ * [Test Hash Map](data_structures/hashing/tests/test_hash_map.py)
* Heap
- * [Binomial Heap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap/binomial_heap.py)
- * [Heap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap/heap.py)
- * [Heap Generic](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap/heap_generic.py)
- * [Max Heap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap/max_heap.py)
- * [Min Heap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap/min_heap.py)
- * [Randomized Heap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap/randomized_heap.py)
- * [Skew Heap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap/skew_heap.py)
+ * [Binomial Heap](data_structures/heap/binomial_heap.py)
+ * [Heap](data_structures/heap/heap.py)
+ * [Heap Generic](data_structures/heap/heap_generic.py)
+ * [Max Heap](data_structures/heap/max_heap.py)
+ * [Min Heap](data_structures/heap/min_heap.py)
+ * [Randomized Heap](data_structures/heap/randomized_heap.py)
+ * [Skew Heap](data_structures/heap/skew_heap.py)
+ * Kd Tree
+ * [Build Kdtree](data_structures/kd_tree/build_kdtree.py)
+ * Example
+ * [Example Usage](data_structures/kd_tree/example/example_usage.py)
+ * [Hypercube Points](data_structures/kd_tree/example/hypercube_points.py)
+ * [Kd Node](data_structures/kd_tree/kd_node.py)
+ * [Nearest Neighbour Search](data_structures/kd_tree/nearest_neighbour_search.py)
+ * Tests
+ * [Test Kdtree](data_structures/kd_tree/tests/test_kdtree.py)
* Linked List
- * [Circular Linked List](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/circular_linked_list.py)
- * [Deque Doubly](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/deque_doubly.py)
- * [Doubly Linked List](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/doubly_linked_list.py)
- * [Doubly Linked List Two](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/doubly_linked_list_two.py)
- * [From Sequence](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/from_sequence.py)
- * [Has Loop](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/has_loop.py)
- * [Is Palindrome](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/is_palindrome.py)
- * [Middle Element Of Linked List](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/middle_element_of_linked_list.py)
- * [Print Reverse](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/print_reverse.py)
- * [Singly Linked List](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/singly_linked_list.py)
- * [Skip List](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/skip_list.py)
- * [Swap Nodes](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/swap_nodes.py)
- * Queue
- * [Circular Queue](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/circular_queue.py)
- * [Double Ended Queue](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/double_ended_queue.py)
- * [Linked Queue](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/linked_queue.py)
- * [Priority Queue Using List](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/priority_queue_using_list.py)
- * [Queue On List](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/queue_on_list.py)
- * [Queue On Pseudo Stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/queue_on_pseudo_stack.py)
+ * [Circular Linked List](data_structures/linked_list/circular_linked_list.py)
+ * [Deque Doubly](data_structures/linked_list/deque_doubly.py)
+ * [Doubly Linked List](data_structures/linked_list/doubly_linked_list.py)
+ * [Doubly Linked List Two](data_structures/linked_list/doubly_linked_list_two.py)
+ * [Floyds Cycle Detection](data_structures/linked_list/floyds_cycle_detection.py)
+ * [From Sequence](data_structures/linked_list/from_sequence.py)
+ * [Has Loop](data_structures/linked_list/has_loop.py)
+ * [Is Palindrome](data_structures/linked_list/is_palindrome.py)
+ * [Merge Two Lists](data_structures/linked_list/merge_two_lists.py)
+ * [Middle Element Of Linked List](data_structures/linked_list/middle_element_of_linked_list.py)
+ * [Print Reverse](data_structures/linked_list/print_reverse.py)
+ * [Reverse K Group](data_structures/linked_list/reverse_k_group.py)
+ * [Rotate To The Right](data_structures/linked_list/rotate_to_the_right.py)
+ * [Singly Linked List](data_structures/linked_list/singly_linked_list.py)
+ * [Skip List](data_structures/linked_list/skip_list.py)
+ * [Swap Nodes](data_structures/linked_list/swap_nodes.py)
+ * Queues
+ * [Circular Queue](data_structures/queues/circular_queue.py)
+ * [Circular Queue Linked List](data_structures/queues/circular_queue_linked_list.py)
+ * [Double Ended Queue](data_structures/queues/double_ended_queue.py)
+ * [Linked Queue](data_structures/queues/linked_queue.py)
+ * [Priority Queue Using List](data_structures/queues/priority_queue_using_list.py)
+ * [Queue By List](data_structures/queues/queue_by_list.py)
+ * [Queue By Two Stacks](data_structures/queues/queue_by_two_stacks.py)
+ * [Queue On Pseudo Stack](data_structures/queues/queue_on_pseudo_stack.py)
* Stacks
- * [Balanced Parentheses](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/balanced_parentheses.py)
- * [Dijkstras Two Stack Algorithm](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/dijkstras_two_stack_algorithm.py)
- * [Evaluate Postfix Notations](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/evaluate_postfix_notations.py)
- * [Infix To Postfix Conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/infix_to_postfix_conversion.py)
- * [Infix To Prefix Conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/infix_to_prefix_conversion.py)
- * [Linked Stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/linked_stack.py)
- * [Next Greater Element](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/next_greater_element.py)
- * [Postfix Evaluation](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/postfix_evaluation.py)
- * [Prefix Evaluation](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/prefix_evaluation.py)
- * [Stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/stack.py)
- * [Stack Using Dll](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/stack_using_dll.py)
- * [Stock Span Problem](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/stock_span_problem.py)
+ * [Balanced Parentheses](data_structures/stacks/balanced_parentheses.py)
+ * [Dijkstras Two Stack Algorithm](data_structures/stacks/dijkstras_two_stack_algorithm.py)
+ * [Infix To Postfix Conversion](data_structures/stacks/infix_to_postfix_conversion.py)
+ * [Infix To Prefix Conversion](data_structures/stacks/infix_to_prefix_conversion.py)
+ * [Largest Rectangle Histogram](data_structures/stacks/largest_rectangle_histogram.py)
+ * [Lexicographical Numbers](data_structures/stacks/lexicographical_numbers.py)
+ * [Next Greater Element](data_structures/stacks/next_greater_element.py)
+ * [Postfix Evaluation](data_structures/stacks/postfix_evaluation.py)
+ * [Prefix Evaluation](data_structures/stacks/prefix_evaluation.py)
+ * [Stack](data_structures/stacks/stack.py)
+ * [Stack Using Two Queues](data_structures/stacks/stack_using_two_queues.py)
+ * [Stack With Doubly Linked List](data_structures/stacks/stack_with_doubly_linked_list.py)
+ * [Stack With Singly Linked List](data_structures/stacks/stack_with_singly_linked_list.py)
+ * [Stock Span Problem](data_structures/stacks/stock_span_problem.py)
+ * Suffix Tree
+ * Example
+ * [Example Usage](data_structures/suffix_tree/example/example_usage.py)
+ * [Suffix Tree](data_structures/suffix_tree/suffix_tree.py)
+ * [Suffix Tree Node](data_structures/suffix_tree/suffix_tree_node.py)
+ * Tests
+ * [Test Suffix Tree](data_structures/suffix_tree/tests/test_suffix_tree.py)
* Trie
- * [Trie](https://github.com/TheAlgorithms/Python/blob/master/data_structures/trie/trie.py)
+ * [Radix Tree](data_structures/trie/radix_tree.py)
+ * [Trie](data_structures/trie/trie.py)
## Digital Image Processing
- * [Change Brightness](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/change_brightness.py)
- * [Change Contrast](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/change_contrast.py)
- * [Convert To Negative](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/convert_to_negative.py)
+ * [Change Brightness](digital_image_processing/change_brightness.py)
+ * [Change Contrast](digital_image_processing/change_contrast.py)
+ * [Convert To Negative](digital_image_processing/convert_to_negative.py)
* Dithering
- * [Burkes](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/dithering/burkes.py)
+ * [Burkes](digital_image_processing/dithering/burkes.py)
* Edge Detection
- * [Canny](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/edge_detection/canny.py)
+ * [Canny](digital_image_processing/edge_detection/canny.py)
* Filters
- * [Bilateral Filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/bilateral_filter.py)
- * [Convolve](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/convolve.py)
- * [Gaussian Filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/gaussian_filter.py)
- * [Median Filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/median_filter.py)
- * [Sobel Filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/sobel_filter.py)
+ * [Bilateral Filter](digital_image_processing/filters/bilateral_filter.py)
+ * [Convolve](digital_image_processing/filters/convolve.py)
+ * [Gabor Filter](digital_image_processing/filters/gabor_filter.py)
+ * [Gaussian Filter](digital_image_processing/filters/gaussian_filter.py)
+ * [Laplacian Filter](digital_image_processing/filters/laplacian_filter.py)
+ * [Local Binary Pattern](digital_image_processing/filters/local_binary_pattern.py)
+ * [Median Filter](digital_image_processing/filters/median_filter.py)
+ * [Sobel Filter](digital_image_processing/filters/sobel_filter.py)
* Histogram Equalization
- * [Histogram Stretch](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/histogram_equalization/histogram_stretch.py)
- * [Index Calculation](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/index_calculation.py)
+ * [Histogram Stretch](digital_image_processing/histogram_equalization/histogram_stretch.py)
+ * [Index Calculation](digital_image_processing/index_calculation.py)
+ * Morphological Operations
+ * [Dilation Operation](digital_image_processing/morphological_operations/dilation_operation.py)
+ * [Erosion Operation](digital_image_processing/morphological_operations/erosion_operation.py)
* Resize
- * [Resize](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/resize/resize.py)
+ * [Resize](digital_image_processing/resize/resize.py)
* Rotation
- * [Rotation](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/rotation/rotation.py)
- * [Sepia](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/sepia.py)
- * [Test Digital Image Processing](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/test_digital_image_processing.py)
+ * [Rotation](digital_image_processing/rotation/rotation.py)
+ * [Sepia](digital_image_processing/sepia.py)
+ * [Test Digital Image Processing](digital_image_processing/test_digital_image_processing.py)
## Divide And Conquer
- * [Closest Pair Of Points](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/closest_pair_of_points.py)
- * [Convex Hull](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/convex_hull.py)
- * [Heaps Algorithm](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/heaps_algorithm.py)
- * [Heaps Algorithm Iterative](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/heaps_algorithm_iterative.py)
- * [Inversions](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/inversions.py)
- * [Kth Order Statistic](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/kth_order_statistic.py)
- * [Max Subarray Sum](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/max_subarray_sum.py)
- * [Mergesort](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/mergesort.py)
- * [Peak](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/peak.py)
- * [Power](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/power.py)
- * [Strassen Matrix Multiplication](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/strassen_matrix_multiplication.py)
+ * [Closest Pair Of Points](divide_and_conquer/closest_pair_of_points.py)
+ * [Convex Hull](divide_and_conquer/convex_hull.py)
+ * [Heaps Algorithm](divide_and_conquer/heaps_algorithm.py)
+ * [Heaps Algorithm Iterative](divide_and_conquer/heaps_algorithm_iterative.py)
+ * [Inversions](divide_and_conquer/inversions.py)
+ * [Kth Order Statistic](divide_and_conquer/kth_order_statistic.py)
+ * [Max Difference Pair](divide_and_conquer/max_difference_pair.py)
+ * [Max Subarray](divide_and_conquer/max_subarray.py)
+ * [Mergesort](divide_and_conquer/mergesort.py)
+ * [Peak](divide_and_conquer/peak.py)
+ * [Power](divide_and_conquer/power.py)
+ * [Strassen Matrix Multiplication](divide_and_conquer/strassen_matrix_multiplication.py)
+
+## Docs
+ * [Conf](docs/conf.py)
## Dynamic Programming
- * [Abbreviation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/abbreviation.py)
- * [Bitmask](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/bitmask.py)
- * [Climbing Stairs](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/climbing_stairs.py)
- * [Coin Change](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/coin_change.py)
- * [Edit Distance](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/edit_distance.py)
- * [Factorial](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/factorial.py)
- * [Fast Fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fast_fibonacci.py)
- * [Fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fibonacci.py)
- * [Floyd Warshall](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/floyd_warshall.py)
- * [Fractional Knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fractional_knapsack.py)
- * [Fractional Knapsack 2](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fractional_knapsack_2.py)
- * [Integer Partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/integer_partition.py)
- * [Iterating Through Submasks](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/iterating_through_submasks.py)
- * [Knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/knapsack.py)
- * [Longest Common Subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_common_subsequence.py)
- * [Longest Increasing Subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence.py)
- * [Longest Increasing Subsequence O(Nlogn)](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence_o(nlogn).py)
- * [Longest Sub Array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_sub_array.py)
- * [Matrix Chain Order](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/matrix_chain_order.py)
- * [Max Non Adjacent Sum](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/max_non_adjacent_sum.py)
- * [Max Sub Array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/max_sub_array.py)
- * [Max Sum Contiguous Subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/max_sum_contiguous_subsequence.py)
- * [Minimum Cost Path](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/minimum_cost_path.py)
- * [Minimum Partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/minimum_partition.py)
- * [Optimal Binary Search Tree](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/optimal_binary_search_tree.py)
- * [Rod Cutting](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/rod_cutting.py)
- * [Subset Generation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/subset_generation.py)
- * [Sum Of Subset](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/sum_of_subset.py)
+ * [Abbreviation](dynamic_programming/abbreviation.py)
+ * [All Construct](dynamic_programming/all_construct.py)
+ * [Bitmask](dynamic_programming/bitmask.py)
+ * [Catalan Numbers](dynamic_programming/catalan_numbers.py)
+ * [Climbing Stairs](dynamic_programming/climbing_stairs.py)
+ * [Combination Sum Iv](dynamic_programming/combination_sum_iv.py)
+ * [Edit Distance](dynamic_programming/edit_distance.py)
+ * [Factorial](dynamic_programming/factorial.py)
+ * [Fast Fibonacci](dynamic_programming/fast_fibonacci.py)
+ * [Fibonacci](dynamic_programming/fibonacci.py)
+ * [Fizz Buzz](dynamic_programming/fizz_buzz.py)
+ * [Floyd Warshall](dynamic_programming/floyd_warshall.py)
+ * [Integer Partition](dynamic_programming/integer_partition.py)
+ * [Iterating Through Submasks](dynamic_programming/iterating_through_submasks.py)
+ * [K Means Clustering Tensorflow](dynamic_programming/k_means_clustering_tensorflow.py)
+ * [Knapsack](dynamic_programming/knapsack.py)
+ * [Largest Divisible Subset](dynamic_programming/largest_divisible_subset.py)
+ * [Longest Common Subsequence](dynamic_programming/longest_common_subsequence.py)
+ * [Longest Common Substring](dynamic_programming/longest_common_substring.py)
+ * [Longest Increasing Subsequence](dynamic_programming/longest_increasing_subsequence.py)
+ * [Longest Increasing Subsequence Iterative](dynamic_programming/longest_increasing_subsequence_iterative.py)
+ * [Longest Increasing Subsequence O Nlogn](dynamic_programming/longest_increasing_subsequence_o_nlogn.py)
+ * [Longest Palindromic Subsequence](dynamic_programming/longest_palindromic_subsequence.py)
+ * [Matrix Chain Multiplication](dynamic_programming/matrix_chain_multiplication.py)
+ * [Matrix Chain Order](dynamic_programming/matrix_chain_order.py)
+ * [Max Non Adjacent Sum](dynamic_programming/max_non_adjacent_sum.py)
+ * [Max Product Subarray](dynamic_programming/max_product_subarray.py)
+ * [Max Subarray Sum](dynamic_programming/max_subarray_sum.py)
+ * [Min Distance Up Bottom](dynamic_programming/min_distance_up_bottom.py)
+ * [Minimum Coin Change](dynamic_programming/minimum_coin_change.py)
+ * [Minimum Cost Path](dynamic_programming/minimum_cost_path.py)
+ * [Minimum Partition](dynamic_programming/minimum_partition.py)
+ * [Minimum Size Subarray Sum](dynamic_programming/minimum_size_subarray_sum.py)
+ * [Minimum Squares To Represent A Number](dynamic_programming/minimum_squares_to_represent_a_number.py)
+ * [Minimum Steps To One](dynamic_programming/minimum_steps_to_one.py)
+ * [Minimum Tickets Cost](dynamic_programming/minimum_tickets_cost.py)
+ * [Optimal Binary Search Tree](dynamic_programming/optimal_binary_search_tree.py)
+ * [Palindrome Partitioning](dynamic_programming/palindrome_partitioning.py)
+ * [Range Sum Query](dynamic_programming/range_sum_query.py)
+ * [Regex Match](dynamic_programming/regex_match.py)
+ * [Rod Cutting](dynamic_programming/rod_cutting.py)
+ * [Smith Waterman](dynamic_programming/smith_waterman.py)
+ * [Subset Generation](dynamic_programming/subset_generation.py)
+ * [Sum Of Subset](dynamic_programming/sum_of_subset.py)
+ * [Trapped Water](dynamic_programming/trapped_water.py)
+ * [Tribonacci](dynamic_programming/tribonacci.py)
+ * [Viterbi](dynamic_programming/viterbi.py)
+ * [Wildcard Matching](dynamic_programming/wildcard_matching.py)
+ * [Word Break](dynamic_programming/word_break.py)
+
+## Electronics
+ * [Apparent Power](electronics/apparent_power.py)
+ * [Builtin Voltage](electronics/builtin_voltage.py)
+ * [Capacitor Equivalence](electronics/capacitor_equivalence.py)
+ * [Carrier Concentration](electronics/carrier_concentration.py)
+ * [Charging Capacitor](electronics/charging_capacitor.py)
+ * [Charging Inductor](electronics/charging_inductor.py)
+ * [Circular Convolution](electronics/circular_convolution.py)
+ * [Coulombs Law](electronics/coulombs_law.py)
+ * [Electric Conductivity](electronics/electric_conductivity.py)
+ * [Electric Power](electronics/electric_power.py)
+ * [Electrical Impedance](electronics/electrical_impedance.py)
+ * [Ic 555 Timer](electronics/ic_555_timer.py)
+ * [Ind Reactance](electronics/ind_reactance.py)
+ * [Ohms Law](electronics/ohms_law.py)
+ * [Real And Reactive Power](electronics/real_and_reactive_power.py)
+ * [Resistor Color Code](electronics/resistor_color_code.py)
+ * [Resistor Equivalence](electronics/resistor_equivalence.py)
+ * [Resonant Frequency](electronics/resonant_frequency.py)
+ * [Wheatstone Bridge](electronics/wheatstone_bridge.py)
## File Transfer
- * [Receive File](https://github.com/TheAlgorithms/Python/blob/master/file_transfer/receive_file.py)
- * [Send File](https://github.com/TheAlgorithms/Python/blob/master/file_transfer/send_file.py)
+ * [Receive File](file_transfer/receive_file.py)
+ * [Send File](file_transfer/send_file.py)
* Tests
- * [Test Send File](https://github.com/TheAlgorithms/Python/blob/master/file_transfer/tests/test_send_file.py)
+ * [Test Send File](file_transfer/tests/test_send_file.py)
+
+## Financial
+ * [Equated Monthly Installments](financial/equated_monthly_installments.py)
+ * [Exponential Moving Average](financial/exponential_moving_average.py)
+ * [Interest](financial/interest.py)
+ * [Present Value](financial/present_value.py)
+ * [Price Plus Tax](financial/price_plus_tax.py)
+ * [Simple Moving Average](financial/simple_moving_average.py)
+
+## Fractals
+ * [Julia Sets](fractals/julia_sets.py)
+ * [Koch Snowflake](fractals/koch_snowflake.py)
+ * [Mandelbrot](fractals/mandelbrot.py)
+ * [Sierpinski Triangle](fractals/sierpinski_triangle.py)
+ * [Vicsek](fractals/vicsek.py)
## Fuzzy Logic
- * [Fuzzy Operations](https://github.com/TheAlgorithms/Python/blob/master/fuzzy_logic/fuzzy_operations.py)
+ * [Fuzzy Operations](fuzzy_logic/fuzzy_operations.py)
## Genetic Algorithm
- * [Basic String](https://github.com/TheAlgorithms/Python/blob/master/genetic_algorithm/basic_string.py)
+ * [Basic String](genetic_algorithm/basic_string.py)
## Geodesy
- * [Haversine Distance](https://github.com/TheAlgorithms/Python/blob/master/geodesy/haversine_distance.py)
- * [Lamberts Ellipsoidal Distance](https://github.com/TheAlgorithms/Python/blob/master/geodesy/lamberts_ellipsoidal_distance.py)
+ * [Haversine Distance](geodesy/haversine_distance.py)
+ * [Lamberts Ellipsoidal Distance](geodesy/lamberts_ellipsoidal_distance.py)
+
+## Geometry
+ * [Geometry](geometry/geometry.py)
## Graphics
- * [Bezier Curve](https://github.com/TheAlgorithms/Python/blob/master/graphics/bezier_curve.py)
- * [Vector3 For 2D Rendering](https://github.com/TheAlgorithms/Python/blob/master/graphics/vector3_for_2d_rendering.py)
+ * [Bezier Curve](graphics/bezier_curve.py)
+ * [Butterfly Pattern](graphics/butterfly_pattern.py)
+ * [Digital Differential Analyzer Line](graphics/digital_differential_analyzer_line.py)
+ * [Vector3 For 2D Rendering](graphics/vector3_for_2d_rendering.py)
## Graphs
- * [A Star](https://github.com/TheAlgorithms/Python/blob/master/graphs/a_star.py)
- * [Articulation Points](https://github.com/TheAlgorithms/Python/blob/master/graphs/articulation_points.py)
- * [Basic Graphs](https://github.com/TheAlgorithms/Python/blob/master/graphs/basic_graphs.py)
- * [Bellman Ford](https://github.com/TheAlgorithms/Python/blob/master/graphs/bellman_ford.py)
- * [Bfs Shortest Path](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs_shortest_path.py)
- * [Bfs Zero One Shortest Path](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs_zero_one_shortest_path.py)
- * [Bidirectional A Star](https://github.com/TheAlgorithms/Python/blob/master/graphs/bidirectional_a_star.py)
- * [Bidirectional Breadth First Search](https://github.com/TheAlgorithms/Python/blob/master/graphs/bidirectional_breadth_first_search.py)
- * [Breadth First Search](https://github.com/TheAlgorithms/Python/blob/master/graphs/breadth_first_search.py)
- * [Breadth First Search 2](https://github.com/TheAlgorithms/Python/blob/master/graphs/breadth_first_search_2.py)
- * [Breadth First Search Shortest Path](https://github.com/TheAlgorithms/Python/blob/master/graphs/breadth_first_search_shortest_path.py)
- * [Check Bipartite Graph Bfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_bfs.py)
- * [Check Bipartite Graph Dfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_dfs.py)
- * [Connected Components](https://github.com/TheAlgorithms/Python/blob/master/graphs/connected_components.py)
- * [Depth First Search](https://github.com/TheAlgorithms/Python/blob/master/graphs/depth_first_search.py)
- * [Depth First Search 2](https://github.com/TheAlgorithms/Python/blob/master/graphs/depth_first_search_2.py)
- * [Dijkstra](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra.py)
- * [Dijkstra 2](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra_2.py)
- * [Dijkstra Algorithm](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra_algorithm.py)
- * [Dinic](https://github.com/TheAlgorithms/Python/blob/master/graphs/dinic.py)
- * [Directed And Undirected (Weighted) Graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/directed_and_undirected_(weighted)_graph.py)
- * [Edmonds Karp Multiple Source And Sink](https://github.com/TheAlgorithms/Python/blob/master/graphs/edmonds_karp_multiple_source_and_sink.py)
- * [Eulerian Path And Circuit For Undirected Graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/eulerian_path_and_circuit_for_undirected_graph.py)
- * [Even Tree](https://github.com/TheAlgorithms/Python/blob/master/graphs/even_tree.py)
- * [Finding Bridges](https://github.com/TheAlgorithms/Python/blob/master/graphs/finding_bridges.py)
- * [Frequent Pattern Graph Miner](https://github.com/TheAlgorithms/Python/blob/master/graphs/frequent_pattern_graph_miner.py)
- * [G Topological Sort](https://github.com/TheAlgorithms/Python/blob/master/graphs/g_topological_sort.py)
- * [Gale Shapley Bigraph](https://github.com/TheAlgorithms/Python/blob/master/graphs/gale_shapley_bigraph.py)
- * [Graph List](https://github.com/TheAlgorithms/Python/blob/master/graphs/graph_list.py)
- * [Graph Matrix](https://github.com/TheAlgorithms/Python/blob/master/graphs/graph_matrix.py)
- * [Graphs Floyd Warshall](https://github.com/TheAlgorithms/Python/blob/master/graphs/graphs_floyd_warshall.py)
- * [Greedy Best First](https://github.com/TheAlgorithms/Python/blob/master/graphs/greedy_best_first.py)
- * [Kahns Algorithm Long](https://github.com/TheAlgorithms/Python/blob/master/graphs/kahns_algorithm_long.py)
- * [Kahns Algorithm Topo](https://github.com/TheAlgorithms/Python/blob/master/graphs/kahns_algorithm_topo.py)
- * [Karger](https://github.com/TheAlgorithms/Python/blob/master/graphs/karger.py)
- * [Minimum Spanning Tree Boruvka](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_boruvka.py)
- * [Minimum Spanning Tree Kruskal](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_kruskal.py)
- * [Minimum Spanning Tree Kruskal2](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_kruskal2.py)
- * [Minimum Spanning Tree Prims](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_prims.py)
- * [Minimum Spanning Tree Prims2](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_prims2.py)
- * [Multi Heuristic Astar](https://github.com/TheAlgorithms/Python/blob/master/graphs/multi_heuristic_astar.py)
- * [Page Rank](https://github.com/TheAlgorithms/Python/blob/master/graphs/page_rank.py)
- * [Prim](https://github.com/TheAlgorithms/Python/blob/master/graphs/prim.py)
- * [Scc Kosaraju](https://github.com/TheAlgorithms/Python/blob/master/graphs/scc_kosaraju.py)
- * [Strongly Connected Components](https://github.com/TheAlgorithms/Python/blob/master/graphs/strongly_connected_components.py)
- * [Tarjans Scc](https://github.com/TheAlgorithms/Python/blob/master/graphs/tarjans_scc.py)
+ * [A Star](graphs/a_star.py)
+ * [Ant Colony Optimization Algorithms](graphs/ant_colony_optimization_algorithms.py)
+ * [Articulation Points](graphs/articulation_points.py)
+ * [Basic Graphs](graphs/basic_graphs.py)
+ * [Bellman Ford](graphs/bellman_ford.py)
+ * [Bi Directional Dijkstra](graphs/bi_directional_dijkstra.py)
+ * [Bidirectional A Star](graphs/bidirectional_a_star.py)
+ * [Bidirectional Breadth First Search](graphs/bidirectional_breadth_first_search.py)
+ * [Boruvka](graphs/boruvka.py)
+ * [Breadth First Search](graphs/breadth_first_search.py)
+ * [Breadth First Search 2](graphs/breadth_first_search_2.py)
+ * [Breadth First Search Shortest Path](graphs/breadth_first_search_shortest_path.py)
+ * [Breadth First Search Shortest Path 2](graphs/breadth_first_search_shortest_path_2.py)
+ * [Breadth First Search Zero One Shortest Path](graphs/breadth_first_search_zero_one_shortest_path.py)
+ * [Check Bipatrite](graphs/check_bipatrite.py)
+ * [Check Cycle](graphs/check_cycle.py)
+ * [Connected Components](graphs/connected_components.py)
+ * [Deep Clone Graph](graphs/deep_clone_graph.py)
+ * [Depth First Search](graphs/depth_first_search.py)
+ * [Depth First Search 2](graphs/depth_first_search_2.py)
+ * [Dijkstra](graphs/dijkstra.py)
+ * [Dijkstra 2](graphs/dijkstra_2.py)
+ * [Dijkstra Algorithm](graphs/dijkstra_algorithm.py)
+ * [Dijkstra Alternate](graphs/dijkstra_alternate.py)
+ * [Dijkstra Binary Grid](graphs/dijkstra_binary_grid.py)
+ * [Dinic](graphs/dinic.py)
+ * [Directed And Undirected Weighted Graph](graphs/directed_and_undirected_weighted_graph.py)
+ * [Edmonds Karp Multiple Source And Sink](graphs/edmonds_karp_multiple_source_and_sink.py)
+ * [Eulerian Path And Circuit For Undirected Graph](graphs/eulerian_path_and_circuit_for_undirected_graph.py)
+ * [Even Tree](graphs/even_tree.py)
+ * [Finding Bridges](graphs/finding_bridges.py)
+ * [Frequent Pattern Graph Miner](graphs/frequent_pattern_graph_miner.py)
+ * [G Topological Sort](graphs/g_topological_sort.py)
+ * [Gale Shapley Bigraph](graphs/gale_shapley_bigraph.py)
+ * [Graph Adjacency List](graphs/graph_adjacency_list.py)
+ * [Graph Adjacency Matrix](graphs/graph_adjacency_matrix.py)
+ * [Graph List](graphs/graph_list.py)
+ * [Graphs Floyd Warshall](graphs/graphs_floyd_warshall.py)
+ * [Greedy Best First](graphs/greedy_best_first.py)
+ * [Greedy Min Vertex Cover](graphs/greedy_min_vertex_cover.py)
+ * [Kahns Algorithm Long](graphs/kahns_algorithm_long.py)
+ * [Kahns Algorithm Topo](graphs/kahns_algorithm_topo.py)
+ * [Karger](graphs/karger.py)
+ * [Lanczos Eigenvectors](graphs/lanczos_eigenvectors.py)
+ * [Markov Chain](graphs/markov_chain.py)
+ * [Matching Min Vertex Cover](graphs/matching_min_vertex_cover.py)
+ * [Minimum Path Sum](graphs/minimum_path_sum.py)
+ * [Minimum Spanning Tree Boruvka](graphs/minimum_spanning_tree_boruvka.py)
+ * [Minimum Spanning Tree Kruskal](graphs/minimum_spanning_tree_kruskal.py)
+ * [Minimum Spanning Tree Kruskal2](graphs/minimum_spanning_tree_kruskal2.py)
+ * [Minimum Spanning Tree Prims](graphs/minimum_spanning_tree_prims.py)
+ * [Minimum Spanning Tree Prims2](graphs/minimum_spanning_tree_prims2.py)
+ * [Multi Heuristic Astar](graphs/multi_heuristic_astar.py)
+ * [Page Rank](graphs/page_rank.py)
+ * [Prim](graphs/prim.py)
+ * [Random Graph Generator](graphs/random_graph_generator.py)
+ * [Scc Kosaraju](graphs/scc_kosaraju.py)
+ * [Strongly Connected Components](graphs/strongly_connected_components.py)
+ * [Tarjans Scc](graphs/tarjans_scc.py)
* Tests
- * [Test Min Spanning Tree Kruskal](https://github.com/TheAlgorithms/Python/blob/master/graphs/tests/test_min_spanning_tree_kruskal.py)
- * [Test Min Spanning Tree Prim](https://github.com/TheAlgorithms/Python/blob/master/graphs/tests/test_min_spanning_tree_prim.py)
+ * [Test Min Spanning Tree Kruskal](graphs/tests/test_min_spanning_tree_kruskal.py)
+ * [Test Min Spanning Tree Prim](graphs/tests/test_min_spanning_tree_prim.py)
-## Greedy Method
- * [Greedy Knapsack](https://github.com/TheAlgorithms/Python/blob/master/greedy_method/greedy_knapsack.py)
- * [Test Knapsack](https://github.com/TheAlgorithms/Python/blob/master/greedy_method/test_knapsack.py)
+## Greedy Methods
+ * [Best Time To Buy And Sell Stock](greedy_methods/best_time_to_buy_and_sell_stock.py)
+ * [Fractional Cover Problem](greedy_methods/fractional_cover_problem.py)
+ * [Fractional Knapsack](greedy_methods/fractional_knapsack.py)
+ * [Fractional Knapsack 2](greedy_methods/fractional_knapsack_2.py)
+ * [Gas Station](greedy_methods/gas_station.py)
+ * [Minimum Coin Change](greedy_methods/minimum_coin_change.py)
+ * [Minimum Waiting Time](greedy_methods/minimum_waiting_time.py)
+ * [Optimal Merge Pattern](greedy_methods/optimal_merge_pattern.py)
+ * [Smallest Range](greedy_methods/smallest_range.py)
## Hashes
- * [Adler32](https://github.com/TheAlgorithms/Python/blob/master/hashes/adler32.py)
- * [Chaos Machine](https://github.com/TheAlgorithms/Python/blob/master/hashes/chaos_machine.py)
- * [Djb2](https://github.com/TheAlgorithms/Python/blob/master/hashes/djb2.py)
- * [Enigma Machine](https://github.com/TheAlgorithms/Python/blob/master/hashes/enigma_machine.py)
- * [Hamming Code](https://github.com/TheAlgorithms/Python/blob/master/hashes/hamming_code.py)
- * [Md5](https://github.com/TheAlgorithms/Python/blob/master/hashes/md5.py)
- * [Sdbm](https://github.com/TheAlgorithms/Python/blob/master/hashes/sdbm.py)
- * [Sha1](https://github.com/TheAlgorithms/Python/blob/master/hashes/sha1.py)
+ * [Adler32](hashes/adler32.py)
+ * [Chaos Machine](hashes/chaos_machine.py)
+ * [Djb2](hashes/djb2.py)
+ * [Elf](hashes/elf.py)
+ * [Enigma Machine](hashes/enigma_machine.py)
+ * [Fletcher16](hashes/fletcher16.py)
+ * [Hamming Code](hashes/hamming_code.py)
+ * [Luhn](hashes/luhn.py)
+ * [Md5](hashes/md5.py)
+ * [Sdbm](hashes/sdbm.py)
+ * [Sha1](hashes/sha1.py)
+ * [Sha256](hashes/sha256.py)
## Knapsack
- * [Knapsack](https://github.com/TheAlgorithms/Python/blob/master/knapsack/knapsack.py)
- * [Test Knapsack](https://github.com/TheAlgorithms/Python/blob/master/knapsack/test_knapsack.py)
+ * [Greedy Knapsack](knapsack/greedy_knapsack.py)
+ * [Knapsack](knapsack/knapsack.py)
+ * [Recursive Approach Knapsack](knapsack/recursive_approach_knapsack.py)
+ * Tests
+ * [Test Greedy Knapsack](knapsack/tests/test_greedy_knapsack.py)
+ * [Test Knapsack](knapsack/tests/test_knapsack.py)
## Linear Algebra
+ * [Gaussian Elimination](linear_algebra/gaussian_elimination.py)
+ * [Jacobi Iteration Method](linear_algebra/jacobi_iteration_method.py)
+ * [Lu Decomposition](linear_algebra/lu_decomposition.py)
* Src
- * [Lib](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/lib.py)
- * [Polynom For Points](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/polynom_for_points.py)
- * [Power Iteration](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/power_iteration.py)
- * [Rayleigh Quotient](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/rayleigh_quotient.py)
- * [Test Linear Algebra](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/test_linear_algebra.py)
- * [Transformations 2D](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/transformations_2d.py)
+ * [Conjugate Gradient](linear_algebra/src/conjugate_gradient.py)
+ * [Gaussian Elimination Pivoting](linear_algebra/src/gaussian_elimination_pivoting.py)
+ * [Lib](linear_algebra/src/lib.py)
+ * [Polynom For Points](linear_algebra/src/polynom_for_points.py)
+ * [Power Iteration](linear_algebra/src/power_iteration.py)
+ * [Rank Of Matrix](linear_algebra/src/rank_of_matrix.py)
+ * [Rayleigh Quotient](linear_algebra/src/rayleigh_quotient.py)
+ * [Schur Complement](linear_algebra/src/schur_complement.py)
+ * [Test Linear Algebra](linear_algebra/src/test_linear_algebra.py)
+ * [Transformations 2D](linear_algebra/src/transformations_2d.py)
+
+## Linear Programming
+ * [Simplex](linear_programming/simplex.py)
## Machine Learning
- * [Astar](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/astar.py)
- * [Data Transformations](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/data_transformations.py)
- * [Decision Tree](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/decision_tree.py)
+ * [Apriori Algorithm](machine_learning/apriori_algorithm.py)
+ * [Astar](machine_learning/astar.py)
+ * [Automatic Differentiation](machine_learning/automatic_differentiation.py)
+ * [Data Transformations](machine_learning/data_transformations.py)
+ * [Decision Tree](machine_learning/decision_tree.py)
+ * [Dimensionality Reduction](machine_learning/dimensionality_reduction.py)
* Forecasting
- * [Run](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/forecasting/run.py)
- * [Gaussian Naive Bayes](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/gaussian_naive_bayes.py)
- * [Gradient Boosting Regressor](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/gradient_boosting_regressor.py)
- * [Gradient Descent](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/gradient_descent.py)
- * [K Means Clust](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/k_means_clust.py)
- * [K Nearest Neighbours](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/k_nearest_neighbours.py)
- * [Knn Sklearn](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/knn_sklearn.py)
- * [Linear Discriminant Analysis](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/linear_discriminant_analysis.py)
- * [Linear Regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/linear_regression.py)
- * [Logistic Regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/logistic_regression.py)
+ * [Run](machine_learning/forecasting/run.py)
+ * [Frequent Pattern Growth](machine_learning/frequent_pattern_growth.py)
+ * [Gradient Boosting Classifier](machine_learning/gradient_boosting_classifier.py)
+ * [Gradient Descent](machine_learning/gradient_descent.py)
+ * [K Means Clust](machine_learning/k_means_clust.py)
+ * [K Nearest Neighbours](machine_learning/k_nearest_neighbours.py)
+ * [Linear Discriminant Analysis](machine_learning/linear_discriminant_analysis.py)
+ * [Linear Regression](machine_learning/linear_regression.py)
+ * Local Weighted Learning
+ * [Local Weighted Learning](machine_learning/local_weighted_learning/local_weighted_learning.py)
+ * [Logistic Regression](machine_learning/logistic_regression.py)
+ * [Loss Functions](machine_learning/loss_functions.py)
* Lstm
- * [Lstm Prediction](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/lstm/lstm_prediction.py)
- * [Multilayer Perceptron Classifier](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/multilayer_perceptron_classifier.py)
- * [Polymonial Regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/polymonial_regression.py)
- * [Random Forest Classifier](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classifier.py)
- * [Random Forest Regressor](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regressor.py)
- * [Scoring Functions](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/scoring_functions.py)
- * [Sequential Minimum Optimization](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/sequential_minimum_optimization.py)
- * [Similarity Search](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/similarity_search.py)
- * [Support Vector Machines](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/support_vector_machines.py)
- * [Word Frequency Functions](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/word_frequency_functions.py)
+ * [Lstm Prediction](machine_learning/lstm/lstm_prediction.py)
+ * [Mfcc](machine_learning/mfcc.py)
+ * [Multilayer Perceptron Classifier](machine_learning/multilayer_perceptron_classifier.py)
+ * [Polynomial Regression](machine_learning/polynomial_regression.py)
+ * [Principle Component Analysis](machine_learning/principle_component_analysis.py)
+ * [Scoring Functions](machine_learning/scoring_functions.py)
+ * [Self Organizing Map](machine_learning/self_organizing_map.py)
+ * [Sequential Minimum Optimization](machine_learning/sequential_minimum_optimization.py)
+ * [Similarity Search](machine_learning/similarity_search.py)
+ * [Support Vector Machines](machine_learning/support_vector_machines.py)
+ * [Word Frequency Functions](machine_learning/word_frequency_functions.py)
+ * [Xgboost Classifier](machine_learning/xgboost_classifier.py)
+ * [Xgboost Regressor](machine_learning/xgboost_regressor.py)
## Maths
- * [3N Plus 1](https://github.com/TheAlgorithms/Python/blob/master/maths/3n_plus_1.py)
- * [Abs](https://github.com/TheAlgorithms/Python/blob/master/maths/abs.py)
- * [Abs Max](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_max.py)
- * [Abs Min](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_min.py)
- * [Add](https://github.com/TheAlgorithms/Python/blob/master/maths/add.py)
- * [Aliquot Sum](https://github.com/TheAlgorithms/Python/blob/master/maths/aliquot_sum.py)
- * [Allocation Number](https://github.com/TheAlgorithms/Python/blob/master/maths/allocation_number.py)
- * [Area](https://github.com/TheAlgorithms/Python/blob/master/maths/area.py)
- * [Area Under Curve](https://github.com/TheAlgorithms/Python/blob/master/maths/area_under_curve.py)
- * [Armstrong Numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/armstrong_numbers.py)
- * [Average Mean](https://github.com/TheAlgorithms/Python/blob/master/maths/average_mean.py)
- * [Average Median](https://github.com/TheAlgorithms/Python/blob/master/maths/average_median.py)
- * [Average Mode](https://github.com/TheAlgorithms/Python/blob/master/maths/average_mode.py)
- * [Bailey Borwein Plouffe](https://github.com/TheAlgorithms/Python/blob/master/maths/bailey_borwein_plouffe.py)
- * [Basic Maths](https://github.com/TheAlgorithms/Python/blob/master/maths/basic_maths.py)
- * [Binary Exp Mod](https://github.com/TheAlgorithms/Python/blob/master/maths/binary_exp_mod.py)
- * [Binary Exponentiation](https://github.com/TheAlgorithms/Python/blob/master/maths/binary_exponentiation.py)
- * [Binomial Coefficient](https://github.com/TheAlgorithms/Python/blob/master/maths/binomial_coefficient.py)
- * [Binomial Distribution](https://github.com/TheAlgorithms/Python/blob/master/maths/binomial_distribution.py)
- * [Bisection](https://github.com/TheAlgorithms/Python/blob/master/maths/bisection.py)
- * [Ceil](https://github.com/TheAlgorithms/Python/blob/master/maths/ceil.py)
- * [Chudnovsky Algorithm](https://github.com/TheAlgorithms/Python/blob/master/maths/chudnovsky_algorithm.py)
- * [Collatz Sequence](https://github.com/TheAlgorithms/Python/blob/master/maths/collatz_sequence.py)
- * [Combinations](https://github.com/TheAlgorithms/Python/blob/master/maths/combinations.py)
- * [Decimal Isolate](https://github.com/TheAlgorithms/Python/blob/master/maths/decimal_isolate.py)
- * [Entropy](https://github.com/TheAlgorithms/Python/blob/master/maths/entropy.py)
- * [Eulers Totient](https://github.com/TheAlgorithms/Python/blob/master/maths/eulers_totient.py)
- * [Explicit Euler](https://github.com/TheAlgorithms/Python/blob/master/maths/explicit_euler.py)
- * [Extended Euclidean Algorithm](https://github.com/TheAlgorithms/Python/blob/master/maths/extended_euclidean_algorithm.py)
- * [Factorial Iterative](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_iterative.py)
- * [Factorial Python](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_python.py)
- * [Factorial Recursive](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_recursive.py)
- * [Factors](https://github.com/TheAlgorithms/Python/blob/master/maths/factors.py)
- * [Fermat Little Theorem](https://github.com/TheAlgorithms/Python/blob/master/maths/fermat_little_theorem.py)
- * [Fibonacci](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci.py)
- * [Fibonacci Sequence Recursion](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci_sequence_recursion.py)
- * [Find Max](https://github.com/TheAlgorithms/Python/blob/master/maths/find_max.py)
- * [Find Max Recursion](https://github.com/TheAlgorithms/Python/blob/master/maths/find_max_recursion.py)
- * [Find Min](https://github.com/TheAlgorithms/Python/blob/master/maths/find_min.py)
- * [Find Min Recursion](https://github.com/TheAlgorithms/Python/blob/master/maths/find_min_recursion.py)
- * [Floor](https://github.com/TheAlgorithms/Python/blob/master/maths/floor.py)
- * [Gamma](https://github.com/TheAlgorithms/Python/blob/master/maths/gamma.py)
- * [Gaussian](https://github.com/TheAlgorithms/Python/blob/master/maths/gaussian.py)
- * [Greatest Common Divisor](https://github.com/TheAlgorithms/Python/blob/master/maths/greatest_common_divisor.py)
- * [Hardy Ramanujanalgo](https://github.com/TheAlgorithms/Python/blob/master/maths/hardy_ramanujanalgo.py)
- * [Is Square Free](https://github.com/TheAlgorithms/Python/blob/master/maths/is_square_free.py)
- * [Jaccard Similarity](https://github.com/TheAlgorithms/Python/blob/master/maths/jaccard_similarity.py)
- * [Kadanes](https://github.com/TheAlgorithms/Python/blob/master/maths/kadanes.py)
- * [Karatsuba](https://github.com/TheAlgorithms/Python/blob/master/maths/karatsuba.py)
- * [Krishnamurthy Number](https://github.com/TheAlgorithms/Python/blob/master/maths/krishnamurthy_number.py)
- * [Kth Lexicographic Permutation](https://github.com/TheAlgorithms/Python/blob/master/maths/kth_lexicographic_permutation.py)
- * [Largest Of Very Large Numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/largest_of_very_large_numbers.py)
- * [Least Common Multiple](https://github.com/TheAlgorithms/Python/blob/master/maths/least_common_multiple.py)
- * [Line Length](https://github.com/TheAlgorithms/Python/blob/master/maths/line_length.py)
- * [Lucas Lehmer Primality Test](https://github.com/TheAlgorithms/Python/blob/master/maths/lucas_lehmer_primality_test.py)
- * [Lucas Series](https://github.com/TheAlgorithms/Python/blob/master/maths/lucas_series.py)
- * [Matrix Exponentiation](https://github.com/TheAlgorithms/Python/blob/master/maths/matrix_exponentiation.py)
- * [Miller Rabin](https://github.com/TheAlgorithms/Python/blob/master/maths/miller_rabin.py)
- * [Mobius Function](https://github.com/TheAlgorithms/Python/blob/master/maths/mobius_function.py)
- * [Modular Exponential](https://github.com/TheAlgorithms/Python/blob/master/maths/modular_exponential.py)
- * [Monte Carlo](https://github.com/TheAlgorithms/Python/blob/master/maths/monte_carlo.py)
- * [Monte Carlo Dice](https://github.com/TheAlgorithms/Python/blob/master/maths/monte_carlo_dice.py)
- * [Newton Raphson](https://github.com/TheAlgorithms/Python/blob/master/maths/newton_raphson.py)
- * [Number Of Digits](https://github.com/TheAlgorithms/Python/blob/master/maths/number_of_digits.py)
- * [Numerical Integration](https://github.com/TheAlgorithms/Python/blob/master/maths/numerical_integration.py)
- * [Perfect Cube](https://github.com/TheAlgorithms/Python/blob/master/maths/perfect_cube.py)
- * [Perfect Number](https://github.com/TheAlgorithms/Python/blob/master/maths/perfect_number.py)
- * [Perfect Square](https://github.com/TheAlgorithms/Python/blob/master/maths/perfect_square.py)
- * [Pi Monte Carlo Estimation](https://github.com/TheAlgorithms/Python/blob/master/maths/pi_monte_carlo_estimation.py)
- * [Polynomial Evaluation](https://github.com/TheAlgorithms/Python/blob/master/maths/polynomial_evaluation.py)
- * [Power Using Recursion](https://github.com/TheAlgorithms/Python/blob/master/maths/power_using_recursion.py)
- * [Prime Check](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_check.py)
- * [Prime Factors](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_factors.py)
- * [Prime Numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_numbers.py)
- * [Prime Sieve Eratosthenes](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_sieve_eratosthenes.py)
- * [Pythagoras](https://github.com/TheAlgorithms/Python/blob/master/maths/pythagoras.py)
- * [Qr Decomposition](https://github.com/TheAlgorithms/Python/blob/master/maths/qr_decomposition.py)
- * [Quadratic Equations Complex Numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/quadratic_equations_complex_numbers.py)
- * [Radians](https://github.com/TheAlgorithms/Python/blob/master/maths/radians.py)
- * [Radix2 Fft](https://github.com/TheAlgorithms/Python/blob/master/maths/radix2_fft.py)
- * [Relu](https://github.com/TheAlgorithms/Python/blob/master/maths/relu.py)
- * [Runge Kutta](https://github.com/TheAlgorithms/Python/blob/master/maths/runge_kutta.py)
- * [Segmented Sieve](https://github.com/TheAlgorithms/Python/blob/master/maths/segmented_sieve.py)
+ * [Abs](maths/abs.py)
+ * [Addition Without Arithmetic](maths/addition_without_arithmetic.py)
+ * [Aliquot Sum](maths/aliquot_sum.py)
+ * [Allocation Number](maths/allocation_number.py)
+ * [Arc Length](maths/arc_length.py)
+ * [Area](maths/area.py)
+ * [Area Under Curve](maths/area_under_curve.py)
+ * [Average Absolute Deviation](maths/average_absolute_deviation.py)
+ * [Average Mean](maths/average_mean.py)
+ * [Average Median](maths/average_median.py)
+ * [Average Mode](maths/average_mode.py)
+ * [Bailey Borwein Plouffe](maths/bailey_borwein_plouffe.py)
+ * [Base Neg2 Conversion](maths/base_neg2_conversion.py)
+ * [Basic Maths](maths/basic_maths.py)
+ * [Binary Exponentiation](maths/binary_exponentiation.py)
+ * [Binary Multiplication](maths/binary_multiplication.py)
+ * [Binomial Coefficient](maths/binomial_coefficient.py)
+ * [Binomial Distribution](maths/binomial_distribution.py)
+ * [Ceil](maths/ceil.py)
+ * [Chebyshev Distance](maths/chebyshev_distance.py)
+ * [Check Polygon](maths/check_polygon.py)
+ * [Chinese Remainder Theorem](maths/chinese_remainder_theorem.py)
+ * [Chudnovsky Algorithm](maths/chudnovsky_algorithm.py)
+ * [Collatz Sequence](maths/collatz_sequence.py)
+ * [Combinations](maths/combinations.py)
+ * [Continued Fraction](maths/continued_fraction.py)
+ * [Decimal Isolate](maths/decimal_isolate.py)
+ * [Decimal To Fraction](maths/decimal_to_fraction.py)
+ * [Dodecahedron](maths/dodecahedron.py)
+ * [Double Factorial](maths/double_factorial.py)
+ * [Dual Number Automatic Differentiation](maths/dual_number_automatic_differentiation.py)
+ * [Entropy](maths/entropy.py)
+ * [Euclidean Distance](maths/euclidean_distance.py)
+ * [Euler Method](maths/euler_method.py)
+ * [Euler Modified](maths/euler_modified.py)
+ * [Eulers Totient](maths/eulers_totient.py)
+ * [Extended Euclidean Algorithm](maths/extended_euclidean_algorithm.py)
+ * [Factorial](maths/factorial.py)
+ * [Factors](maths/factors.py)
+ * [Fast Inverse Sqrt](maths/fast_inverse_sqrt.py)
+ * [Fermat Little Theorem](maths/fermat_little_theorem.py)
+ * [Fibonacci](maths/fibonacci.py)
+ * [Find Max](maths/find_max.py)
+ * [Find Min](maths/find_min.py)
+ * [Floor](maths/floor.py)
+ * [Gamma](maths/gamma.py)
+ * [Gaussian](maths/gaussian.py)
+ * [Gcd Of N Numbers](maths/gcd_of_n_numbers.py)
+ * [Geometric Mean](maths/geometric_mean.py)
+ * [Germain Primes](maths/germain_primes.py)
+ * [Greatest Common Divisor](maths/greatest_common_divisor.py)
+ * [Hardy Ramanujanalgo](maths/hardy_ramanujanalgo.py)
+ * [Integer Square Root](maths/integer_square_root.py)
+ * [Interquartile Range](maths/interquartile_range.py)
+ * [Is Int Palindrome](maths/is_int_palindrome.py)
+ * [Is Ip V4 Address Valid](maths/is_ip_v4_address_valid.py)
+ * [Is Square Free](maths/is_square_free.py)
+ * [Jaccard Similarity](maths/jaccard_similarity.py)
+ * [Joint Probability Distribution](maths/joint_probability_distribution.py)
+ * [Josephus Problem](maths/josephus_problem.py)
+ * [Juggler Sequence](maths/juggler_sequence.py)
+ * [Karatsuba](maths/karatsuba.py)
+ * [Kth Lexicographic Permutation](maths/kth_lexicographic_permutation.py)
+ * [Largest Of Very Large Numbers](maths/largest_of_very_large_numbers.py)
+ * [Least Common Multiple](maths/least_common_multiple.py)
+ * [Line Length](maths/line_length.py)
+ * [Liouville Lambda](maths/liouville_lambda.py)
+ * [Lucas Lehmer Primality Test](maths/lucas_lehmer_primality_test.py)
+ * [Lucas Series](maths/lucas_series.py)
+ * [Maclaurin Series](maths/maclaurin_series.py)
+ * [Manhattan Distance](maths/manhattan_distance.py)
+ * [Matrix Exponentiation](maths/matrix_exponentiation.py)
+ * [Max Sum Sliding Window](maths/max_sum_sliding_window.py)
+ * [Minkowski Distance](maths/minkowski_distance.py)
+ * [Mobius Function](maths/mobius_function.py)
+ * [Modular Division](maths/modular_division.py)
+ * [Modular Exponential](maths/modular_exponential.py)
+ * [Monte Carlo](maths/monte_carlo.py)
+ * [Monte Carlo Dice](maths/monte_carlo_dice.py)
+ * [Number Of Digits](maths/number_of_digits.py)
+ * Numerical Analysis
+ * [Adams Bashforth](maths/numerical_analysis/adams_bashforth.py)
+ * [Bisection](maths/numerical_analysis/bisection.py)
+ * [Bisection 2](maths/numerical_analysis/bisection_2.py)
+ * [Integration By Simpson Approx](maths/numerical_analysis/integration_by_simpson_approx.py)
+ * [Intersection](maths/numerical_analysis/intersection.py)
+ * [Nevilles Method](maths/numerical_analysis/nevilles_method.py)
+ * [Newton Forward Interpolation](maths/numerical_analysis/newton_forward_interpolation.py)
+ * [Newton Raphson](maths/numerical_analysis/newton_raphson.py)
+ * [Numerical Integration](maths/numerical_analysis/numerical_integration.py)
+ * [Proper Fractions](maths/numerical_analysis/proper_fractions.py)
+ * [Runge Kutta](maths/numerical_analysis/runge_kutta.py)
+ * [Runge Kutta Fehlberg 45](maths/numerical_analysis/runge_kutta_fehlberg_45.py)
+ * [Runge Kutta Gills](maths/numerical_analysis/runge_kutta_gills.py)
+ * [Secant Method](maths/numerical_analysis/secant_method.py)
+ * [Simpson Rule](maths/numerical_analysis/simpson_rule.py)
+ * [Square Root](maths/numerical_analysis/square_root.py)
+ * [Odd Sieve](maths/odd_sieve.py)
+ * [Perfect Cube](maths/perfect_cube.py)
+ * [Perfect Number](maths/perfect_number.py)
+ * [Perfect Square](maths/perfect_square.py)
+ * [Persistence](maths/persistence.py)
+ * [Pi Generator](maths/pi_generator.py)
+ * [Pi Monte Carlo Estimation](maths/pi_monte_carlo_estimation.py)
+ * [Points Are Collinear 3D](maths/points_are_collinear_3d.py)
+ * [Pollard Rho](maths/pollard_rho.py)
+ * [Polynomial Evaluation](maths/polynomial_evaluation.py)
+ * Polynomials
+ * [Single Indeterminate Operations](maths/polynomials/single_indeterminate_operations.py)
+ * [Power Using Recursion](maths/power_using_recursion.py)
+ * [Prime Check](maths/prime_check.py)
+ * [Prime Factors](maths/prime_factors.py)
+ * [Prime Numbers](maths/prime_numbers.py)
+ * [Prime Sieve Eratosthenes](maths/prime_sieve_eratosthenes.py)
+ * [Primelib](maths/primelib.py)
+ * [Print Multiplication Table](maths/print_multiplication_table.py)
+ * [Pythagoras](maths/pythagoras.py)
+ * [Qr Decomposition](maths/qr_decomposition.py)
+ * [Quadratic Equations Complex Numbers](maths/quadratic_equations_complex_numbers.py)
+ * [Radians](maths/radians.py)
+ * [Radix2 Fft](maths/radix2_fft.py)
+ * [Remove Digit](maths/remove_digit.py)
+ * [Segmented Sieve](maths/segmented_sieve.py)
* Series
- * [Geometric Series](https://github.com/TheAlgorithms/Python/blob/master/maths/series/geometric_series.py)
- * [Harmonic Series](https://github.com/TheAlgorithms/Python/blob/master/maths/series/harmonic_series.py)
- * [P Series](https://github.com/TheAlgorithms/Python/blob/master/maths/series/p_series.py)
- * [Sieve Of Eratosthenes](https://github.com/TheAlgorithms/Python/blob/master/maths/sieve_of_eratosthenes.py)
- * [Sigmoid](https://github.com/TheAlgorithms/Python/blob/master/maths/sigmoid.py)
- * [Simpson Rule](https://github.com/TheAlgorithms/Python/blob/master/maths/simpson_rule.py)
- * [Softmax](https://github.com/TheAlgorithms/Python/blob/master/maths/softmax.py)
- * [Square Root](https://github.com/TheAlgorithms/Python/blob/master/maths/square_root.py)
- * [Sum Of Arithmetic Series](https://github.com/TheAlgorithms/Python/blob/master/maths/sum_of_arithmetic_series.py)
- * [Sum Of Digits](https://github.com/TheAlgorithms/Python/blob/master/maths/sum_of_digits.py)
- * [Sum Of Geometric Progression](https://github.com/TheAlgorithms/Python/blob/master/maths/sum_of_geometric_progression.py)
- * [Test Prime Check](https://github.com/TheAlgorithms/Python/blob/master/maths/test_prime_check.py)
- * [Trapezoidal Rule](https://github.com/TheAlgorithms/Python/blob/master/maths/trapezoidal_rule.py)
- * [Ugly Numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/ugly_numbers.py)
- * [Volume](https://github.com/TheAlgorithms/Python/blob/master/maths/volume.py)
- * [Zellers Congruence](https://github.com/TheAlgorithms/Python/blob/master/maths/zellers_congruence.py)
+ * [Arithmetic](maths/series/arithmetic.py)
+ * [Geometric](maths/series/geometric.py)
+ * [Geometric Series](maths/series/geometric_series.py)
+ * [Harmonic](maths/series/harmonic.py)
+ * [Harmonic Series](maths/series/harmonic_series.py)
+ * [Hexagonal Numbers](maths/series/hexagonal_numbers.py)
+ * [P Series](maths/series/p_series.py)
+ * [Sieve Of Eratosthenes](maths/sieve_of_eratosthenes.py)
+ * [Sigmoid](maths/sigmoid.py)
+ * [Signum](maths/signum.py)
+ * [Simultaneous Linear Equation Solver](maths/simultaneous_linear_equation_solver.py)
+ * [Sin](maths/sin.py)
+ * [Sock Merchant](maths/sock_merchant.py)
+ * [Softmax](maths/softmax.py)
+ * [Solovay Strassen Primality Test](maths/solovay_strassen_primality_test.py)
+ * [Spearman Rank Correlation Coefficient](maths/spearman_rank_correlation_coefficient.py)
+ * Special Numbers
+ * [Armstrong Numbers](maths/special_numbers/armstrong_numbers.py)
+ * [Automorphic Number](maths/special_numbers/automorphic_number.py)
+ * [Bell Numbers](maths/special_numbers/bell_numbers.py)
+ * [Carmichael Number](maths/special_numbers/carmichael_number.py)
+ * [Catalan Number](maths/special_numbers/catalan_number.py)
+ * [Hamming Numbers](maths/special_numbers/hamming_numbers.py)
+ * [Happy Number](maths/special_numbers/happy_number.py)
+ * [Harshad Numbers](maths/special_numbers/harshad_numbers.py)
+ * [Hexagonal Number](maths/special_numbers/hexagonal_number.py)
+ * [Krishnamurthy Number](maths/special_numbers/krishnamurthy_number.py)
+ * [Perfect Number](maths/special_numbers/perfect_number.py)
+ * [Polygonal Numbers](maths/special_numbers/polygonal_numbers.py)
+ * [Pronic Number](maths/special_numbers/pronic_number.py)
+ * [Proth Number](maths/special_numbers/proth_number.py)
+ * [Triangular Numbers](maths/special_numbers/triangular_numbers.py)
+ * [Ugly Numbers](maths/special_numbers/ugly_numbers.py)
+ * [Weird Number](maths/special_numbers/weird_number.py)
+ * [Sum Of Arithmetic Series](maths/sum_of_arithmetic_series.py)
+ * [Sum Of Digits](maths/sum_of_digits.py)
+ * [Sum Of Geometric Progression](maths/sum_of_geometric_progression.py)
+ * [Sum Of Harmonic Series](maths/sum_of_harmonic_series.py)
+ * [Sumset](maths/sumset.py)
+ * [Sylvester Sequence](maths/sylvester_sequence.py)
+ * [Tanh](maths/tanh.py)
+ * [Test Prime Check](maths/test_prime_check.py)
+ * [Three Sum](maths/three_sum.py)
+ * [Trapezoidal Rule](maths/trapezoidal_rule.py)
+ * [Triplet Sum](maths/triplet_sum.py)
+ * [Twin Prime](maths/twin_prime.py)
+ * [Two Pointer](maths/two_pointer.py)
+ * [Two Sum](maths/two_sum.py)
+ * [Volume](maths/volume.py)
+ * [Zellers Congruence](maths/zellers_congruence.py)
## Matrix
- * [Count Islands In Matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/count_islands_in_matrix.py)
- * [Inverse Of Matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/inverse_of_matrix.py)
- * [Matrix Class](https://github.com/TheAlgorithms/Python/blob/master/matrix/matrix_class.py)
- * [Matrix Operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/matrix_operation.py)
- * [Nth Fibonacci Using Matrix Exponentiation](https://github.com/TheAlgorithms/Python/blob/master/matrix/nth_fibonacci_using_matrix_exponentiation.py)
- * [Rotate Matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/rotate_matrix.py)
- * [Searching In Sorted Matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/searching_in_sorted_matrix.py)
- * [Sherman Morrison](https://github.com/TheAlgorithms/Python/blob/master/matrix/sherman_morrison.py)
- * [Spiral Print](https://github.com/TheAlgorithms/Python/blob/master/matrix/spiral_print.py)
+ * [Binary Search Matrix](matrix/binary_search_matrix.py)
+ * [Count Islands In Matrix](matrix/count_islands_in_matrix.py)
+ * [Count Negative Numbers In Sorted Matrix](matrix/count_negative_numbers_in_sorted_matrix.py)
+ * [Count Paths](matrix/count_paths.py)
+ * [Cramers Rule 2X2](matrix/cramers_rule_2x2.py)
+ * [Inverse Of Matrix](matrix/inverse_of_matrix.py)
+ * [Largest Square Area In Matrix](matrix/largest_square_area_in_matrix.py)
+ * [Matrix Based Game](matrix/matrix_based_game.py)
+ * [Matrix Class](matrix/matrix_class.py)
+ * [Matrix Equalization](matrix/matrix_equalization.py)
+ * [Matrix Multiplication Recursion](matrix/matrix_multiplication_recursion.py)
+ * [Matrix Operation](matrix/matrix_operation.py)
+ * [Max Area Of Island](matrix/max_area_of_island.py)
+ * [Median Matrix](matrix/median_matrix.py)
+ * [Nth Fibonacci Using Matrix Exponentiation](matrix/nth_fibonacci_using_matrix_exponentiation.py)
+ * [Pascal Triangle](matrix/pascal_triangle.py)
+ * [Rotate Matrix](matrix/rotate_matrix.py)
+ * [Searching In Sorted Matrix](matrix/searching_in_sorted_matrix.py)
+ * [Sherman Morrison](matrix/sherman_morrison.py)
+ * [Spiral Print](matrix/spiral_print.py)
* Tests
- * [Test Matrix Operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/tests/test_matrix_operation.py)
+ * [Test Matrix Operation](matrix/tests/test_matrix_operation.py)
+ * [Validate Sudoku Board](matrix/validate_sudoku_board.py)
## Networking Flow
- * [Ford Fulkerson](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/ford_fulkerson.py)
- * [Minimum Cut](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/minimum_cut.py)
+ * [Ford Fulkerson](networking_flow/ford_fulkerson.py)
+ * [Minimum Cut](networking_flow/minimum_cut.py)
## Neural Network
- * [Back Propagation Neural Network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/back_propagation_neural_network.py)
- * [Convolution Neural Network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/convolution_neural_network.py)
- * [Perceptron](https://github.com/TheAlgorithms/Python/blob/master/neural_network/perceptron.py)
+ * Activation Functions
+ * [Binary Step](neural_network/activation_functions/binary_step.py)
+ * [Exponential Linear Unit](neural_network/activation_functions/exponential_linear_unit.py)
+ * [Gaussian Error Linear Unit](neural_network/activation_functions/gaussian_error_linear_unit.py)
+ * [Leaky Rectified Linear Unit](neural_network/activation_functions/leaky_rectified_linear_unit.py)
+ * [Mish](neural_network/activation_functions/mish.py)
+ * [Rectified Linear Unit](neural_network/activation_functions/rectified_linear_unit.py)
+ * [Scaled Exponential Linear Unit](neural_network/activation_functions/scaled_exponential_linear_unit.py)
+ * [Soboleva Modified Hyperbolic Tangent](neural_network/activation_functions/soboleva_modified_hyperbolic_tangent.py)
+ * [Softplus](neural_network/activation_functions/softplus.py)
+ * [Squareplus](neural_network/activation_functions/squareplus.py)
+ * [Swish](neural_network/activation_functions/swish.py)
+ * [Back Propagation Neural Network](neural_network/back_propagation_neural_network.py)
+ * [Convolution Neural Network](neural_network/convolution_neural_network.py)
+ * [Input Data](neural_network/input_data.py)
+ * [Simple Neural Network](neural_network/simple_neural_network.py)
+ * [Two Hidden Layers Neural Network](neural_network/two_hidden_layers_neural_network.py)
## Other
- * [Activity Selection](https://github.com/TheAlgorithms/Python/blob/master/other/activity_selection.py)
- * [Anagrams](https://github.com/TheAlgorithms/Python/blob/master/other/anagrams.py)
- * [Autocomplete Using Trie](https://github.com/TheAlgorithms/Python/blob/master/other/autocomplete_using_trie.py)
- * [Binary Exponentiation](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation.py)
- * [Binary Exponentiation 2](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation_2.py)
- * [Davis–Putnam–Logemann–Loveland](https://github.com/TheAlgorithms/Python/blob/master/other/davis–putnam–logemann–loveland.py)
- * [Detecting English Programmatically](https://github.com/TheAlgorithms/Python/blob/master/other/detecting_english_programmatically.py)
- * [Dijkstra Bankers Algorithm](https://github.com/TheAlgorithms/Python/blob/master/other/dijkstra_bankers_algorithm.py)
- * [Doomsday](https://github.com/TheAlgorithms/Python/blob/master/other/doomsday.py)
- * [Euclidean Gcd](https://github.com/TheAlgorithms/Python/blob/master/other/euclidean_gcd.py)
- * [Fischer Yates Shuffle](https://github.com/TheAlgorithms/Python/blob/master/other/fischer_yates_shuffle.py)
- * [Frequency Finder](https://github.com/TheAlgorithms/Python/blob/master/other/frequency_finder.py)
- * [Game Of Life](https://github.com/TheAlgorithms/Python/blob/master/other/game_of_life.py)
- * [Gauss Easter](https://github.com/TheAlgorithms/Python/blob/master/other/gauss_easter.py)
- * [Greedy](https://github.com/TheAlgorithms/Python/blob/master/other/greedy.py)
- * [Integeration By Simpson Approx](https://github.com/TheAlgorithms/Python/blob/master/other/integeration_by_simpson_approx.py)
- * [Largest Subarray Sum](https://github.com/TheAlgorithms/Python/blob/master/other/largest_subarray_sum.py)
- * [Least Recently Used](https://github.com/TheAlgorithms/Python/blob/master/other/least_recently_used.py)
- * [Lfu Cache](https://github.com/TheAlgorithms/Python/blob/master/other/lfu_cache.py)
- * [Linear Congruential Generator](https://github.com/TheAlgorithms/Python/blob/master/other/linear_congruential_generator.py)
- * [Lru Cache](https://github.com/TheAlgorithms/Python/blob/master/other/lru_cache.py)
- * [Magicdiamondpattern](https://github.com/TheAlgorithms/Python/blob/master/other/magicdiamondpattern.py)
- * [Markov Chain](https://github.com/TheAlgorithms/Python/blob/master/other/markov_chain.py)
- * [Max Sum Sliding Window](https://github.com/TheAlgorithms/Python/blob/master/other/max_sum_sliding_window.py)
- * [Median Of Two Arrays](https://github.com/TheAlgorithms/Python/blob/master/other/median_of_two_arrays.py)
- * [Nested Brackets](https://github.com/TheAlgorithms/Python/blob/master/other/nested_brackets.py)
- * [Palindrome](https://github.com/TheAlgorithms/Python/blob/master/other/palindrome.py)
- * [Password Generator](https://github.com/TheAlgorithms/Python/blob/master/other/password_generator.py)
- * [Primelib](https://github.com/TheAlgorithms/Python/blob/master/other/primelib.py)
- * [Scoring Algorithm](https://github.com/TheAlgorithms/Python/blob/master/other/scoring_algorithm.py)
- * [Sdes](https://github.com/TheAlgorithms/Python/blob/master/other/sdes.py)
- * [Sierpinski Triangle](https://github.com/TheAlgorithms/Python/blob/master/other/sierpinski_triangle.py)
- * [Tower Of Hanoi](https://github.com/TheAlgorithms/Python/blob/master/other/tower_of_hanoi.py)
- * [Triplet Sum](https://github.com/TheAlgorithms/Python/blob/master/other/triplet_sum.py)
- * [Two Pointer](https://github.com/TheAlgorithms/Python/blob/master/other/two_pointer.py)
- * [Two Sum](https://github.com/TheAlgorithms/Python/blob/master/other/two_sum.py)
- * [Word Patterns](https://github.com/TheAlgorithms/Python/blob/master/other/word_patterns.py)
+ * [Activity Selection](other/activity_selection.py)
+ * [Alternative List Arrange](other/alternative_list_arrange.py)
+ * [Bankers Algorithm](other/bankers_algorithm.py)
+ * [Davis Putnam Logemann Loveland](other/davis_putnam_logemann_loveland.py)
+ * [Doomsday](other/doomsday.py)
+ * [Fischer Yates Shuffle](other/fischer_yates_shuffle.py)
+ * [Gauss Easter](other/gauss_easter.py)
+ * [Graham Scan](other/graham_scan.py)
+ * [Greedy](other/greedy.py)
+ * [Guess The Number Search](other/guess_the_number_search.py)
+ * [H Index](other/h_index.py)
+ * [Least Recently Used](other/least_recently_used.py)
+ * [Lfu Cache](other/lfu_cache.py)
+ * [Linear Congruential Generator](other/linear_congruential_generator.py)
+ * [Lru Cache](other/lru_cache.py)
+ * [Magicdiamondpattern](other/magicdiamondpattern.py)
+ * [Majority Vote Algorithm](other/majority_vote_algorithm.py)
+ * [Maximum Subsequence](other/maximum_subsequence.py)
+ * [Nested Brackets](other/nested_brackets.py)
+ * [Number Container System](other/number_container_system.py)
+ * [Password](other/password.py)
+ * [Quine](other/quine.py)
+ * [Scoring Algorithm](other/scoring_algorithm.py)
+ * [Sdes](other/sdes.py)
+ * [Tower Of Hanoi](other/tower_of_hanoi.py)
+ * [Word Search](other/word_search.py)
+
+## Physics
+ * [Altitude Pressure](physics/altitude_pressure.py)
+ * [Archimedes Principle Of Buoyant Force](physics/archimedes_principle_of_buoyant_force.py)
+ * [Basic Orbital Capture](physics/basic_orbital_capture.py)
+ * [Casimir Effect](physics/casimir_effect.py)
+ * [Center Of Mass](physics/center_of_mass.py)
+ * [Centripetal Force](physics/centripetal_force.py)
+ * [Coulombs Law](physics/coulombs_law.py)
+ * [Doppler Frequency](physics/doppler_frequency.py)
+ * [Grahams Law](physics/grahams_law.py)
+ * [Horizontal Projectile Motion](physics/horizontal_projectile_motion.py)
+ * [Hubble Parameter](physics/hubble_parameter.py)
+ * [Ideal Gas Law](physics/ideal_gas_law.py)
+ * [In Static Equilibrium](physics/in_static_equilibrium.py)
+ * [Kinetic Energy](physics/kinetic_energy.py)
+ * [Lens Formulae](physics/lens_formulae.py)
+ * [Lorentz Transformation Four Vector](physics/lorentz_transformation_four_vector.py)
+ * [Malus Law](physics/malus_law.py)
+ * [Mass Energy Equivalence](physics/mass_energy_equivalence.py)
+ * [Mirror Formulae](physics/mirror_formulae.py)
+ * [N Body Simulation](physics/n_body_simulation.py)
+ * [Newtons Law Of Gravitation](physics/newtons_law_of_gravitation.py)
+ * [Newtons Second Law Of Motion](physics/newtons_second_law_of_motion.py)
+ * [Period Of Pendulum](physics/period_of_pendulum.py)
+ * [Photoelectric Effect](physics/photoelectric_effect.py)
+ * [Potential Energy](physics/potential_energy.py)
+ * [Rainfall Intensity](physics/rainfall_intensity.py)
+ * [Reynolds Number](physics/reynolds_number.py)
+ * [Rms Speed Of Molecule](physics/rms_speed_of_molecule.py)
+ * [Shear Stress](physics/shear_stress.py)
+ * [Speed Of Sound](physics/speed_of_sound.py)
+ * [Speeds Of Gas Molecules](physics/speeds_of_gas_molecules.py)
+ * [Terminal Velocity](physics/terminal_velocity.py)
## Project Euler
* Problem 001
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_001/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_001/sol2.py)
- * [Sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_001/sol3.py)
- * [Sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_001/sol4.py)
- * [Sol5](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_001/sol5.py)
- * [Sol6](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_001/sol6.py)
- * [Sol7](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_001/sol7.py)
+ * [Sol1](project_euler/problem_001/sol1.py)
+ * [Sol2](project_euler/problem_001/sol2.py)
+ * [Sol3](project_euler/problem_001/sol3.py)
+ * [Sol4](project_euler/problem_001/sol4.py)
+ * [Sol5](project_euler/problem_001/sol5.py)
+ * [Sol6](project_euler/problem_001/sol6.py)
+ * [Sol7](project_euler/problem_001/sol7.py)
* Problem 002
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_002/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_002/sol2.py)
- * [Sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_002/sol3.py)
- * [Sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_002/sol4.py)
- * [Sol5](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_002/sol5.py)
+ * [Sol1](project_euler/problem_002/sol1.py)
+ * [Sol2](project_euler/problem_002/sol2.py)
+ * [Sol3](project_euler/problem_002/sol3.py)
+ * [Sol4](project_euler/problem_002/sol4.py)
+ * [Sol5](project_euler/problem_002/sol5.py)
* Problem 003
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_003/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_003/sol2.py)
- * [Sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_003/sol3.py)
+ * [Sol1](project_euler/problem_003/sol1.py)
+ * [Sol2](project_euler/problem_003/sol2.py)
+ * [Sol3](project_euler/problem_003/sol3.py)
* Problem 004
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_004/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_004/sol2.py)
+ * [Sol1](project_euler/problem_004/sol1.py)
+ * [Sol2](project_euler/problem_004/sol2.py)
* Problem 005
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_005/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_005/sol2.py)
+ * [Sol1](project_euler/problem_005/sol1.py)
+ * [Sol2](project_euler/problem_005/sol2.py)
* Problem 006
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_006/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_006/sol2.py)
- * [Sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_006/sol3.py)
- * [Sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_006/sol4.py)
+ * [Sol1](project_euler/problem_006/sol1.py)
+ * [Sol2](project_euler/problem_006/sol2.py)
+ * [Sol3](project_euler/problem_006/sol3.py)
+ * [Sol4](project_euler/problem_006/sol4.py)
* Problem 007
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_007/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_007/sol2.py)
- * [Sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_007/sol3.py)
+ * [Sol1](project_euler/problem_007/sol1.py)
+ * [Sol2](project_euler/problem_007/sol2.py)
+ * [Sol3](project_euler/problem_007/sol3.py)
* Problem 008
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_008/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_008/sol2.py)
- * [Sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_008/sol3.py)
+ * [Sol1](project_euler/problem_008/sol1.py)
+ * [Sol2](project_euler/problem_008/sol2.py)
+ * [Sol3](project_euler/problem_008/sol3.py)
* Problem 009
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_009/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_009/sol2.py)
- * [Sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_009/sol3.py)
+ * [Sol1](project_euler/problem_009/sol1.py)
+ * [Sol2](project_euler/problem_009/sol2.py)
+ * [Sol3](project_euler/problem_009/sol3.py)
* Problem 010
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_010/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_010/sol2.py)
- * [Sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_010/sol3.py)
+ * [Sol1](project_euler/problem_010/sol1.py)
+ * [Sol2](project_euler/problem_010/sol2.py)
+ * [Sol3](project_euler/problem_010/sol3.py)
* Problem 011
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_011/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_011/sol2.py)
+ * [Sol1](project_euler/problem_011/sol1.py)
+ * [Sol2](project_euler/problem_011/sol2.py)
* Problem 012
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_012/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_012/sol2.py)
+ * [Sol1](project_euler/problem_012/sol1.py)
+ * [Sol2](project_euler/problem_012/sol2.py)
* Problem 013
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_013/sol1.py)
+ * [Sol1](project_euler/problem_013/sol1.py)
* Problem 014
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_014/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_014/sol2.py)
+ * [Sol1](project_euler/problem_014/sol1.py)
+ * [Sol2](project_euler/problem_014/sol2.py)
* Problem 015
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_015/sol1.py)
+ * [Sol1](project_euler/problem_015/sol1.py)
* Problem 016
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_016/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_016/sol2.py)
+ * [Sol1](project_euler/problem_016/sol1.py)
+ * [Sol2](project_euler/problem_016/sol2.py)
* Problem 017
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_017/sol1.py)
+ * [Sol1](project_euler/problem_017/sol1.py)
* Problem 018
- * [Solution](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_018/solution.py)
+ * [Solution](project_euler/problem_018/solution.py)
* Problem 019
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_019/sol1.py)
+ * [Sol1](project_euler/problem_019/sol1.py)
* Problem 020
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_020/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_020/sol2.py)
- * [Sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_020/sol3.py)
- * [Sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_020/sol4.py)
+ * [Sol1](project_euler/problem_020/sol1.py)
+ * [Sol2](project_euler/problem_020/sol2.py)
+ * [Sol3](project_euler/problem_020/sol3.py)
+ * [Sol4](project_euler/problem_020/sol4.py)
* Problem 021
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_021/sol1.py)
+ * [Sol1](project_euler/problem_021/sol1.py)
* Problem 022
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_022/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_022/sol2.py)
+ * [Sol1](project_euler/problem_022/sol1.py)
+ * [Sol2](project_euler/problem_022/sol2.py)
* Problem 023
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_023/sol1.py)
+ * [Sol1](project_euler/problem_023/sol1.py)
* Problem 024
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_024/sol1.py)
+ * [Sol1](project_euler/problem_024/sol1.py)
* Problem 025
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_025/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_025/sol2.py)
- * [Sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_025/sol3.py)
+ * [Sol1](project_euler/problem_025/sol1.py)
+ * [Sol2](project_euler/problem_025/sol2.py)
+ * [Sol3](project_euler/problem_025/sol3.py)
* Problem 026
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_026/sol1.py)
+ * [Sol1](project_euler/problem_026/sol1.py)
* Problem 027
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_027/sol1.py)
+ * [Sol1](project_euler/problem_027/sol1.py)
* Problem 028
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_028/sol1.py)
+ * [Sol1](project_euler/problem_028/sol1.py)
* Problem 029
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_029/sol1.py)
+ * [Sol1](project_euler/problem_029/sol1.py)
* Problem 030
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_030/sol1.py)
+ * [Sol1](project_euler/problem_030/sol1.py)
* Problem 031
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_031/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_031/sol2.py)
+ * [Sol1](project_euler/problem_031/sol1.py)
+ * [Sol2](project_euler/problem_031/sol2.py)
* Problem 032
- * [Sol32](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_032/sol32.py)
+ * [Sol32](project_euler/problem_032/sol32.py)
* Problem 033
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_033/sol1.py)
+ * [Sol1](project_euler/problem_033/sol1.py)
* Problem 034
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_034/sol1.py)
+ * [Sol1](project_euler/problem_034/sol1.py)
* Problem 035
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_035/sol1.py)
+ * [Sol1](project_euler/problem_035/sol1.py)
* Problem 036
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_036/sol1.py)
+ * [Sol1](project_euler/problem_036/sol1.py)
* Problem 037
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_037/sol1.py)
+ * [Sol1](project_euler/problem_037/sol1.py)
* Problem 038
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_038/sol1.py)
+ * [Sol1](project_euler/problem_038/sol1.py)
* Problem 039
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_039/sol1.py)
+ * [Sol1](project_euler/problem_039/sol1.py)
* Problem 040
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_040/sol1.py)
+ * [Sol1](project_euler/problem_040/sol1.py)
* Problem 041
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_041/sol1.py)
+ * [Sol1](project_euler/problem_041/sol1.py)
* Problem 042
- * [Solution42](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_042/solution42.py)
+ * [Solution42](project_euler/problem_042/solution42.py)
* Problem 043
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_043/sol1.py)
+ * [Sol1](project_euler/problem_043/sol1.py)
* Problem 044
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_044/sol1.py)
+ * [Sol1](project_euler/problem_044/sol1.py)
* Problem 045
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_045/sol1.py)
+ * [Sol1](project_euler/problem_045/sol1.py)
* Problem 046
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_046/sol1.py)
+ * [Sol1](project_euler/problem_046/sol1.py)
* Problem 047
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_047/sol1.py)
+ * [Sol1](project_euler/problem_047/sol1.py)
* Problem 048
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_048/sol1.py)
+ * [Sol1](project_euler/problem_048/sol1.py)
* Problem 049
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_049/sol1.py)
+ * [Sol1](project_euler/problem_049/sol1.py)
* Problem 050
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_050/sol1.py)
+ * [Sol1](project_euler/problem_050/sol1.py)
* Problem 051
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_051/sol1.py)
+ * [Sol1](project_euler/problem_051/sol1.py)
* Problem 052
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_052/sol1.py)
+ * [Sol1](project_euler/problem_052/sol1.py)
* Problem 053
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_053/sol1.py)
+ * [Sol1](project_euler/problem_053/sol1.py)
* Problem 054
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_054/sol1.py)
- * [Test Poker Hand](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_054/test_poker_hand.py)
+ * [Sol1](project_euler/problem_054/sol1.py)
+ * [Test Poker Hand](project_euler/problem_054/test_poker_hand.py)
* Problem 055
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_055/sol1.py)
+ * [Sol1](project_euler/problem_055/sol1.py)
* Problem 056
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_056/sol1.py)
+ * [Sol1](project_euler/problem_056/sol1.py)
* Problem 057
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_057/sol1.py)
+ * [Sol1](project_euler/problem_057/sol1.py)
* Problem 058
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_058/sol1.py)
+ * [Sol1](project_euler/problem_058/sol1.py)
+ * Problem 059
+ * [Sol1](project_euler/problem_059/sol1.py)
* Problem 062
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_062/sol1.py)
+ * [Sol1](project_euler/problem_062/sol1.py)
* Problem 063
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_063/sol1.py)
+ * [Sol1](project_euler/problem_063/sol1.py)
* Problem 064
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_064/sol1.py)
+ * [Sol1](project_euler/problem_064/sol1.py)
* Problem 065
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_065/sol1.py)
+ * [Sol1](project_euler/problem_065/sol1.py)
* Problem 067
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_067/sol1.py)
+ * [Sol1](project_euler/problem_067/sol1.py)
+ * [Sol2](project_euler/problem_067/sol2.py)
+ * Problem 068
+ * [Sol1](project_euler/problem_068/sol1.py)
* Problem 069
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_069/sol1.py)
+ * [Sol1](project_euler/problem_069/sol1.py)
+ * Problem 070
+ * [Sol1](project_euler/problem_070/sol1.py)
* Problem 071
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_071/sol1.py)
+ * [Sol1](project_euler/problem_071/sol1.py)
* Problem 072
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_072/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_072/sol2.py)
+ * [Sol1](project_euler/problem_072/sol1.py)
+ * [Sol2](project_euler/problem_072/sol2.py)
+ * Problem 073
+ * [Sol1](project_euler/problem_073/sol1.py)
* Problem 074
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_074/sol1.py)
- * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_074/sol2.py)
+ * [Sol1](project_euler/problem_074/sol1.py)
+ * [Sol2](project_euler/problem_074/sol2.py)
* Problem 075
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_075/sol1.py)
+ * [Sol1](project_euler/problem_075/sol1.py)
* Problem 076
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_076/sol1.py)
+ * [Sol1](project_euler/problem_076/sol1.py)
+ * Problem 077
+ * [Sol1](project_euler/problem_077/sol1.py)
+ * Problem 078
+ * [Sol1](project_euler/problem_078/sol1.py)
+ * Problem 079
+ * [Sol1](project_euler/problem_079/sol1.py)
* Problem 080
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_080/sol1.py)
+ * [Sol1](project_euler/problem_080/sol1.py)
* Problem 081
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_081/sol1.py)
+ * [Sol1](project_euler/problem_081/sol1.py)
+ * Problem 082
+ * [Sol1](project_euler/problem_082/sol1.py)
+ * Problem 085
+ * [Sol1](project_euler/problem_085/sol1.py)
+ * Problem 086
+ * [Sol1](project_euler/problem_086/sol1.py)
* Problem 087
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_087/sol1.py)
+ * [Sol1](project_euler/problem_087/sol1.py)
+ * Problem 089
+ * [Sol1](project_euler/problem_089/sol1.py)
* Problem 091
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_091/sol1.py)
+ * [Sol1](project_euler/problem_091/sol1.py)
+ * Problem 092
+ * [Sol1](project_euler/problem_092/sol1.py)
+ * Problem 094
+ * [Sol1](project_euler/problem_094/sol1.py)
* Problem 097
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_097/sol1.py)
+ * [Sol1](project_euler/problem_097/sol1.py)
* Problem 099
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_099/sol1.py)
+ * [Sol1](project_euler/problem_099/sol1.py)
+ * Problem 100
+ * [Sol1](project_euler/problem_100/sol1.py)
+ * Problem 101
+ * [Sol1](project_euler/problem_101/sol1.py)
+ * Problem 102
+ * [Sol1](project_euler/problem_102/sol1.py)
+ * Problem 104
+ * [Sol1](project_euler/problem_104/sol1.py)
+ * Problem 107
+ * [Sol1](project_euler/problem_107/sol1.py)
+ * Problem 109
+ * [Sol1](project_euler/problem_109/sol1.py)
* Problem 112
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_112/sol1.py)
+ * [Sol1](project_euler/problem_112/sol1.py)
* Problem 113
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_113/sol1.py)
+ * [Sol1](project_euler/problem_113/sol1.py)
+ * Problem 114
+ * [Sol1](project_euler/problem_114/sol1.py)
+ * Problem 115
+ * [Sol1](project_euler/problem_115/sol1.py)
+ * Problem 116
+ * [Sol1](project_euler/problem_116/sol1.py)
+ * Problem 117
+ * [Sol1](project_euler/problem_117/sol1.py)
* Problem 119
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_119/sol1.py)
+ * [Sol1](project_euler/problem_119/sol1.py)
* Problem 120
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_120/sol1.py)
+ * [Sol1](project_euler/problem_120/sol1.py)
+ * Problem 121
+ * [Sol1](project_euler/problem_121/sol1.py)
* Problem 123
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_123/sol1.py)
+ * [Sol1](project_euler/problem_123/sol1.py)
* Problem 125
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_125/sol1.py)
+ * [Sol1](project_euler/problem_125/sol1.py)
+ * Problem 129
+ * [Sol1](project_euler/problem_129/sol1.py)
+ * Problem 131
+ * [Sol1](project_euler/problem_131/sol1.py)
+ * Problem 135
+ * [Sol1](project_euler/problem_135/sol1.py)
+ * Problem 144
+ * [Sol1](project_euler/problem_144/sol1.py)
+ * Problem 145
+ * [Sol1](project_euler/problem_145/sol1.py)
* Problem 173
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_173/sol1.py)
+ * [Sol1](project_euler/problem_173/sol1.py)
* Problem 174
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_174/sol1.py)
+ * [Sol1](project_euler/problem_174/sol1.py)
+ * Problem 180
+ * [Sol1](project_euler/problem_180/sol1.py)
+ * Problem 187
+ * [Sol1](project_euler/problem_187/sol1.py)
+ * Problem 188
+ * [Sol1](project_euler/problem_188/sol1.py)
* Problem 191
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_191/sol1.py)
+ * [Sol1](project_euler/problem_191/sol1.py)
* Problem 203
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_203/sol1.py)
+ * [Sol1](project_euler/problem_203/sol1.py)
+ * Problem 205
+ * [Sol1](project_euler/problem_205/sol1.py)
* Problem 206
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_206/sol1.py)
+ * [Sol1](project_euler/problem_206/sol1.py)
* Problem 207
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_207/sol1.py)
+ * [Sol1](project_euler/problem_207/sol1.py)
* Problem 234
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_234/sol1.py)
+ * [Sol1](project_euler/problem_234/sol1.py)
* Problem 301
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_301/sol1.py)
+ * [Sol1](project_euler/problem_301/sol1.py)
+ * Problem 493
+ * [Sol1](project_euler/problem_493/sol1.py)
* Problem 551
- * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_551/sol1.py)
+ * [Sol1](project_euler/problem_551/sol1.py)
+ * Problem 587
+ * [Sol1](project_euler/problem_587/sol1.py)
+ * Problem 686
+ * [Sol1](project_euler/problem_686/sol1.py)
+ * Problem 800
+ * [Sol1](project_euler/problem_800/sol1.py)
## Quantum
- * [Deutsch Jozsa](https://github.com/TheAlgorithms/Python/blob/master/quantum/deutsch_jozsa.py)
- * [Half Adder](https://github.com/TheAlgorithms/Python/blob/master/quantum/half_adder.py)
- * [Not Gate](https://github.com/TheAlgorithms/Python/blob/master/quantum/not_gate.py)
- * [Quantum Entanglement](https://github.com/TheAlgorithms/Python/blob/master/quantum/quantum_entanglement.py)
- * [Ripple Adder Classic](https://github.com/TheAlgorithms/Python/blob/master/quantum/ripple_adder_classic.py)
- * [Single Qubit Measure](https://github.com/TheAlgorithms/Python/blob/master/quantum/single_qubit_measure.py)
+ * [Q Fourier Transform](quantum/q_fourier_transform.py)
## Scheduling
- * [First Come First Served](https://github.com/TheAlgorithms/Python/blob/master/scheduling/first_come_first_served.py)
- * [Round Robin](https://github.com/TheAlgorithms/Python/blob/master/scheduling/round_robin.py)
- * [Shortest Job First](https://github.com/TheAlgorithms/Python/blob/master/scheduling/shortest_job_first.py)
+ * [First Come First Served](scheduling/first_come_first_served.py)
+ * [Highest Response Ratio Next](scheduling/highest_response_ratio_next.py)
+ * [Job Sequence With Deadline](scheduling/job_sequence_with_deadline.py)
+ * [Job Sequencing With Deadline](scheduling/job_sequencing_with_deadline.py)
+ * [Multi Level Feedback Queue](scheduling/multi_level_feedback_queue.py)
+ * [Non Preemptive Shortest Job First](scheduling/non_preemptive_shortest_job_first.py)
+ * [Round Robin](scheduling/round_robin.py)
+ * [Shortest Job First](scheduling/shortest_job_first.py)
## Searches
- * [Binary Search](https://github.com/TheAlgorithms/Python/blob/master/searches/binary_search.py)
- * [Double Linear Search](https://github.com/TheAlgorithms/Python/blob/master/searches/double_linear_search.py)
- * [Double Linear Search Recursion](https://github.com/TheAlgorithms/Python/blob/master/searches/double_linear_search_recursion.py)
- * [Fibonacci Search](https://github.com/TheAlgorithms/Python/blob/master/searches/fibonacci_search.py)
- * [Hill Climbing](https://github.com/TheAlgorithms/Python/blob/master/searches/hill_climbing.py)
- * [Interpolation Search](https://github.com/TheAlgorithms/Python/blob/master/searches/interpolation_search.py)
- * [Jump Search](https://github.com/TheAlgorithms/Python/blob/master/searches/jump_search.py)
- * [Linear Search](https://github.com/TheAlgorithms/Python/blob/master/searches/linear_search.py)
- * [Quick Select](https://github.com/TheAlgorithms/Python/blob/master/searches/quick_select.py)
- * [Sentinel Linear Search](https://github.com/TheAlgorithms/Python/blob/master/searches/sentinel_linear_search.py)
- * [Simple Binary Search](https://github.com/TheAlgorithms/Python/blob/master/searches/simple_binary_search.py)
- * [Simulated Annealing](https://github.com/TheAlgorithms/Python/blob/master/searches/simulated_annealing.py)
- * [Tabu Search](https://github.com/TheAlgorithms/Python/blob/master/searches/tabu_search.py)
- * [Ternary Search](https://github.com/TheAlgorithms/Python/blob/master/searches/ternary_search.py)
+ * [Binary Search](searches/binary_search.py)
+ * [Binary Tree Traversal](searches/binary_tree_traversal.py)
+ * [Double Linear Search](searches/double_linear_search.py)
+ * [Double Linear Search Recursion](searches/double_linear_search_recursion.py)
+ * [Exponential Search](searches/exponential_search.py)
+ * [Fibonacci Search](searches/fibonacci_search.py)
+ * [Hill Climbing](searches/hill_climbing.py)
+ * [Interpolation Search](searches/interpolation_search.py)
+ * [Jump Search](searches/jump_search.py)
+ * [Linear Search](searches/linear_search.py)
+ * [Median Of Medians](searches/median_of_medians.py)
+ * [Quick Select](searches/quick_select.py)
+ * [Sentinel Linear Search](searches/sentinel_linear_search.py)
+ * [Simple Binary Search](searches/simple_binary_search.py)
+ * [Simulated Annealing](searches/simulated_annealing.py)
+ * [Tabu Search](searches/tabu_search.py)
+ * [Ternary Search](searches/ternary_search.py)
## Sorts
- * [Bead Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bead_sort.py)
- * [Bitonic Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bitonic_sort.py)
- * [Bogo Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bogo_sort.py)
- * [Bubble Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bubble_sort.py)
- * [Bucket Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bucket_sort.py)
- * [Cocktail Shaker Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/cocktail_shaker_sort.py)
- * [Comb Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/comb_sort.py)
- * [Counting Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/counting_sort.py)
- * [Cycle Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/cycle_sort.py)
- * [Double Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/double_sort.py)
- * [External Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/external_sort.py)
- * [Gnome Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/gnome_sort.py)
- * [Heap Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/heap_sort.py)
- * [Insertion Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/insertion_sort.py)
- * [Iterative Merge Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/iterative_merge_sort.py)
- * [Merge Insertion Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_insertion_sort.py)
- * [Merge Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort.py)
- * [Natural Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/natural_sort.py)
- * [Odd Even Transposition Parallel](https://github.com/TheAlgorithms/Python/blob/master/sorts/odd_even_transposition_parallel.py)
- * [Odd Even Transposition Single Threaded](https://github.com/TheAlgorithms/Python/blob/master/sorts/odd_even_transposition_single_threaded.py)
- * [Pancake Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pancake_sort.py)
- * [Patience Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/patience_sort.py)
- * [Pigeon Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pigeon_sort.py)
- * [Pigeonhole Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pigeonhole_sort.py)
- * [Quick Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/quick_sort.py)
- * [Quick Sort 3 Partition](https://github.com/TheAlgorithms/Python/blob/master/sorts/quick_sort_3_partition.py)
- * [Radix Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/radix_sort.py)
- * [Random Normal Distribution Quicksort](https://github.com/TheAlgorithms/Python/blob/master/sorts/random_normal_distribution_quicksort.py)
- * [Random Pivot Quick Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/random_pivot_quick_sort.py)
- * [Recursive Bubble Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/recursive_bubble_sort.py)
- * [Recursive Insertion Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/recursive_insertion_sort.py)
- * [Recursive Quick Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/recursive_quick_sort.py)
- * [Selection Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/selection_sort.py)
- * [Shell Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/shell_sort.py)
- * [Stooge Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/stooge_sort.py)
- * [Strand Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/strand_sort.py)
- * [Tim Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/tim_sort.py)
- * [Topological Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/topological_sort.py)
- * [Tree Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/tree_sort.py)
- * [Unknown Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/unknown_sort.py)
- * [Wiggle Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/wiggle_sort.py)
+ * [Bead Sort](sorts/bead_sort.py)
+ * [Binary Insertion Sort](sorts/binary_insertion_sort.py)
+ * [Bitonic Sort](sorts/bitonic_sort.py)
+ * [Bogo Sort](sorts/bogo_sort.py)
+ * [Bubble Sort](sorts/bubble_sort.py)
+ * [Bucket Sort](sorts/bucket_sort.py)
+ * [Circle Sort](sorts/circle_sort.py)
+ * [Cocktail Shaker Sort](sorts/cocktail_shaker_sort.py)
+ * [Comb Sort](sorts/comb_sort.py)
+ * [Counting Sort](sorts/counting_sort.py)
+ * [Cycle Sort](sorts/cycle_sort.py)
+ * [Double Sort](sorts/double_sort.py)
+ * [Dutch National Flag Sort](sorts/dutch_national_flag_sort.py)
+ * [Exchange Sort](sorts/exchange_sort.py)
+ * [External Sort](sorts/external_sort.py)
+ * [Gnome Sort](sorts/gnome_sort.py)
+ * [Heap Sort](sorts/heap_sort.py)
+ * [Insertion Sort](sorts/insertion_sort.py)
+ * [Intro Sort](sorts/intro_sort.py)
+ * [Iterative Merge Sort](sorts/iterative_merge_sort.py)
+ * [Merge Insertion Sort](sorts/merge_insertion_sort.py)
+ * [Merge Sort](sorts/merge_sort.py)
+ * [Msd Radix Sort](sorts/msd_radix_sort.py)
+ * [Natural Sort](sorts/natural_sort.py)
+ * [Odd Even Sort](sorts/odd_even_sort.py)
+ * [Odd Even Transposition Parallel](sorts/odd_even_transposition_parallel.py)
+ * [Odd Even Transposition Single Threaded](sorts/odd_even_transposition_single_threaded.py)
+ * [Pancake Sort](sorts/pancake_sort.py)
+ * [Patience Sort](sorts/patience_sort.py)
+ * [Pigeon Sort](sorts/pigeon_sort.py)
+ * [Pigeonhole Sort](sorts/pigeonhole_sort.py)
+ * [Quick Sort](sorts/quick_sort.py)
+ * [Quick Sort 3 Partition](sorts/quick_sort_3_partition.py)
+ * [Radix Sort](sorts/radix_sort.py)
+ * [Recursive Insertion Sort](sorts/recursive_insertion_sort.py)
+ * [Recursive Mergesort Array](sorts/recursive_mergesort_array.py)
+ * [Recursive Quick Sort](sorts/recursive_quick_sort.py)
+ * [Selection Sort](sorts/selection_sort.py)
+ * [Shell Sort](sorts/shell_sort.py)
+ * [Shrink Shell Sort](sorts/shrink_shell_sort.py)
+ * [Slowsort](sorts/slowsort.py)
+ * [Stooge Sort](sorts/stooge_sort.py)
+ * [Strand Sort](sorts/strand_sort.py)
+ * [Tim Sort](sorts/tim_sort.py)
+ * [Topological Sort](sorts/topological_sort.py)
+ * [Tree Sort](sorts/tree_sort.py)
+ * [Unknown Sort](sorts/unknown_sort.py)
+ * [Wiggle Sort](sorts/wiggle_sort.py)
## Strings
- * [Aho Corasick](https://github.com/TheAlgorithms/Python/blob/master/strings/aho_corasick.py)
- * [Boyer Moore Search](https://github.com/TheAlgorithms/Python/blob/master/strings/boyer_moore_search.py)
- * [Can String Be Rearranged As Palindrome](https://github.com/TheAlgorithms/Python/blob/master/strings/can_string_be_rearranged_as_palindrome.py)
- * [Capitalize](https://github.com/TheAlgorithms/Python/blob/master/strings/capitalize.py)
- * [Check Anagrams](https://github.com/TheAlgorithms/Python/blob/master/strings/check_anagrams.py)
- * [Check Pangram](https://github.com/TheAlgorithms/Python/blob/master/strings/check_pangram.py)
- * [Is Palindrome](https://github.com/TheAlgorithms/Python/blob/master/strings/is_palindrome.py)
- * [Jaro Winkler](https://github.com/TheAlgorithms/Python/blob/master/strings/jaro_winkler.py)
- * [Knuth Morris Pratt](https://github.com/TheAlgorithms/Python/blob/master/strings/knuth_morris_pratt.py)
- * [Levenshtein Distance](https://github.com/TheAlgorithms/Python/blob/master/strings/levenshtein_distance.py)
- * [Lower](https://github.com/TheAlgorithms/Python/blob/master/strings/lower.py)
- * [Manacher](https://github.com/TheAlgorithms/Python/blob/master/strings/manacher.py)
- * [Min Cost String Conversion](https://github.com/TheAlgorithms/Python/blob/master/strings/min_cost_string_conversion.py)
- * [Naive String Search](https://github.com/TheAlgorithms/Python/blob/master/strings/naive_string_search.py)
- * [Prefix Function](https://github.com/TheAlgorithms/Python/blob/master/strings/prefix_function.py)
- * [Rabin Karp](https://github.com/TheAlgorithms/Python/blob/master/strings/rabin_karp.py)
- * [Remove Duplicate](https://github.com/TheAlgorithms/Python/blob/master/strings/remove_duplicate.py)
- * [Reverse Letters](https://github.com/TheAlgorithms/Python/blob/master/strings/reverse_letters.py)
- * [Reverse Words](https://github.com/TheAlgorithms/Python/blob/master/strings/reverse_words.py)
- * [Split](https://github.com/TheAlgorithms/Python/blob/master/strings/split.py)
- * [Swap Case](https://github.com/TheAlgorithms/Python/blob/master/strings/swap_case.py)
- * [Upper](https://github.com/TheAlgorithms/Python/blob/master/strings/upper.py)
- * [Word Occurrence](https://github.com/TheAlgorithms/Python/blob/master/strings/word_occurrence.py)
- * [Z Function](https://github.com/TheAlgorithms/Python/blob/master/strings/z_function.py)
-
-## Traversals
- * [Binary Tree Traversals](https://github.com/TheAlgorithms/Python/blob/master/traversals/binary_tree_traversals.py)
+ * [Aho Corasick](strings/aho_corasick.py)
+ * [Alternative String Arrange](strings/alternative_string_arrange.py)
+ * [Anagrams](strings/anagrams.py)
+ * [Autocomplete Using Trie](strings/autocomplete_using_trie.py)
+ * [Barcode Validator](strings/barcode_validator.py)
+ * [Bitap String Match](strings/bitap_string_match.py)
+ * [Boyer Moore Search](strings/boyer_moore_search.py)
+ * [Camel Case To Snake Case](strings/camel_case_to_snake_case.py)
+ * [Can String Be Rearranged As Palindrome](strings/can_string_be_rearranged_as_palindrome.py)
+ * [Capitalize](strings/capitalize.py)
+ * [Check Anagrams](strings/check_anagrams.py)
+ * [Count Vowels](strings/count_vowels.py)
+ * [Credit Card Validator](strings/credit_card_validator.py)
+ * [Damerau Levenshtein Distance](strings/damerau_levenshtein_distance.py)
+ * [Detecting English Programmatically](strings/detecting_english_programmatically.py)
+ * [Dna](strings/dna.py)
+ * [Edit Distance](strings/edit_distance.py)
+ * [Frequency Finder](strings/frequency_finder.py)
+ * [Hamming Distance](strings/hamming_distance.py)
+ * [Indian Phone Validator](strings/indian_phone_validator.py)
+ * [Is Contains Unique Chars](strings/is_contains_unique_chars.py)
+ * [Is Isogram](strings/is_isogram.py)
+ * [Is Pangram](strings/is_pangram.py)
+ * [Is Polish National Id](strings/is_polish_national_id.py)
+ * [Is Spain National Id](strings/is_spain_national_id.py)
+ * [Is Srilankan Phone Number](strings/is_srilankan_phone_number.py)
+ * [Is Valid Email Address](strings/is_valid_email_address.py)
+ * [Jaro Winkler](strings/jaro_winkler.py)
+ * [Join](strings/join.py)
+ * [Knuth Morris Pratt](strings/knuth_morris_pratt.py)
+ * [Levenshtein Distance](strings/levenshtein_distance.py)
+ * [Lower](strings/lower.py)
+ * [Manacher](strings/manacher.py)
+ * [Min Cost String Conversion](strings/min_cost_string_conversion.py)
+ * [Naive String Search](strings/naive_string_search.py)
+ * [Ngram](strings/ngram.py)
+ * [Palindrome](strings/palindrome.py)
+ * [Pig Latin](strings/pig_latin.py)
+ * [Prefix Function](strings/prefix_function.py)
+ * [Rabin Karp](strings/rabin_karp.py)
+ * [Remove Duplicate](strings/remove_duplicate.py)
+ * [Reverse Letters](strings/reverse_letters.py)
+ * [Reverse Words](strings/reverse_words.py)
+ * [Snake Case To Camel Pascal Case](strings/snake_case_to_camel_pascal_case.py)
+ * [Split](strings/split.py)
+ * [String Switch Case](strings/string_switch_case.py)
+ * [Strip](strings/strip.py)
+ * [Text Justification](strings/text_justification.py)
+ * [Title](strings/title.py)
+ * [Top K Frequent Words](strings/top_k_frequent_words.py)
+ * [Upper](strings/upper.py)
+ * [Wave String](strings/wave_string.py)
+ * [Wildcard Pattern Matching](strings/wildcard_pattern_matching.py)
+ * [Word Occurrence](strings/word_occurrence.py)
+ * [Word Patterns](strings/word_patterns.py)
+ * [Z Function](strings/z_function.py)
## Web Programming
- * [Co2 Emission](https://github.com/TheAlgorithms/Python/blob/master/web_programming/co2_emission.py)
- * [Covid Stats Via Xpath](https://github.com/TheAlgorithms/Python/blob/master/web_programming/covid_stats_via_xpath.py)
- * [Crawl Google Results](https://github.com/TheAlgorithms/Python/blob/master/web_programming/crawl_google_results.py)
- * [Crawl Google Scholar Citation](https://github.com/TheAlgorithms/Python/blob/master/web_programming/crawl_google_scholar_citation.py)
- * [Current Stock Price](https://github.com/TheAlgorithms/Python/blob/master/web_programming/current_stock_price.py)
- * [Current Weather](https://github.com/TheAlgorithms/Python/blob/master/web_programming/current_weather.py)
- * [Daily Horoscope](https://github.com/TheAlgorithms/Python/blob/master/web_programming/daily_horoscope.py)
- * [Emails From Url](https://github.com/TheAlgorithms/Python/blob/master/web_programming/emails_from_url.py)
- * [Fetch Bbc News](https://github.com/TheAlgorithms/Python/blob/master/web_programming/fetch_bbc_news.py)
- * [Fetch Github Info](https://github.com/TheAlgorithms/Python/blob/master/web_programming/fetch_github_info.py)
- * [Fetch Jobs](https://github.com/TheAlgorithms/Python/blob/master/web_programming/fetch_jobs.py)
- * [Get Imdb Top 250 Movies Csv](https://github.com/TheAlgorithms/Python/blob/master/web_programming/get_imdb_top_250_movies_csv.py)
- * [Get Imdbtop](https://github.com/TheAlgorithms/Python/blob/master/web_programming/get_imdbtop.py)
- * [Instagram Crawler](https://github.com/TheAlgorithms/Python/blob/master/web_programming/instagram_crawler.py)
- * [Recaptcha Verification](https://github.com/TheAlgorithms/Python/blob/master/web_programming/recaptcha_verification.py)
- * [Slack Message](https://github.com/TheAlgorithms/Python/blob/master/web_programming/slack_message.py)
- * [World Covid19 Stats](https://github.com/TheAlgorithms/Python/blob/master/web_programming/world_covid19_stats.py)
+ * [Co2 Emission](web_programming/co2_emission.py)
+ * [Covid Stats Via Xpath](web_programming/covid_stats_via_xpath.py)
+ * [Crawl Google Results](web_programming/crawl_google_results.py)
+ * [Crawl Google Scholar Citation](web_programming/crawl_google_scholar_citation.py)
+ * [Currency Converter](web_programming/currency_converter.py)
+ * [Current Stock Price](web_programming/current_stock_price.py)
+ * [Current Weather](web_programming/current_weather.py)
+ * [Daily Horoscope](web_programming/daily_horoscope.py)
+ * [Download Images From Google Query](web_programming/download_images_from_google_query.py)
+ * [Emails From Url](web_programming/emails_from_url.py)
+ * [Fetch Anime And Play](web_programming/fetch_anime_and_play.py)
+ * [Fetch Bbc News](web_programming/fetch_bbc_news.py)
+ * [Fetch Github Info](web_programming/fetch_github_info.py)
+ * [Fetch Jobs](web_programming/fetch_jobs.py)
+ * [Fetch Quotes](web_programming/fetch_quotes.py)
+ * [Fetch Well Rx Price](web_programming/fetch_well_rx_price.py)
+ * [Get Amazon Product Data](web_programming/get_amazon_product_data.py)
+ * [Get Imdb Top 250 Movies Csv](web_programming/get_imdb_top_250_movies_csv.py)
+ * [Get Ip Geolocation](web_programming/get_ip_geolocation.py)
+ * [Get Top Billionaires](web_programming/get_top_billionaires.py)
+ * [Get Top Hn Posts](web_programming/get_top_hn_posts.py)
+ * [Giphy](web_programming/giphy.py)
+ * [Instagram Crawler](web_programming/instagram_crawler.py)
+ * [Instagram Pic](web_programming/instagram_pic.py)
+ * [Instagram Video](web_programming/instagram_video.py)
+ * [Nasa Data](web_programming/nasa_data.py)
+ * [Open Google Results](web_programming/open_google_results.py)
+ * [Random Anime Character](web_programming/random_anime_character.py)
+ * [Recaptcha Verification](web_programming/recaptcha_verification.py)
+ * [Reddit](web_programming/reddit.py)
+ * [Search Books By Isbn](web_programming/search_books_by_isbn.py)
+ * [Slack Message](web_programming/slack_message.py)
+ * [Test Fetch Github Info](web_programming/test_fetch_github_info.py)
+ * [World Covid19 Stats](web_programming/world_covid19_stats.py)
diff --git a/LICENSE.md b/LICENSE.md
index 3b7951527ab3..de631c3ef333 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,6 +1,6 @@
-MIT License
+## MIT License
-Copyright (c) 2020 The Algorithms
+Copyright (c) 2016-2022 TheAlgorithms and contributors
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
diff --git a/README.md b/README.md
index f81031b53ebb..d8eba4e016fa 100644
--- a/README.md
+++ b/README.md
@@ -1,27 +1,49 @@
-# The Algorithms - Python
-[](https://gitpod.io/#https://github.com/TheAlgorithms/Python)
-[](https://gitter.im/TheAlgorithms)
-[](https://github.com/TheAlgorithms/Python/actions)
-[](https://lgtm.com/projects/g/TheAlgorithms/Python/alerts)
-[](https://github.com/TheAlgorithms/Python/blob/master/CONTRIBUTING.md)
-[](https://www.paypal.me/TheAlgorithms/100)
-
-[](https://github.com/pre-commit/pre-commit)
-[](https://github.com/psf/black)
-
-
-### All algorithms implemented in Python (for education)
-
-These implementations are for learning purposes only. Therefore they may be less efficient than the implementations in the Python standard library.
-
-## Contribution Guidelines
-
-Read our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
-
-## Community Channel
-
-We're on [Gitter](https://gitter.im/TheAlgorithms)! Please join us.
+
+
+
+ 
+
+
+
+
+
+ 
+
+
+ 
+
+
+
+ 
+
+
+ 
+
+
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+
All algorithms implemented in Python - for education
+
+
+This training phase is possible when data points are linear, but there again comes a question can we predict non-linear relationship between x and y ? as shown below
+
+
+
+
+So, here comes the role of non-parametric algorithm which doesn't compute predictions based on fixed set of params. Rather parameters $\theta$ are computed individually for each query point/data point x.
+
+
+While Computing $\theta$ , a higher preference is given to points in the vicinity of x than points farther from x.
+
+Cost Function J($\theta$) = $\sum_{i=1}^m$ $w^i$ (($\theta$)$^T$ $x^i$ - $y^i$)$^2$
+
+$w^i$ is non-negative weight associated to training point $x^i$. \
+$w^i$ is large fr $x^i$'s lying closer to query point $x_i$. \
+$w^i$ is small for $x^i$'s lying farther to query point $x_i$.
+
+A Typical weight can be computed using \
+
+$w^i$ = $\exp$(-$\frac{(x^i-x)(x^i-x)^T}{2\tau^2}$)
+
+Where $\tau$ is the bandwidth parameter that controls $w^i$ distance from x.
+
+Let's look at a example :
+
+Suppose, we had a query point x=5.0 and training points $x^1$=4.9 and $x^2$=5.0 than we can calculate weights as :
+
+$w^i$ = $\exp$(-$\frac{(x^i-x)(x^i-x)^T}{2\tau^2}$) with $\tau$=0.5
+
+$w^1$ = $\exp$(-$\frac{(4.9-5)^2}{2(0.5)^2}$) = 0.9802
+
+$w^2$ = $\exp$(-$\frac{(3-5)^2}{2(0.5)^2}$) = 0.000335
+
+So, J($\theta$) = 0.9802*($\theta$ $^T$ $x^1$ - $y^1$) + 0.000335*($\theta$ $^T$ $x^2$ - $y^2$)
+
+So, here by we can conclude that the weight fall exponentially as the distance between x & $x^i$ increases and So, does the contribution of error in prediction for $x^i$ to the cost.
+
+Steps involved in LWL are : \
+Compute \theta to minimize the cost.
+J($\theta$) = $\sum_{i=1}^m$ $w^i$ (($\theta$)$^T$ $x^i$ - $y^i$)$^2$ \
+Predict Output: for given query point x, \
+return : $\theta$ $^T$ x
+
+
diff --git a/machine_learning/local_weighted_learning/__init__.py b/machine_learning/local_weighted_learning/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/machine_learning/local_weighted_learning/local_weighted_learning.py b/machine_learning/local_weighted_learning/local_weighted_learning.py
new file mode 100644
index 000000000000..f3056da40e24
--- /dev/null
+++ b/machine_learning/local_weighted_learning/local_weighted_learning.py
@@ -0,0 +1,185 @@
+"""
+Locally weighted linear regression, also called local regression, is a type of
+non-parametric linear regression that prioritizes data closest to a given
+prediction point. The algorithm estimates the vector of model coefficients β
+using weighted least squares regression:
+
+β = (XᵀWX)⁻¹(XᵀWy),
+
+where X is the design matrix, y is the response vector, and W is the diagonal
+weight matrix.
+
+This implementation calculates wᵢ, the weight of the ith training sample, using
+the Gaussian weight:
+
+wᵢ = exp(-‖xᵢ - x‖²/(2τ²)),
+
+where xᵢ is the ith training sample, x is the prediction point, τ is the
+"bandwidth", and ‖x‖ is the Euclidean norm (also called the 2-norm or the L²
+norm). The bandwidth τ controls how quickly the weight of a training sample
+decreases as its distance from the prediction point increases. One can think of
+the Gaussian weight as a bell curve centered around the prediction point: a
+training sample is weighted lower if it's farther from the center, and τ
+controls the spread of the bell curve.
+
+Other types of locally weighted regression such as locally estimated scatterplot
+smoothing (LOESS) typically use different weight functions.
+
+References:
+ - https://en.wikipedia.org/wiki/Local_regression
+ - https://en.wikipedia.org/wiki/Weighted_least_squares
+ - https://cs229.stanford.edu/notes2022fall/main_notes.pdf
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def weight_matrix(point: np.ndarray, x_train: np.ndarray, tau: float) -> np.ndarray:
+ """
+ Calculate the weight of every point in the training data around a given
+ prediction point
+
+ Args:
+ point: x-value at which the prediction is being made
+ x_train: ndarray of x-values for training
+ tau: bandwidth value, controls how quickly the weight of training values
+ decreases as the distance from the prediction point increases
+
+ Returns:
+ m x m weight matrix around the prediction point, where m is the size of
+ the training set
+ >>> weight_matrix(
+ ... np.array([1., 1.]),
+ ... np.array([[16.99, 10.34], [21.01,23.68], [24.59,25.69]]),
+ ... 0.6
+ ... )
+ array([[1.43807972e-207, 0.00000000e+000, 0.00000000e+000],
+ [0.00000000e+000, 0.00000000e+000, 0.00000000e+000],
+ [0.00000000e+000, 0.00000000e+000, 0.00000000e+000]])
+ """
+ m = len(x_train) # Number of training samples
+ weights = np.eye(m) # Initialize weights as identity matrix
+ for j in range(m):
+ diff = point - x_train[j]
+ weights[j, j] = np.exp(diff @ diff.T / (-2.0 * tau**2))
+
+ return weights
+
+
+def local_weight(
+ point: np.ndarray, x_train: np.ndarray, y_train: np.ndarray, tau: float
+) -> np.ndarray:
+ """
+ Calculate the local weights at a given prediction point using the weight
+ matrix for that point
+
+ Args:
+ point: x-value at which the prediction is being made
+ x_train: ndarray of x-values for training
+ y_train: ndarray of y-values for training
+ tau: bandwidth value, controls how quickly the weight of training values
+ decreases as the distance from the prediction point increases
+ Returns:
+ ndarray of local weights
+ >>> local_weight(
+ ... np.array([1., 1.]),
+ ... np.array([[16.99, 10.34], [21.01,23.68], [24.59,25.69]]),
+ ... np.array([[1.01, 1.66, 3.5]]),
+ ... 0.6
+ ... )
+ array([[0.00873174],
+ [0.08272556]])
+ """
+ weight_mat = weight_matrix(point, x_train, tau)
+ weight = np.linalg.inv(x_train.T @ weight_mat @ x_train) @ (
+ x_train.T @ weight_mat @ y_train.T
+ )
+
+ return weight
+
+
+def local_weight_regression(
+ x_train: np.ndarray, y_train: np.ndarray, tau: float
+) -> np.ndarray:
+ """
+ Calculate predictions for each point in the training data
+
+ Args:
+ x_train: ndarray of x-values for training
+ y_train: ndarray of y-values for training
+ tau: bandwidth value, controls how quickly the weight of training values
+ decreases as the distance from the prediction point increases
+
+ Returns:
+ ndarray of predictions
+ >>> local_weight_regression(
+ ... np.array([[16.99, 10.34], [21.01, 23.68], [24.59, 25.69]]),
+ ... np.array([[1.01, 1.66, 3.5]]),
+ ... 0.6
+ ... )
+ array([1.07173261, 1.65970737, 3.50160179])
+ """
+ y_pred = np.zeros(len(x_train)) # Initialize array of predictions
+ for i, item in enumerate(x_train):
+ y_pred[i] = np.dot(item, local_weight(item, x_train, y_train, tau)).item()
+
+ return y_pred
+
+
+def load_data(
+ dataset_name: str, x_name: str, y_name: str
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+ """
+ Load data from seaborn and split it into x and y points
+ >>> pass # No doctests, function is for demo purposes only
+ """
+ import seaborn as sns
+
+ data = sns.load_dataset(dataset_name)
+ x_data = np.array(data[x_name])
+ y_data = np.array(data[y_name])
+
+ one = np.ones(len(y_data))
+
+ # pairing elements of one and x_data
+ x_train = np.column_stack((one, x_data))
+
+ return x_train, x_data, y_data
+
+
+def plot_preds(
+ x_train: np.ndarray,
+ preds: np.ndarray,
+ x_data: np.ndarray,
+ y_data: np.ndarray,
+ x_name: str,
+ y_name: str,
+) -> None:
+ """
+ Plot predictions and display the graph
+ >>> pass # No doctests, function is for demo purposes only
+ """
+ x_train_sorted = np.sort(x_train, axis=0)
+ plt.scatter(x_data, y_data, color="blue")
+ plt.plot(
+ x_train_sorted[:, 1],
+ preds[x_train[:, 1].argsort(0)],
+ color="yellow",
+ linewidth=5,
+ )
+ plt.title("Local Weighted Regression")
+ plt.xlabel(x_name)
+ plt.ylabel(y_name)
+ plt.show()
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+
+ # Demo with a dataset from the seaborn module
+ training_data_x, total_bill, tip = load_data("tips", "total_bill", "tip")
+ predictions = local_weight_regression(training_data_x, tip, 5)
+ plot_preds(training_data_x, predictions, total_bill, tip, "total_bill", "tip")
diff --git a/machine_learning/logistic_regression.py b/machine_learning/logistic_regression.py
index 48d88ef61185..496026631fbe 100644
--- a/machine_learning/logistic_regression.py
+++ b/machine_learning/logistic_regression.py
@@ -14,6 +14,7 @@
Coursera ML course
https://medium.com/@martinpella/logistic-regression-from-scratch-in-python-124c5636b8ac
"""
+
import numpy as np
from matplotlib import pyplot as plt
from sklearn import datasets
@@ -27,57 +28,128 @@
# classification problems
-def sigmoid_function(z):
+def sigmoid_function(z: float | np.ndarray) -> float | np.ndarray:
+ """
+ Also known as Logistic Function.
+
+ 1
+ f(x) = -------
+ 1 + e⁻ˣ
+
+ The sigmoid function approaches a value of 1 as its input 'x' becomes
+ increasing positive. Opposite for negative values.
+
+ Reference: https://en.wikipedia.org/wiki/Sigmoid_function
+
+ @param z: input to the function
+ @returns: returns value in the range 0 to 1
+
+ Examples:
+ >>> float(sigmoid_function(4))
+ 0.9820137900379085
+ >>> sigmoid_function(np.array([-3, 3]))
+ array([0.04742587, 0.95257413])
+ >>> sigmoid_function(np.array([-3, 3, 1]))
+ array([0.04742587, 0.95257413, 0.73105858])
+ >>> sigmoid_function(np.array([-0.01, -2, -1.9]))
+ array([0.49750002, 0.11920292, 0.13010847])
+ >>> sigmoid_function(np.array([-1.3, 5.3, 12]))
+ array([0.21416502, 0.9950332 , 0.99999386])
+ >>> sigmoid_function(np.array([0.01, 0.02, 4.1]))
+ array([0.50249998, 0.50499983, 0.9836975 ])
+ >>> sigmoid_function(np.array([0.8]))
+ array([0.68997448])
+ """
return 1 / (1 + np.exp(-z))
-def cost_function(h, y):
- return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()
+def cost_function(h: np.ndarray, y: np.ndarray) -> float:
+ """
+ Cost function quantifies the error between predicted and expected values.
+ The cost function used in Logistic Regression is called Log Loss
+ or Cross Entropy Function.
+
+ J(θ) = (1/m) * Σ [ -y * log(hθ(x)) - (1 - y) * log(1 - hθ(x)) ]
+
+ Where:
+ - J(θ) is the cost that we want to minimize during training
+ - m is the number of training examples
+ - Σ represents the summation over all training examples
+ - y is the actual binary label (0 or 1) for a given example
+ - hθ(x) is the predicted probability that x belongs to the positive class
+
+ @param h: the output of sigmoid function. It is the estimated probability
+ that the input example 'x' belongs to the positive class
+
+ @param y: the actual binary label associated with input example 'x'
+ Examples:
+ >>> estimations = sigmoid_function(np.array([0.3, -4.3, 8.1]))
+ >>> cost_function(h=estimations,y=np.array([1, 0, 1]))
+ 0.18937868932131605
+ >>> estimations = sigmoid_function(np.array([4, 3, 1]))
+ >>> cost_function(h=estimations,y=np.array([1, 0, 0]))
+ 1.459999655669926
+ >>> estimations = sigmoid_function(np.array([4, -3, -1]))
+ >>> cost_function(h=estimations,y=np.array([1,0,0]))
+ 0.1266663223365915
+ >>> estimations = sigmoid_function(0)
+ >>> cost_function(h=estimations,y=np.array([1]))
+ 0.6931471805599453
-def log_likelihood(X, Y, weights):
- scores = np.dot(X, weights)
- return np.sum(Y * scores - np.log(1 + np.exp(scores)))
+ References:
+ - https://en.wikipedia.org/wiki/Logistic_regression
+ """
+ return float((-y * np.log(h) - (1 - y) * np.log(1 - h)).mean())
+
+
+def log_likelihood(x, y, weights):
+ scores = np.dot(x, weights)
+ return np.sum(y * scores - np.log(1 + np.exp(scores)))
# here alpha is the learning rate, X is the feature matrix,y is the target matrix
-def logistic_reg(alpha, X, y, max_iterations=70000):
- theta = np.zeros(X.shape[1])
+def logistic_reg(alpha, x, y, max_iterations=70000):
+ theta = np.zeros(x.shape[1])
for iterations in range(max_iterations):
- z = np.dot(X, theta)
+ z = np.dot(x, theta)
h = sigmoid_function(z)
- gradient = np.dot(X.T, h - y) / y.size
+ gradient = np.dot(x.T, h - y) / y.size
theta = theta - alpha * gradient # updating the weights
- z = np.dot(X, theta)
+ z = np.dot(x, theta)
h = sigmoid_function(z)
- J = cost_function(h, y)
+ j = cost_function(h, y)
if iterations % 100 == 0:
- print(f"loss: {J} \t") # printing the loss after every 100 iterations
+ print(f"loss: {j} \t") # printing the loss after every 100 iterations
return theta
# In[68]:
if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+
iris = datasets.load_iris()
- X = iris.data[:, :2]
+ x = iris.data[:, :2]
y = (iris.target != 0) * 1
alpha = 0.1
- theta = logistic_reg(alpha, X, y, max_iterations=70000)
+ theta = logistic_reg(alpha, x, y, max_iterations=70000)
print("theta: ", theta) # printing the theta i.e our weights vector
- def predict_prob(X):
+ def predict_prob(x):
return sigmoid_function(
- np.dot(X, theta)
+ np.dot(x, theta)
) # predicting the value of probability from the logistic regression algorithm
plt.figure(figsize=(10, 6))
- plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color="b", label="0")
- plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color="r", label="1")
- (x1_min, x1_max) = (X[:, 0].min(), X[:, 0].max())
- (x2_min, x2_max) = (X[:, 1].min(), X[:, 1].max())
+ plt.scatter(x[y == 0][:, 0], x[y == 0][:, 1], color="b", label="0")
+ plt.scatter(x[y == 1][:, 0], x[y == 1][:, 1], color="r", label="1")
+ (x1_min, x1_max) = (x[:, 0].min(), x[:, 0].max())
+ (x2_min, x2_max) = (x[:, 1].min(), x[:, 1].max())
(xx1, xx2) = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))
grid = np.c_[xx1.ravel(), xx2.ravel()]
probs = predict_prob(grid).reshape(xx1.shape)
diff --git a/machine_learning/loss_functions.py b/machine_learning/loss_functions.py
new file mode 100644
index 000000000000..0bd9aa8b5401
--- /dev/null
+++ b/machine_learning/loss_functions.py
@@ -0,0 +1,669 @@
+import numpy as np
+
+
+def binary_cross_entropy(
+ y_true: np.ndarray, y_pred: np.ndarray, epsilon: float = 1e-15
+) -> float:
+ """
+ Calculate the mean binary cross-entropy (BCE) loss between true labels and predicted
+ probabilities.
+
+ BCE loss quantifies dissimilarity between true labels (0 or 1) and predicted
+ probabilities. It's widely used in binary classification tasks.
+
+ BCE = -Σ(y_true * ln(y_pred) + (1 - y_true) * ln(1 - y_pred))
+
+ Reference: https://en.wikipedia.org/wiki/Cross_entropy
+
+ Parameters:
+ - y_true: True binary labels (0 or 1)
+ - y_pred: Predicted probabilities for class 1
+ - epsilon: Small constant to avoid numerical instability
+
+ >>> true_labels = np.array([0, 1, 1, 0, 1])
+ >>> predicted_probs = np.array([0.2, 0.7, 0.9, 0.3, 0.8])
+ >>> float(binary_cross_entropy(true_labels, predicted_probs))
+ 0.2529995012327421
+ >>> true_labels = np.array([0, 1, 1, 0, 1])
+ >>> predicted_probs = np.array([0.3, 0.8, 0.9, 0.2])
+ >>> binary_cross_entropy(true_labels, predicted_probs)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input arrays must have the same length.
+ """
+ if len(y_true) != len(y_pred):
+ raise ValueError("Input arrays must have the same length.")
+
+ y_pred = np.clip(y_pred, epsilon, 1 - epsilon) # Clip predictions to avoid log(0)
+ bce_loss = -(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))
+ return np.mean(bce_loss)
+
+
+def binary_focal_cross_entropy(
+ y_true: np.ndarray,
+ y_pred: np.ndarray,
+ gamma: float = 2.0,
+ alpha: float = 0.25,
+ epsilon: float = 1e-15,
+) -> float:
+ """
+ Calculate the mean binary focal cross-entropy (BFCE) loss between true labels
+ and predicted probabilities.
+
+ BFCE loss quantifies dissimilarity between true labels (0 or 1) and predicted
+ probabilities. It's a variation of binary cross-entropy that addresses class
+ imbalance by focusing on hard examples.
+
+ BCFE = -Σ(alpha * (1 - y_pred)**gamma * y_true * log(y_pred)
+ + (1 - alpha) * y_pred**gamma * (1 - y_true) * log(1 - y_pred))
+
+ Reference: [Lin et al., 2018](https://arxiv.org/pdf/1708.02002.pdf)
+
+ Parameters:
+ - y_true: True binary labels (0 or 1).
+ - y_pred: Predicted probabilities for class 1.
+ - gamma: Focusing parameter for modulating the loss (default: 2.0).
+ - alpha: Weighting factor for class 1 (default: 0.25).
+ - epsilon: Small constant to avoid numerical instability.
+
+ >>> true_labels = np.array([0, 1, 1, 0, 1])
+ >>> predicted_probs = np.array([0.2, 0.7, 0.9, 0.3, 0.8])
+ >>> float(binary_focal_cross_entropy(true_labels, predicted_probs))
+ 0.008257977659239775
+ >>> true_labels = np.array([0, 1, 1, 0, 1])
+ >>> predicted_probs = np.array([0.3, 0.8, 0.9, 0.2])
+ >>> binary_focal_cross_entropy(true_labels, predicted_probs)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input arrays must have the same length.
+ """
+ if len(y_true) != len(y_pred):
+ raise ValueError("Input arrays must have the same length.")
+ # Clip predicted probabilities to avoid log(0)
+ y_pred = np.clip(y_pred, epsilon, 1 - epsilon)
+
+ bcfe_loss = -(
+ alpha * (1 - y_pred) ** gamma * y_true * np.log(y_pred)
+ + (1 - alpha) * y_pred**gamma * (1 - y_true) * np.log(1 - y_pred)
+ )
+
+ return np.mean(bcfe_loss)
+
+
+def categorical_cross_entropy(
+ y_true: np.ndarray, y_pred: np.ndarray, epsilon: float = 1e-15
+) -> float:
+ """
+ Calculate categorical cross-entropy (CCE) loss between true class labels and
+ predicted class probabilities.
+
+ CCE = -Σ(y_true * ln(y_pred))
+
+ Reference: https://en.wikipedia.org/wiki/Cross_entropy
+
+ Parameters:
+ - y_true: True class labels (one-hot encoded)
+ - y_pred: Predicted class probabilities
+ - epsilon: Small constant to avoid numerical instability
+
+ >>> true_labels = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+ >>> pred_probs = np.array([[0.9, 0.1, 0.0], [0.2, 0.7, 0.1], [0.0, 0.1, 0.9]])
+ >>> float(categorical_cross_entropy(true_labels, pred_probs))
+ 0.567395975254385
+ >>> true_labels = np.array([[1, 0], [0, 1]])
+ >>> pred_probs = np.array([[0.9, 0.1, 0.0], [0.2, 0.7, 0.1]])
+ >>> categorical_cross_entropy(true_labels, pred_probs)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input arrays must have the same shape.
+ >>> true_labels = np.array([[2, 0, 1], [1, 0, 0]])
+ >>> pred_probs = np.array([[0.9, 0.1, 0.0], [0.2, 0.7, 0.1]])
+ >>> categorical_cross_entropy(true_labels, pred_probs)
+ Traceback (most recent call last):
+ ...
+ ValueError: y_true must be one-hot encoded.
+ >>> true_labels = np.array([[1, 0, 1], [1, 0, 0]])
+ >>> pred_probs = np.array([[0.9, 0.1, 0.0], [0.2, 0.7, 0.1]])
+ >>> categorical_cross_entropy(true_labels, pred_probs)
+ Traceback (most recent call last):
+ ...
+ ValueError: y_true must be one-hot encoded.
+ >>> true_labels = np.array([[1, 0, 0], [0, 1, 0]])
+ >>> pred_probs = np.array([[0.9, 0.1, 0.1], [0.2, 0.7, 0.1]])
+ >>> categorical_cross_entropy(true_labels, pred_probs)
+ Traceback (most recent call last):
+ ...
+ ValueError: Predicted probabilities must sum to approximately 1.
+ """
+ if y_true.shape != y_pred.shape:
+ raise ValueError("Input arrays must have the same shape.")
+
+ if np.any((y_true != 0) & (y_true != 1)) or np.any(y_true.sum(axis=1) != 1):
+ raise ValueError("y_true must be one-hot encoded.")
+
+ if not np.all(np.isclose(np.sum(y_pred, axis=1), 1, rtol=epsilon, atol=epsilon)):
+ raise ValueError("Predicted probabilities must sum to approximately 1.")
+
+ y_pred = np.clip(y_pred, epsilon, 1) # Clip predictions to avoid log(0)
+ return -np.sum(y_true * np.log(y_pred))
+
+
+def categorical_focal_cross_entropy(
+ y_true: np.ndarray,
+ y_pred: np.ndarray,
+ alpha: np.ndarray = None,
+ gamma: float = 2.0,
+ epsilon: float = 1e-15,
+) -> float:
+ """
+ Calculate the mean categorical focal cross-entropy (CFCE) loss between true
+ labels and predicted probabilities for multi-class classification.
+
+ CFCE loss is a generalization of binary focal cross-entropy for multi-class
+ classification. It addresses class imbalance by focusing on hard examples.
+
+ CFCE = -Σ alpha * (1 - y_pred)**gamma * y_true * log(y_pred)
+
+ Reference: [Lin et al., 2018](https://arxiv.org/pdf/1708.02002.pdf)
+
+ Parameters:
+ - y_true: True labels in one-hot encoded form.
+ - y_pred: Predicted probabilities for each class.
+ - alpha: Array of weighting factors for each class.
+ - gamma: Focusing parameter for modulating the loss (default: 2.0).
+ - epsilon: Small constant to avoid numerical instability.
+
+ Returns:
+ - The mean categorical focal cross-entropy loss.
+
+ >>> true_labels = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+ >>> pred_probs = np.array([[0.9, 0.1, 0.0], [0.2, 0.7, 0.1], [0.0, 0.1, 0.9]])
+ >>> alpha = np.array([0.6, 0.2, 0.7])
+ >>> float(categorical_focal_cross_entropy(true_labels, pred_probs, alpha))
+ 0.0025966118981496423
+
+ >>> true_labels = np.array([[0, 1, 0], [0, 0, 1]])
+ >>> pred_probs = np.array([[0.05, 0.95, 0], [0.1, 0.8, 0.1]])
+ >>> alpha = np.array([0.25, 0.25, 0.25])
+ >>> float(categorical_focal_cross_entropy(true_labels, pred_probs, alpha))
+ 0.23315276982014324
+
+ >>> true_labels = np.array([[1, 0], [0, 1]])
+ >>> pred_probs = np.array([[0.9, 0.1, 0.0], [0.2, 0.7, 0.1]])
+ >>> categorical_cross_entropy(true_labels, pred_probs)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input arrays must have the same shape.
+
+ >>> true_labels = np.array([[2, 0, 1], [1, 0, 0]])
+ >>> pred_probs = np.array([[0.9, 0.1, 0.0], [0.2, 0.7, 0.1]])
+ >>> categorical_focal_cross_entropy(true_labels, pred_probs)
+ Traceback (most recent call last):
+ ...
+ ValueError: y_true must be one-hot encoded.
+
+ >>> true_labels = np.array([[1, 0, 1], [1, 0, 0]])
+ >>> pred_probs = np.array([[0.9, 0.1, 0.0], [0.2, 0.7, 0.1]])
+ >>> categorical_focal_cross_entropy(true_labels, pred_probs)
+ Traceback (most recent call last):
+ ...
+ ValueError: y_true must be one-hot encoded.
+
+ >>> true_labels = np.array([[1, 0, 0], [0, 1, 0]])
+ >>> pred_probs = np.array([[0.9, 0.1, 0.1], [0.2, 0.7, 0.1]])
+ >>> categorical_focal_cross_entropy(true_labels, pred_probs)
+ Traceback (most recent call last):
+ ...
+ ValueError: Predicted probabilities must sum to approximately 1.
+
+ >>> true_labels = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+ >>> pred_probs = np.array([[0.9, 0.1, 0.0], [0.2, 0.7, 0.1], [0.0, 0.1, 0.9]])
+ >>> alpha = np.array([0.6, 0.2])
+ >>> categorical_focal_cross_entropy(true_labels, pred_probs, alpha)
+ Traceback (most recent call last):
+ ...
+ ValueError: Length of alpha must match the number of classes.
+ """
+ if y_true.shape != y_pred.shape:
+ raise ValueError("Shape of y_true and y_pred must be the same.")
+
+ if alpha is None:
+ alpha = np.ones(y_true.shape[1])
+
+ if np.any((y_true != 0) & (y_true != 1)) or np.any(y_true.sum(axis=1) != 1):
+ raise ValueError("y_true must be one-hot encoded.")
+
+ if len(alpha) != y_true.shape[1]:
+ raise ValueError("Length of alpha must match the number of classes.")
+
+ if not np.all(np.isclose(np.sum(y_pred, axis=1), 1, rtol=epsilon, atol=epsilon)):
+ raise ValueError("Predicted probabilities must sum to approximately 1.")
+
+ # Clip predicted probabilities to avoid log(0)
+ y_pred = np.clip(y_pred, epsilon, 1 - epsilon)
+
+ # Calculate loss for each class and sum across classes
+ cfce_loss = -np.sum(
+ alpha * np.power(1 - y_pred, gamma) * y_true * np.log(y_pred), axis=1
+ )
+
+ return np.mean(cfce_loss)
+
+
+def hinge_loss(y_true: np.ndarray, y_pred: np.ndarray) -> float:
+ """
+ Calculate the mean hinge loss for between true labels and predicted probabilities
+ for training support vector machines (SVMs).
+
+ Hinge loss = max(0, 1 - true * pred)
+
+ Reference: https://en.wikipedia.org/wiki/Hinge_loss
+
+ Args:
+ - y_true: actual values (ground truth) encoded as -1 or 1
+ - y_pred: predicted values
+
+ >>> true_labels = np.array([-1, 1, 1, -1, 1])
+ >>> pred = np.array([-4, -0.3, 0.7, 5, 10])
+ >>> float(hinge_loss(true_labels, pred))
+ 1.52
+ >>> true_labels = np.array([-1, 1, 1, -1, 1, 1])
+ >>> pred = np.array([-4, -0.3, 0.7, 5, 10])
+ >>> hinge_loss(true_labels, pred)
+ Traceback (most recent call last):
+ ...
+ ValueError: Length of predicted and actual array must be same.
+ >>> true_labels = np.array([-1, 1, 10, -1, 1])
+ >>> pred = np.array([-4, -0.3, 0.7, 5, 10])
+ >>> hinge_loss(true_labels, pred)
+ Traceback (most recent call last):
+ ...
+ ValueError: y_true can have values -1 or 1 only.
+ """
+ if len(y_true) != len(y_pred):
+ raise ValueError("Length of predicted and actual array must be same.")
+
+ if np.any((y_true != -1) & (y_true != 1)):
+ raise ValueError("y_true can have values -1 or 1 only.")
+
+ hinge_losses = np.maximum(0, 1.0 - (y_true * y_pred))
+ return np.mean(hinge_losses)
+
+
+def huber_loss(y_true: np.ndarray, y_pred: np.ndarray, delta: float) -> float:
+ """
+ Calculate the mean Huber loss between the given ground truth and predicted values.
+
+ The Huber loss describes the penalty incurred by an estimation procedure, and it
+ serves as a measure of accuracy for regression models.
+
+ Huber loss =
+ 0.5 * (y_true - y_pred)^2 if |y_true - y_pred| <= delta
+ delta * |y_true - y_pred| - 0.5 * delta^2 otherwise
+
+ Reference: https://en.wikipedia.org/wiki/Huber_loss
+
+ Parameters:
+ - y_true: The true values (ground truth)
+ - y_pred: The predicted values
+
+ >>> true_values = np.array([0.9, 10.0, 2.0, 1.0, 5.2])
+ >>> predicted_values = np.array([0.8, 2.1, 2.9, 4.2, 5.2])
+ >>> bool(np.isclose(huber_loss(true_values, predicted_values, 1.0), 2.102))
+ True
+ >>> true_labels = np.array([11.0, 21.0, 3.32, 4.0, 5.0])
+ >>> predicted_probs = np.array([8.3, 20.8, 2.9, 11.2, 5.0])
+ >>> bool(np.isclose(huber_loss(true_labels, predicted_probs, 1.0), 1.80164))
+ True
+ >>> true_labels = np.array([11.0, 21.0, 3.32, 4.0])
+ >>> predicted_probs = np.array([8.3, 20.8, 2.9, 11.2, 5.0])
+ >>> huber_loss(true_labels, predicted_probs, 1.0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input arrays must have the same length.
+ """
+ if len(y_true) != len(y_pred):
+ raise ValueError("Input arrays must have the same length.")
+
+ huber_mse = 0.5 * (y_true - y_pred) ** 2
+ huber_mae = delta * (np.abs(y_true - y_pred) - 0.5 * delta)
+ return np.where(np.abs(y_true - y_pred) <= delta, huber_mse, huber_mae).mean()
+
+
+def mean_squared_error(y_true: np.ndarray, y_pred: np.ndarray) -> float:
+ """
+ Calculate the mean squared error (MSE) between ground truth and predicted values.
+
+ MSE measures the squared difference between true values and predicted values, and it
+ serves as a measure of accuracy for regression models.
+
+ MSE = (1/n) * Σ(y_true - y_pred)^2
+
+ Reference: https://en.wikipedia.org/wiki/Mean_squared_error
+
+ Parameters:
+ - y_true: The true values (ground truth)
+ - y_pred: The predicted values
+
+ >>> true_values = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+ >>> predicted_values = np.array([0.8, 2.1, 2.9, 4.2, 5.2])
+ >>> bool(np.isclose(mean_squared_error(true_values, predicted_values), 0.028))
+ True
+ >>> true_labels = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+ >>> predicted_probs = np.array([0.3, 0.8, 0.9, 0.2])
+ >>> mean_squared_error(true_labels, predicted_probs)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input arrays must have the same length.
+ """
+ if len(y_true) != len(y_pred):
+ raise ValueError("Input arrays must have the same length.")
+
+ squared_errors = (y_true - y_pred) ** 2
+ return np.mean(squared_errors)
+
+
+def mean_absolute_error(y_true: np.ndarray, y_pred: np.ndarray) -> float:
+ """
+ Calculates the Mean Absolute Error (MAE) between ground truth (observed)
+ and predicted values.
+
+ MAE measures the absolute difference between true values and predicted values.
+
+ Equation:
+ MAE = (1/n) * Σ(abs(y_true - y_pred))
+
+ Reference: https://en.wikipedia.org/wiki/Mean_absolute_error
+
+ Parameters:
+ - y_true: The true values (ground truth)
+ - y_pred: The predicted values
+
+ >>> true_values = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+ >>> predicted_values = np.array([0.8, 2.1, 2.9, 4.2, 5.2])
+ >>> bool(np.isclose(mean_absolute_error(true_values, predicted_values), 0.16))
+ True
+ >>> true_values = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+ >>> predicted_values = np.array([0.8, 2.1, 2.9, 4.2, 5.2])
+ >>> bool(np.isclose(mean_absolute_error(true_values, predicted_values), 2.16))
+ False
+ >>> true_labels = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+ >>> predicted_probs = np.array([0.3, 0.8, 0.9, 5.2])
+ >>> mean_absolute_error(true_labels, predicted_probs)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input arrays must have the same length.
+ """
+ if len(y_true) != len(y_pred):
+ raise ValueError("Input arrays must have the same length.")
+
+ return np.mean(abs(y_true - y_pred))
+
+
+def mean_squared_logarithmic_error(y_true: np.ndarray, y_pred: np.ndarray) -> float:
+ """
+ Calculate the mean squared logarithmic error (MSLE) between ground truth and
+ predicted values.
+
+ MSLE measures the squared logarithmic difference between true values and predicted
+ values for regression models. It's particularly useful for dealing with skewed or
+ large-value data, and it's often used when the relative differences between
+ predicted and true values are more important than absolute differences.
+
+ MSLE = (1/n) * Σ(log(1 + y_true) - log(1 + y_pred))^2
+
+ Reference: https://insideaiml.com/blog/MeanSquared-Logarithmic-Error-Loss-1035
+
+ Parameters:
+ - y_true: The true values (ground truth)
+ - y_pred: The predicted values
+
+ >>> true_values = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+ >>> predicted_values = np.array([0.8, 2.1, 2.9, 4.2, 5.2])
+ >>> float(mean_squared_logarithmic_error(true_values, predicted_values))
+ 0.0030860877925181344
+ >>> true_labels = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+ >>> predicted_probs = np.array([0.3, 0.8, 0.9, 0.2])
+ >>> mean_squared_logarithmic_error(true_labels, predicted_probs)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input arrays must have the same length.
+ """
+ if len(y_true) != len(y_pred):
+ raise ValueError("Input arrays must have the same length.")
+
+ squared_logarithmic_errors = (np.log1p(y_true) - np.log1p(y_pred)) ** 2
+ return np.mean(squared_logarithmic_errors)
+
+
+def mean_absolute_percentage_error(
+ y_true: np.ndarray, y_pred: np.ndarray, epsilon: float = 1e-15
+) -> float:
+ """
+ Calculate the Mean Absolute Percentage Error between y_true and y_pred.
+
+ Mean Absolute Percentage Error calculates the average of the absolute
+ percentage differences between the predicted and true values.
+
+ Formula = (Σ|y_true[i]-Y_pred[i]/y_true[i]|)/n
+
+ Source: https://stephenallwright.com/good-mape-score/
+
+ Parameters:
+ y_true (np.ndarray): Numpy array containing true/target values.
+ y_pred (np.ndarray): Numpy array containing predicted values.
+
+ Returns:
+ float: The Mean Absolute Percentage error between y_true and y_pred.
+
+ Examples:
+ >>> y_true = np.array([10, 20, 30, 40])
+ >>> y_pred = np.array([12, 18, 33, 45])
+ >>> float(mean_absolute_percentage_error(y_true, y_pred))
+ 0.13125
+
+ >>> y_true = np.array([1, 2, 3, 4])
+ >>> y_pred = np.array([2, 3, 4, 5])
+ >>> float(mean_absolute_percentage_error(y_true, y_pred))
+ 0.5208333333333333
+
+ >>> y_true = np.array([34, 37, 44, 47, 48, 48, 46, 43, 32, 27, 26, 24])
+ >>> y_pred = np.array([37, 40, 46, 44, 46, 50, 45, 44, 34, 30, 22, 23])
+ >>> float(mean_absolute_percentage_error(y_true, y_pred))
+ 0.064671076436071
+ """
+ if len(y_true) != len(y_pred):
+ raise ValueError("The length of the two arrays should be the same.")
+
+ y_true = np.where(y_true == 0, epsilon, y_true)
+ absolute_percentage_diff = np.abs((y_true - y_pred) / y_true)
+
+ return np.mean(absolute_percentage_diff)
+
+
+def perplexity_loss(
+ y_true: np.ndarray, y_pred: np.ndarray, epsilon: float = 1e-7
+) -> float:
+ """
+ Calculate the perplexity for the y_true and y_pred.
+
+ Compute the Perplexity which useful in predicting language model
+ accuracy in Natural Language Processing (NLP.)
+ Perplexity is measure of how certain the model in its predictions.
+
+ Perplexity Loss = exp(-1/N (Σ ln(p(x)))
+
+ Reference:
+ https://en.wikipedia.org/wiki/Perplexity
+
+ Args:
+ y_true: Actual label encoded sentences of shape (batch_size, sentence_length)
+ y_pred: Predicted sentences of shape (batch_size, sentence_length, vocab_size)
+ epsilon: Small floating point number to avoid getting inf for log(0)
+
+ Returns:
+ Perplexity loss between y_true and y_pred.
+
+ >>> y_true = np.array([[1, 4], [2, 3]])
+ >>> y_pred = np.array(
+ ... [[[0.28, 0.19, 0.21 , 0.15, 0.15],
+ ... [0.24, 0.19, 0.09, 0.18, 0.27]],
+ ... [[0.03, 0.26, 0.21, 0.18, 0.30],
+ ... [0.28, 0.10, 0.33, 0.15, 0.12]]]
+ ... )
+ >>> float(perplexity_loss(y_true, y_pred))
+ 5.0247347775367945
+ >>> y_true = np.array([[1, 4], [2, 3]])
+ >>> y_pred = np.array(
+ ... [[[0.28, 0.19, 0.21 , 0.15, 0.15],
+ ... [0.24, 0.19, 0.09, 0.18, 0.27],
+ ... [0.30, 0.10, 0.20, 0.15, 0.25]],
+ ... [[0.03, 0.26, 0.21, 0.18, 0.30],
+ ... [0.28, 0.10, 0.33, 0.15, 0.12],
+ ... [0.30, 0.10, 0.20, 0.15, 0.25]],]
+ ... )
+ >>> perplexity_loss(y_true, y_pred)
+ Traceback (most recent call last):
+ ...
+ ValueError: Sentence length of y_true and y_pred must be equal.
+ >>> y_true = np.array([[1, 4], [2, 11]])
+ >>> y_pred = np.array(
+ ... [[[0.28, 0.19, 0.21 , 0.15, 0.15],
+ ... [0.24, 0.19, 0.09, 0.18, 0.27]],
+ ... [[0.03, 0.26, 0.21, 0.18, 0.30],
+ ... [0.28, 0.10, 0.33, 0.15, 0.12]]]
+ ... )
+ >>> perplexity_loss(y_true, y_pred)
+ Traceback (most recent call last):
+ ...
+ ValueError: Label value must not be greater than vocabulary size.
+ >>> y_true = np.array([[1, 4]])
+ >>> y_pred = np.array(
+ ... [[[0.28, 0.19, 0.21 , 0.15, 0.15],
+ ... [0.24, 0.19, 0.09, 0.18, 0.27]],
+ ... [[0.03, 0.26, 0.21, 0.18, 0.30],
+ ... [0.28, 0.10, 0.33, 0.15, 0.12]]]
+ ... )
+ >>> perplexity_loss(y_true, y_pred)
+ Traceback (most recent call last):
+ ...
+ ValueError: Batch size of y_true and y_pred must be equal.
+ """
+
+ vocab_size = y_pred.shape[2]
+
+ if y_true.shape[0] != y_pred.shape[0]:
+ raise ValueError("Batch size of y_true and y_pred must be equal.")
+ if y_true.shape[1] != y_pred.shape[1]:
+ raise ValueError("Sentence length of y_true and y_pred must be equal.")
+ if np.max(y_true) > vocab_size:
+ raise ValueError("Label value must not be greater than vocabulary size.")
+
+ # Matrix to select prediction value only for true class
+ filter_matrix = np.array(
+ [[list(np.eye(vocab_size)[word]) for word in sentence] for sentence in y_true]
+ )
+
+ # Getting the matrix containing prediction for only true class
+ true_class_pred = np.sum(y_pred * filter_matrix, axis=2).clip(epsilon, 1)
+
+ # Calculating perplexity for each sentence
+ perp_losses = np.exp(np.negative(np.mean(np.log(true_class_pred), axis=1)))
+
+ return np.mean(perp_losses)
+
+
+def smooth_l1_loss(y_true: np.ndarray, y_pred: np.ndarray, beta: float = 1.0) -> float:
+ """
+ Calculate the Smooth L1 Loss between y_true and y_pred.
+
+ The Smooth L1 Loss is less sensitive to outliers than the L2 Loss and is often used
+ in regression problems, such as object detection.
+
+ Smooth L1 Loss =
+ 0.5 * (x - y)^2 / beta, if |x - y| < beta
+ |x - y| - 0.5 * beta, otherwise
+
+ Reference:
+ https://pytorch.org/docs/stable/generated/torch.nn.SmoothL1Loss.html
+
+ Args:
+ y_true: Array of true values.
+ y_pred: Array of predicted values.
+ beta: Specifies the threshold at which to change between L1 and L2 loss.
+
+ Returns:
+ The calculated Smooth L1 Loss between y_true and y_pred.
+
+ Raises:
+ ValueError: If the length of the two arrays is not the same.
+
+ >>> y_true = np.array([3, 5, 2, 7])
+ >>> y_pred = np.array([2.9, 4.8, 2.1, 7.2])
+ >>> float(smooth_l1_loss(y_true, y_pred, 1.0))
+ 0.012500000000000022
+
+ >>> y_true = np.array([2, 4, 6])
+ >>> y_pred = np.array([1, 5, 7])
+ >>> float(smooth_l1_loss(y_true, y_pred, 1.0))
+ 0.5
+
+ >>> y_true = np.array([1, 3, 5, 7])
+ >>> y_pred = np.array([1, 3, 5, 7])
+ >>> float(smooth_l1_loss(y_true, y_pred, 1.0))
+ 0.0
+
+ >>> y_true = np.array([1, 3, 5])
+ >>> y_pred = np.array([1, 3, 5, 7])
+ >>> smooth_l1_loss(y_true, y_pred, 1.0)
+ Traceback (most recent call last):
+ ...
+ ValueError: The length of the two arrays should be the same.
+ """
+
+ if len(y_true) != len(y_pred):
+ raise ValueError("The length of the two arrays should be the same.")
+
+ diff = np.abs(y_true - y_pred)
+ loss = np.where(diff < beta, 0.5 * diff**2 / beta, diff - 0.5 * beta)
+ return np.mean(loss)
+
+
+def kullback_leibler_divergence(y_true: np.ndarray, y_pred: np.ndarray) -> float:
+ """
+ Calculate the Kullback-Leibler divergence (KL divergence) loss between true labels
+ and predicted probabilities.
+
+ KL divergence loss quantifies dissimilarity between true labels and predicted
+ probabilities. It's often used in training generative models.
+
+ KL = Σ(y_true * ln(y_true / y_pred))
+
+ Reference: https://en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence
+
+ Parameters:
+ - y_true: True class probabilities
+ - y_pred: Predicted class probabilities
+
+ >>> true_labels = np.array([0.2, 0.3, 0.5])
+ >>> predicted_probs = np.array([0.3, 0.3, 0.4])
+ >>> float(kullback_leibler_divergence(true_labels, predicted_probs))
+ 0.030478754035472025
+ >>> true_labels = np.array([0.2, 0.3, 0.5])
+ >>> predicted_probs = np.array([0.3, 0.3, 0.4, 0.5])
+ >>> kullback_leibler_divergence(true_labels, predicted_probs)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input arrays must have the same length.
+ """
+ if len(y_true) != len(y_pred):
+ raise ValueError("Input arrays must have the same length.")
+
+ kl_loss = y_true * np.log(y_true / y_pred)
+ return np.sum(kl_loss)
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/machine_learning/lstm/lstm_prediction.py b/machine_learning/lstm/lstm_prediction.py
index 5452f0443f62..81ac5f01d3d6 100644
--- a/machine_learning/lstm/lstm_prediction.py
+++ b/machine_learning/lstm/lstm_prediction.py
@@ -1,9 +1,10 @@
"""
- Create a Long Short Term Memory (LSTM) network model
- An LSTM is a type of Recurrent Neural Network (RNN) as discussed at:
- * http://colah.github.io/posts/2015-08-Understanding-LSTMs
- * https://en.wikipedia.org/wiki/Long_short-term_memory
+Create a Long Short Term Memory (LSTM) network model
+An LSTM is a type of Recurrent Neural Network (RNN) as discussed at:
+* https://colah.github.io/posts/2015-08-Understanding-LSTMs
+* https://en.wikipedia.org/wiki/Long_short-term_memory
"""
+
import numpy as np
import pandas as pd
from keras.layers import LSTM, Dense
@@ -17,11 +18,11 @@
make sure you set the price column on line number 21. Here we
use a dataset which have the price on 3rd column.
"""
- df = pd.read_csv("sample_data.csv", header=None)
- len_data = df.shape[:1][0]
+ sample_data = pd.read_csv("sample_data.csv", header=None)
+ len_data = sample_data.shape[:1][0]
# If you're using some other dataset input the target column
- actual_data = df.iloc[:, 1:2]
- actual_data = actual_data.values.reshape(len_data, 1)
+ actual_data = sample_data.iloc[:, 1:2]
+ actual_data = actual_data.to_numpy().reshape(len_data, 1)
actual_data = MinMaxScaler().fit_transform(actual_data)
look_back = 10
forward_days = 5
@@ -32,10 +33,10 @@
train_x, train_y = [], []
test_x, test_y = [], []
- for i in range(0, len(train_data) - forward_days - look_back + 1):
+ for i in range(len(train_data) - forward_days - look_back + 1):
train_x.append(train_data[i : i + look_back])
train_y.append(train_data[i + look_back : i + look_back + forward_days])
- for i in range(0, len(test_data) - forward_days - look_back + 1):
+ for i in range(len(test_data) - forward_days - look_back + 1):
test_x.append(test_data[i : i + look_back])
test_y.append(test_data[i + look_back : i + look_back + forward_days])
x_train = np.array(train_x)
diff --git a/machine_learning/mfcc.py b/machine_learning/mfcc.py
new file mode 100644
index 000000000000..dcc3151d5a1a
--- /dev/null
+++ b/machine_learning/mfcc.py
@@ -0,0 +1,479 @@
+"""
+Mel Frequency Cepstral Coefficients (MFCC) Calculation
+
+MFCC is an algorithm widely used in audio and speech processing to represent the
+short-term power spectrum of a sound signal in a more compact and
+discriminative way. It is particularly popular in speech and audio processing
+tasks such as speech recognition and speaker identification.
+
+How Mel Frequency Cepstral Coefficients are Calculated:
+1. Preprocessing:
+ - Load an audio signal and normalize it to ensure that the values fall
+ within a specific range (e.g., between -1 and 1).
+ - Frame the audio signal into overlapping, fixed-length segments, typically
+ using a technique like windowing to reduce spectral leakage.
+
+2. Fourier Transform:
+ - Apply a Fast Fourier Transform (FFT) to each audio frame to convert it
+ from the time domain to the frequency domain. This results in a
+ representation of the audio frame as a sequence of frequency components.
+
+3. Power Spectrum:
+ - Calculate the power spectrum by taking the squared magnitude of each
+ frequency component obtained from the FFT. This step measures the energy
+ distribution across different frequency bands.
+
+4. Mel Filterbank:
+ - Apply a set of triangular filterbanks spaced in the Mel frequency scale
+ to the power spectrum. These filters mimic the human auditory system's
+ frequency response. Each filterbank sums the power spectrum values within
+ its band.
+
+5. Logarithmic Compression:
+ - Take the logarithm (typically base 10) of the filterbank values to
+ compress the dynamic range. This step mimics the logarithmic response of
+ the human ear to sound intensity.
+
+6. Discrete Cosine Transform (DCT):
+ - Apply the Discrete Cosine Transform to the log filterbank energies to
+ obtain the MFCC coefficients. This transformation helps decorrelate the
+ filterbank energies and captures the most important features of the audio
+ signal.
+
+7. Feature Extraction:
+ - Select a subset of the DCT coefficients to form the feature vector.
+ Often, the first few coefficients (e.g., 12-13) are used for most
+ applications.
+
+References:
+- Mel-Frequency Cepstral Coefficients (MFCCs):
+ https://en.wikipedia.org/wiki/Mel-frequency_cepstrum
+- Speech and Language Processing by Daniel Jurafsky & James H. Martin:
+ https://web.stanford.edu/~jurafsky/slp3/
+- Mel Frequency Cepstral Coefficient (MFCC) tutorial
+ http://practicalcryptography.com/miscellaneous/machine-learning
+ /guide-mel-frequency-cepstral-coefficients-mfccs/
+
+Author: Amir Lavasani
+"""
+
+import logging
+
+import numpy as np
+import scipy.fftpack as fft
+from scipy.signal import get_window
+
+logging.basicConfig(filename=f"{__file__}.log", level=logging.INFO)
+
+
+def mfcc(
+ audio: np.ndarray,
+ sample_rate: int,
+ ftt_size: int = 1024,
+ hop_length: int = 20,
+ mel_filter_num: int = 10,
+ dct_filter_num: int = 40,
+) -> np.ndarray:
+ """
+ Calculate Mel Frequency Cepstral Coefficients (MFCCs) from an audio signal.
+
+ Args:
+ audio: The input audio signal.
+ sample_rate: The sample rate of the audio signal (in Hz).
+ ftt_size: The size of the FFT window (default is 1024).
+ hop_length: The hop length for frame creation (default is 20ms).
+ mel_filter_num: The number of Mel filters (default is 10).
+ dct_filter_num: The number of DCT filters (default is 40).
+
+ Returns:
+ A matrix of MFCCs for the input audio.
+
+ Raises:
+ ValueError: If the input audio is empty.
+
+ Example:
+ >>> sample_rate = 44100 # Sample rate of 44.1 kHz
+ >>> duration = 2.0 # Duration of 1 second
+ >>> t = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)
+ >>> audio = 0.5 * np.sin(2 * np.pi * 440.0 * t) # Generate a 440 Hz sine wave
+ >>> mfccs = mfcc(audio, sample_rate)
+ >>> mfccs.shape
+ (40, 101)
+ """
+ logging.info(f"Sample rate: {sample_rate}Hz")
+ logging.info(f"Audio duration: {len(audio) / sample_rate}s")
+ logging.info(f"Audio min: {np.min(audio)}")
+ logging.info(f"Audio max: {np.max(audio)}")
+
+ # normalize audio
+ audio_normalized = normalize(audio)
+
+ logging.info(f"Normalized audio min: {np.min(audio_normalized)}")
+ logging.info(f"Normalized audio max: {np.max(audio_normalized)}")
+
+ # frame audio into
+ audio_framed = audio_frames(
+ audio_normalized, sample_rate, ftt_size=ftt_size, hop_length=hop_length
+ )
+
+ logging.info(f"Framed audio shape: {audio_framed.shape}")
+ logging.info(f"First frame: {audio_framed[0]}")
+
+ # convert to frequency domain
+ # For simplicity we will choose the Hanning window.
+ window = get_window("hann", ftt_size, fftbins=True)
+ audio_windowed = audio_framed * window
+
+ logging.info(f"Windowed audio shape: {audio_windowed.shape}")
+ logging.info(f"First frame: {audio_windowed[0]}")
+
+ audio_fft = calculate_fft(audio_windowed, ftt_size)
+ logging.info(f"fft audio shape: {audio_fft.shape}")
+ logging.info(f"First frame: {audio_fft[0]}")
+
+ audio_power = calculate_signal_power(audio_fft)
+ logging.info(f"power audio shape: {audio_power.shape}")
+ logging.info(f"First frame: {audio_power[0]}")
+
+ filters = mel_spaced_filterbank(sample_rate, mel_filter_num, ftt_size)
+ logging.info(f"filters shape: {filters.shape}")
+
+ audio_filtered = np.dot(filters, np.transpose(audio_power))
+ audio_log = 10.0 * np.log10(audio_filtered)
+ logging.info(f"audio_log shape: {audio_log.shape}")
+
+ dct_filters = discrete_cosine_transform(dct_filter_num, mel_filter_num)
+ cepstral_coefficents = np.dot(dct_filters, audio_log)
+
+ logging.info(f"cepstral_coefficents shape: {cepstral_coefficents.shape}")
+ return cepstral_coefficents
+
+
+def normalize(audio: np.ndarray) -> np.ndarray:
+ """
+ Normalize an audio signal by scaling it to have values between -1 and 1.
+
+ Args:
+ audio: The input audio signal.
+
+ Returns:
+ The normalized audio signal.
+
+ Examples:
+ >>> audio = np.array([1, 2, 3, 4, 5])
+ >>> normalized_audio = normalize(audio)
+ >>> float(np.max(normalized_audio))
+ 1.0
+ >>> float(np.min(normalized_audio))
+ 0.2
+ """
+ # Divide the entire audio signal by the maximum absolute value
+ return audio / np.max(np.abs(audio))
+
+
+def audio_frames(
+ audio: np.ndarray,
+ sample_rate: int,
+ hop_length: int = 20,
+ ftt_size: int = 1024,
+) -> np.ndarray:
+ """
+ Split an audio signal into overlapping frames.
+
+ Args:
+ audio: The input audio signal.
+ sample_rate: The sample rate of the audio signal.
+ hop_length: The length of the hopping (default is 20ms).
+ ftt_size: The size of the FFT window (default is 1024).
+
+ Returns:
+ An array of overlapping frames.
+
+ Examples:
+ >>> audio = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]*1000)
+ >>> sample_rate = 8000
+ >>> frames = audio_frames(audio, sample_rate, hop_length=10, ftt_size=512)
+ >>> frames.shape
+ (126, 512)
+ """
+
+ hop_size = np.round(sample_rate * hop_length / 1000).astype(int)
+
+ # Pad the audio signal to handle edge cases
+ audio = np.pad(audio, int(ftt_size / 2), mode="reflect")
+
+ # Calculate the number of frames
+ frame_count = int((len(audio) - ftt_size) / hop_size) + 1
+
+ # Initialize an array to store the frames
+ frames = np.zeros((frame_count, ftt_size))
+
+ # Split the audio signal into frames
+ for n in range(frame_count):
+ frames[n] = audio[n * hop_size : n * hop_size + ftt_size]
+
+ return frames
+
+
+def calculate_fft(audio_windowed: np.ndarray, ftt_size: int = 1024) -> np.ndarray:
+ """
+ Calculate the Fast Fourier Transform (FFT) of windowed audio data.
+
+ Args:
+ audio_windowed: The windowed audio signal.
+ ftt_size: The size of the FFT (default is 1024).
+
+ Returns:
+ The FFT of the audio data.
+
+ Examples:
+ >>> audio_windowed = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
+ >>> audio_fft = calculate_fft(audio_windowed, ftt_size=4)
+ >>> bool(np.allclose(audio_fft[0], np.array([6.0+0.j, -1.5+0.8660254j,
+ ... -1.5-0.8660254j])))
+ True
+ """
+ # Transpose the audio data to have time in rows and channels in columns
+ audio_transposed = np.transpose(audio_windowed)
+
+ # Initialize an array to store the FFT results
+ audio_fft = np.empty(
+ (int(1 + ftt_size // 2), audio_transposed.shape[1]),
+ dtype=np.complex64,
+ order="F",
+ )
+
+ # Compute FFT for each channel
+ for n in range(audio_fft.shape[1]):
+ audio_fft[:, n] = fft.fft(audio_transposed[:, n], axis=0)[: audio_fft.shape[0]]
+
+ # Transpose the FFT results back to the original shape
+ return np.transpose(audio_fft)
+
+
+def calculate_signal_power(audio_fft: np.ndarray) -> np.ndarray:
+ """
+ Calculate the power of the audio signal from its FFT.
+
+ Args:
+ audio_fft: The FFT of the audio signal.
+
+ Returns:
+ The power of the audio signal.
+
+ Examples:
+ >>> audio_fft = np.array([1+2j, 2+3j, 3+4j, 4+5j])
+ >>> power = calculate_signal_power(audio_fft)
+ >>> np.allclose(power, np.array([5, 13, 25, 41]))
+ True
+ """
+ # Calculate the power by squaring the absolute values of the FFT coefficients
+ return np.square(np.abs(audio_fft))
+
+
+def freq_to_mel(freq: float) -> float:
+ """
+ Convert a frequency in Hertz to the mel scale.
+
+ Args:
+ freq: The frequency in Hertz.
+
+ Returns:
+ The frequency in mel scale.
+
+ Examples:
+ >>> float(round(freq_to_mel(1000), 2))
+ 999.99
+ """
+ # Use the formula to convert frequency to the mel scale
+ return 2595.0 * np.log10(1.0 + freq / 700.0)
+
+
+def mel_to_freq(mels: float) -> float:
+ """
+ Convert a frequency in the mel scale to Hertz.
+
+ Args:
+ mels: The frequency in mel scale.
+
+ Returns:
+ The frequency in Hertz.
+
+ Examples:
+ >>> round(mel_to_freq(999.99), 2)
+ 1000.01
+ """
+ # Use the formula to convert mel scale to frequency
+ return 700.0 * (10.0 ** (mels / 2595.0) - 1.0)
+
+
+def mel_spaced_filterbank(
+ sample_rate: int, mel_filter_num: int = 10, ftt_size: int = 1024
+) -> np.ndarray:
+ """
+ Create a Mel-spaced filter bank for audio processing.
+
+ Args:
+ sample_rate: The sample rate of the audio.
+ mel_filter_num: The number of mel filters (default is 10).
+ ftt_size: The size of the FFT (default is 1024).
+
+ Returns:
+ Mel-spaced filter bank.
+
+ Examples:
+ >>> float(round(mel_spaced_filterbank(8000, 10, 1024)[0][1], 10))
+ 0.0004603981
+ """
+ freq_min = 0
+ freq_high = sample_rate // 2
+
+ logging.info(f"Minimum frequency: {freq_min}")
+ logging.info(f"Maximum frequency: {freq_high}")
+
+ # Calculate filter points and mel frequencies
+ filter_points, mel_freqs = get_filter_points(
+ sample_rate,
+ freq_min,
+ freq_high,
+ mel_filter_num,
+ ftt_size,
+ )
+
+ filters = get_filters(filter_points, ftt_size)
+
+ # normalize filters
+ # taken from the librosa library
+ enorm = 2.0 / (mel_freqs[2 : mel_filter_num + 2] - mel_freqs[:mel_filter_num])
+ return filters * enorm[:, np.newaxis]
+
+
+def get_filters(filter_points: np.ndarray, ftt_size: int) -> np.ndarray:
+ """
+ Generate filters for audio processing.
+
+ Args:
+ filter_points: A list of filter points.
+ ftt_size: The size of the FFT.
+
+ Returns:
+ A matrix of filters.
+
+ Examples:
+ >>> get_filters(np.array([0, 20, 51, 95, 161, 256], dtype=int), 512).shape
+ (4, 257)
+ """
+ num_filters = len(filter_points) - 2
+ filters = np.zeros((num_filters, int(ftt_size / 2) + 1))
+
+ for n in range(num_filters):
+ start = filter_points[n]
+ mid = filter_points[n + 1]
+ end = filter_points[n + 2]
+
+ # Linearly increase values from 0 to 1
+ filters[n, start:mid] = np.linspace(0, 1, mid - start)
+
+ # Linearly decrease values from 1 to 0
+ filters[n, mid:end] = np.linspace(1, 0, end - mid)
+
+ return filters
+
+
+def get_filter_points(
+ sample_rate: int,
+ freq_min: int,
+ freq_high: int,
+ mel_filter_num: int = 10,
+ ftt_size: int = 1024,
+) -> tuple[np.ndarray, np.ndarray]:
+ """
+ Calculate the filter points and frequencies for mel frequency filters.
+
+ Args:
+ sample_rate: The sample rate of the audio.
+ freq_min: The minimum frequency in Hertz.
+ freq_high: The maximum frequency in Hertz.
+ mel_filter_num: The number of mel filters (default is 10).
+ ftt_size: The size of the FFT (default is 1024).
+
+ Returns:
+ Filter points and corresponding frequencies.
+
+ Examples:
+ >>> filter_points = get_filter_points(8000, 0, 4000, mel_filter_num=4, ftt_size=512)
+ >>> filter_points[0]
+ array([ 0, 20, 51, 95, 161, 256])
+ >>> filter_points[1]
+ array([ 0. , 324.46707094, 799.33254207, 1494.30973963,
+ 2511.42581671, 4000. ])
+ """
+ # Convert minimum and maximum frequencies to mel scale
+ fmin_mel = freq_to_mel(freq_min)
+ fmax_mel = freq_to_mel(freq_high)
+
+ logging.info(f"MEL min: {fmin_mel}")
+ logging.info(f"MEL max: {fmax_mel}")
+
+ # Generate equally spaced mel frequencies
+ mels = np.linspace(fmin_mel, fmax_mel, num=mel_filter_num + 2)
+
+ # Convert mel frequencies back to Hertz
+ freqs = mel_to_freq(mels)
+
+ # Calculate filter points as integer values
+ filter_points = np.floor((ftt_size + 1) / sample_rate * freqs).astype(int)
+
+ return filter_points, freqs
+
+
+def discrete_cosine_transform(dct_filter_num: int, filter_num: int) -> np.ndarray:
+ """
+ Compute the Discrete Cosine Transform (DCT) basis matrix.
+
+ Args:
+ dct_filter_num: The number of DCT filters to generate.
+ filter_num: The number of the fbank filters.
+
+ Returns:
+ The DCT basis matrix.
+
+ Examples:
+ >>> float(round(discrete_cosine_transform(3, 5)[0][0], 5))
+ 0.44721
+ """
+ basis = np.empty((dct_filter_num, filter_num))
+ basis[0, :] = 1.0 / np.sqrt(filter_num)
+
+ samples = np.arange(1, 2 * filter_num, 2) * np.pi / (2.0 * filter_num)
+
+ for i in range(1, dct_filter_num):
+ basis[i, :] = np.cos(i * samples) * np.sqrt(2.0 / filter_num)
+
+ return basis
+
+
+def example(wav_file_path: str = "./path-to-file/sample.wav") -> np.ndarray:
+ """
+ Example function to calculate Mel Frequency Cepstral Coefficients
+ (MFCCs) from an audio file.
+
+ Args:
+ wav_file_path: The path to the WAV audio file.
+
+ Returns:
+ np.ndarray: The computed MFCCs for the audio.
+ """
+ from scipy.io import wavfile
+
+ # Load the audio from the WAV file
+ sample_rate, audio = wavfile.read(wav_file_path)
+
+ # Calculate MFCCs
+ return mfcc(audio, sample_rate)
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/machine_learning/multilayer_perceptron_classifier.py b/machine_learning/multilayer_perceptron_classifier.py
index 604185cef677..40f998c7dfa2 100644
--- a/machine_learning/multilayer_perceptron_classifier.py
+++ b/machine_learning/multilayer_perceptron_classifier.py
@@ -15,12 +15,12 @@
Y = clf.predict(test)
-def wrapper(Y):
+def wrapper(y):
"""
- >>> wrapper(Y)
+ >>> [int(x) for x in wrapper(Y)]
[0, 0, 1]
"""
- return list(Y)
+ return list(y)
if __name__ == "__main__":
diff --git a/machine_learning/polymonial_regression.py b/machine_learning/polymonial_regression.py
deleted file mode 100644
index 374c35f7f905..000000000000
--- a/machine_learning/polymonial_regression.py
+++ /dev/null
@@ -1,45 +0,0 @@
-import pandas as pd
-from matplotlib import pyplot as plt
-from sklearn.linear_model import LinearRegression
-
-# Splitting the dataset into the Training set and Test set
-from sklearn.model_selection import train_test_split
-
-# Fitting Polynomial Regression to the dataset
-from sklearn.preprocessing import PolynomialFeatures
-
-# Importing the dataset
-dataset = pd.read_csv(
- "https://s3.us-west-2.amazonaws.com/public.gamelab.fun/dataset/"
- "position_salaries.csv"
-)
-X = dataset.iloc[:, 1:2].values
-y = dataset.iloc[:, 2].values
-
-
-X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
-
-
-poly_reg = PolynomialFeatures(degree=4)
-X_poly = poly_reg.fit_transform(X)
-pol_reg = LinearRegression()
-pol_reg.fit(X_poly, y)
-
-
-# Visualizing the Polymonial Regression results
-def viz_polymonial():
- plt.scatter(X, y, color="red")
- plt.plot(X, pol_reg.predict(poly_reg.fit_transform(X)), color="blue")
- plt.title("Truth or Bluff (Linear Regression)")
- plt.xlabel("Position level")
- plt.ylabel("Salary")
- plt.show()
- return
-
-
-if __name__ == "__main__":
- viz_polymonial()
-
- # Predicting a new result with Polymonial Regression
- pol_reg.predict(poly_reg.fit_transform([[5.5]]))
- # output should be 132148.43750003
diff --git a/machine_learning/polynomial_regression.py b/machine_learning/polynomial_regression.py
new file mode 100644
index 000000000000..212f40bea197
--- /dev/null
+++ b/machine_learning/polynomial_regression.py
@@ -0,0 +1,213 @@
+"""
+Polynomial regression is a type of regression analysis that models the relationship
+between a predictor x and the response y as an mth-degree polynomial:
+
+y = β₀ + β₁x + β₂x² + ... + βₘxᵐ + ε
+
+By treating x, x², ..., xᵐ as distinct variables, we see that polynomial regression is a
+special case of multiple linear regression. Therefore, we can use ordinary least squares
+(OLS) estimation to estimate the vector of model parameters β = (β₀, β₁, β₂, ..., βₘ)
+for polynomial regression:
+
+β = (XᵀX)⁻¹Xᵀy = X⁺y
+
+where X is the design matrix, y is the response vector, and X⁺ denotes the Moore-Penrose
+pseudoinverse of X. In the case of polynomial regression, the design matrix is
+
+ |1 x₁ x₁² ⋯ x₁ᵐ|
+X = |1 x₂ x₂² ⋯ x₂ᵐ|
+ |⋮ ⋮ ⋮ ⋱ ⋮ |
+ |1 xₙ xₙ² ⋯ xₙᵐ|
+
+In OLS estimation, inverting XᵀX to compute X⁺ can be very numerically unstable. This
+implementation sidesteps this need to invert XᵀX by computing X⁺ using singular value
+decomposition (SVD):
+
+β = VΣ⁺Uᵀy
+
+where UΣVᵀ is an SVD of X.
+
+References:
+ - https://en.wikipedia.org/wiki/Polynomial_regression
+ - https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_inverse
+ - https://en.wikipedia.org/wiki/Numerical_methods_for_linear_least_squares
+ - https://en.wikipedia.org/wiki/Singular_value_decomposition
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+class PolynomialRegression:
+ __slots__ = "degree", "params"
+
+ def __init__(self, degree: int) -> None:
+ """
+ @raises ValueError: if the polynomial degree is negative
+ """
+ if degree < 0:
+ raise ValueError("Polynomial degree must be non-negative")
+
+ self.degree = degree
+ self.params = None
+
+ @staticmethod
+ def _design_matrix(data: np.ndarray, degree: int) -> np.ndarray:
+ """
+ Constructs a polynomial regression design matrix for the given input data. For
+ input data x = (x₁, x₂, ..., xₙ) and polynomial degree m, the design matrix is
+ the Vandermonde matrix
+
+ |1 x₁ x₁² ⋯ x₁ᵐ|
+ X = |1 x₂ x₂² ⋯ x₂ᵐ|
+ |⋮ ⋮ ⋮ ⋱ ⋮ |
+ |1 xₙ xₙ² ⋯ xₙᵐ|
+
+ Reference: https://en.wikipedia.org/wiki/Vandermonde_matrix
+
+ @param data: the input predictor values x, either for model fitting or for
+ prediction
+ @param degree: the polynomial degree m
+ @returns: the Vandermonde matrix X (see above)
+ @raises ValueError: if input data is not N x 1
+
+ >>> x = np.array([0, 1, 2])
+ >>> PolynomialRegression._design_matrix(x, degree=0)
+ array([[1],
+ [1],
+ [1]])
+ >>> PolynomialRegression._design_matrix(x, degree=1)
+ array([[1, 0],
+ [1, 1],
+ [1, 2]])
+ >>> PolynomialRegression._design_matrix(x, degree=2)
+ array([[1, 0, 0],
+ [1, 1, 1],
+ [1, 2, 4]])
+ >>> PolynomialRegression._design_matrix(x, degree=3)
+ array([[1, 0, 0, 0],
+ [1, 1, 1, 1],
+ [1, 2, 4, 8]])
+ >>> PolynomialRegression._design_matrix(np.array([[0, 0], [0 , 0]]), degree=3)
+ Traceback (most recent call last):
+ ...
+ ValueError: Data must have dimensions N x 1
+ """
+ rows, *remaining = data.shape
+ if remaining:
+ raise ValueError("Data must have dimensions N x 1")
+
+ return np.vander(data, N=degree + 1, increasing=True)
+
+ def fit(self, x_train: np.ndarray, y_train: np.ndarray) -> None:
+ """
+ Computes the polynomial regression model parameters using ordinary least squares
+ (OLS) estimation:
+
+ β = (XᵀX)⁻¹Xᵀy = X⁺y
+
+ where X⁺ denotes the Moore-Penrose pseudoinverse of the design matrix X. This
+ function computes X⁺ using singular value decomposition (SVD).
+
+ References:
+ - https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_inverse
+ - https://en.wikipedia.org/wiki/Singular_value_decomposition
+ - https://en.wikipedia.org/wiki/Multicollinearity
+
+ @param x_train: the predictor values x for model fitting
+ @param y_train: the response values y for model fitting
+ @raises ArithmeticError: if X isn't full rank, then XᵀX is singular and β
+ doesn't exist
+
+ >>> x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+ >>> y = x**3 - 2 * x**2 + 3 * x - 5
+ >>> poly_reg = PolynomialRegression(degree=3)
+ >>> poly_reg.fit(x, y)
+ >>> poly_reg.params
+ array([-5., 3., -2., 1.])
+ >>> poly_reg = PolynomialRegression(degree=20)
+ >>> poly_reg.fit(x, y)
+ Traceback (most recent call last):
+ ...
+ ArithmeticError: Design matrix is not full rank, can't compute coefficients
+
+ Make sure errors don't grow too large:
+ >>> coefs = np.array([-250, 50, -2, 36, 20, -12, 10, 2, -1, -15, 1])
+ >>> y = PolynomialRegression._design_matrix(x, len(coefs) - 1) @ coefs
+ >>> poly_reg = PolynomialRegression(degree=len(coefs) - 1)
+ >>> poly_reg.fit(x, y)
+ >>> np.allclose(poly_reg.params, coefs, atol=10e-3)
+ True
+ """
+ X = PolynomialRegression._design_matrix(x_train, self.degree) # noqa: N806
+ _, cols = X.shape
+ if np.linalg.matrix_rank(X) < cols:
+ raise ArithmeticError(
+ "Design matrix is not full rank, can't compute coefficients"
+ )
+
+ # np.linalg.pinv() computes the Moore-Penrose pseudoinverse using SVD
+ self.params = np.linalg.pinv(X) @ y_train
+
+ def predict(self, data: np.ndarray) -> np.ndarray:
+ """
+ Computes the predicted response values y for the given input data by
+ constructing the design matrix X and evaluating y = Xβ.
+
+ @param data: the predictor values x for prediction
+ @returns: the predicted response values y = Xβ
+ @raises ArithmeticError: if this function is called before the model
+ parameters are fit
+
+ >>> x = np.array([0, 1, 2, 3, 4])
+ >>> y = x**3 - 2 * x**2 + 3 * x - 5
+ >>> poly_reg = PolynomialRegression(degree=3)
+ >>> poly_reg.fit(x, y)
+ >>> poly_reg.predict(np.array([-1]))
+ array([-11.])
+ >>> poly_reg.predict(np.array([-2]))
+ array([-27.])
+ >>> poly_reg.predict(np.array([6]))
+ array([157.])
+ >>> PolynomialRegression(degree=3).predict(x)
+ Traceback (most recent call last):
+ ...
+ ArithmeticError: Predictor hasn't been fit yet
+ """
+ if self.params is None:
+ raise ArithmeticError("Predictor hasn't been fit yet")
+
+ return PolynomialRegression._design_matrix(data, self.degree) @ self.params
+
+
+def main() -> None:
+ """
+ Fit a polynomial regression model to predict fuel efficiency using seaborn's mpg
+ dataset
+
+ >>> pass # Placeholder, function is only for demo purposes
+ """
+ import seaborn as sns
+
+ mpg_data = sns.load_dataset("mpg")
+
+ poly_reg = PolynomialRegression(degree=2)
+ poly_reg.fit(mpg_data.weight, mpg_data.mpg)
+
+ weight_sorted = np.sort(mpg_data.weight)
+ predictions = poly_reg.predict(weight_sorted)
+
+ plt.scatter(mpg_data.weight, mpg_data.mpg, color="gray", alpha=0.5)
+ plt.plot(weight_sorted, predictions, color="red", linewidth=3)
+ plt.title("Predicting Fuel Efficiency Using Polynomial Regression")
+ plt.xlabel("Weight (lbs)")
+ plt.ylabel("Fuel Efficiency (mpg)")
+ plt.show()
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+
+ main()
diff --git a/machine_learning/principle_component_analysis.py b/machine_learning/principle_component_analysis.py
new file mode 100644
index 000000000000..46ccdb968494
--- /dev/null
+++ b/machine_learning/principle_component_analysis.py
@@ -0,0 +1,85 @@
+"""
+Principal Component Analysis (PCA) is a dimensionality reduction technique
+used in machine learning. It transforms high-dimensional data into a lower-dimensional
+representation while retaining as much variance as possible.
+
+This implementation follows best practices, including:
+- Standardizing the dataset.
+- Computing principal components using Singular Value Decomposition (SVD).
+- Returning transformed data and explained variance ratio.
+"""
+
+import doctest
+
+import numpy as np
+from sklearn.datasets import load_iris
+from sklearn.decomposition import PCA
+from sklearn.preprocessing import StandardScaler
+
+
+def collect_dataset() -> tuple[np.ndarray, np.ndarray]:
+ """
+ Collects the dataset (Iris dataset) and returns feature matrix and target values.
+
+ :return: Tuple containing feature matrix (X) and target labels (y)
+
+ Example:
+ >>> X, y = collect_dataset()
+ >>> X.shape
+ (150, 4)
+ >>> y.shape
+ (150,)
+ """
+ data = load_iris()
+ return np.array(data.data), np.array(data.target)
+
+
+def apply_pca(data_x: np.ndarray, n_components: int) -> tuple[np.ndarray, np.ndarray]:
+ """
+ Applies Principal Component Analysis (PCA) to reduce dimensionality.
+
+ :param data_x: Original dataset (features)
+ :param n_components: Number of principal components to retain
+ :return: Tuple containing transformed dataset and explained variance ratio
+
+ Example:
+ >>> X, _ = collect_dataset()
+ >>> transformed_X, variance = apply_pca(X, 2)
+ >>> transformed_X.shape
+ (150, 2)
+ >>> len(variance) == 2
+ True
+ """
+ # Standardizing the dataset
+ scaler = StandardScaler()
+ data_x_scaled = scaler.fit_transform(data_x)
+
+ # Applying PCA
+ pca = PCA(n_components=n_components)
+ principal_components = pca.fit_transform(data_x_scaled)
+
+ return principal_components, pca.explained_variance_ratio_
+
+
+def main() -> None:
+ """
+ Driver function to execute PCA and display results.
+ """
+ data_x, data_y = collect_dataset()
+
+ # Number of principal components to retain
+ n_components = 2
+
+ # Apply PCA
+ transformed_data, variance_ratio = apply_pca(data_x, n_components)
+
+ print("Transformed Dataset (First 5 rows):")
+ print(transformed_data[:5])
+
+ print("\nExplained Variance Ratio:")
+ print(variance_ratio)
+
+
+if __name__ == "__main__":
+ doctest.testmod()
+ main()
diff --git a/machine_learning/random_forest_classifier.py b/machine_learning/random_forest_classifier.py.broken.txt
similarity index 91%
rename from machine_learning/random_forest_classifier.py
rename to machine_learning/random_forest_classifier.py.broken.txt
index 6370254090f7..3267fa209660 100644
--- a/machine_learning/random_forest_classifier.py
+++ b/machine_learning/random_forest_classifier.py.broken.txt
@@ -17,10 +17,10 @@ def main():
iris = load_iris()
# Split dataset into train and test data
- X = iris["data"] # features
- Y = iris["target"]
+ x = iris["data"] # features
+ y = iris["target"]
x_train, x_test, y_train, y_test = train_test_split(
- X, Y, test_size=0.3, random_state=1
+ x, y, test_size=0.3, random_state=1
)
# Random Forest Classifier
diff --git a/machine_learning/random_forest_regressor.py b/machine_learning/random_forest_regressor.py.broken.txt
similarity index 91%
rename from machine_learning/random_forest_regressor.py
rename to machine_learning/random_forest_regressor.py.broken.txt
index 0aade626b038..1001931a109d 100644
--- a/machine_learning/random_forest_regressor.py
+++ b/machine_learning/random_forest_regressor.py.broken.txt
@@ -17,10 +17,10 @@ def main():
print(boston.keys())
# Split dataset into train and test data
- X = boston["data"] # features
- Y = boston["target"]
+ x = boston["data"] # features
+ y = boston["target"]
x_train, x_test, y_train, y_test = train_test_split(
- X, Y, test_size=0.3, random_state=1
+ x, y, test_size=0.3, random_state=1
)
# Random Forest Regressor
diff --git a/machine_learning/scoring_functions.py b/machine_learning/scoring_functions.py
index 08b969a95c3b..f6b685f4f98a 100644
--- a/machine_learning/scoring_functions.py
+++ b/machine_learning/scoring_functions.py
@@ -20,11 +20,11 @@ def mae(predict, actual):
"""
Examples(rounded for precision):
>>> actual = [1,2,3];predict = [1,4,3]
- >>> np.around(mae(predict,actual),decimals = 2)
+ >>> float(np.around(mae(predict,actual),decimals = 2))
0.67
>>> actual = [1,1,1];predict = [1,1,1]
- >>> mae(predict,actual)
+ >>> float(mae(predict,actual))
0.0
"""
predict = np.array(predict)
@@ -41,11 +41,11 @@ def mse(predict, actual):
"""
Examples(rounded for precision):
>>> actual = [1,2,3];predict = [1,4,3]
- >>> np.around(mse(predict,actual),decimals = 2)
+ >>> float(np.around(mse(predict,actual),decimals = 2))
1.33
>>> actual = [1,1,1];predict = [1,1,1]
- >>> mse(predict,actual)
+ >>> float(mse(predict,actual))
0.0
"""
predict = np.array(predict)
@@ -63,11 +63,11 @@ def rmse(predict, actual):
"""
Examples(rounded for precision):
>>> actual = [1,2,3];predict = [1,4,3]
- >>> np.around(rmse(predict,actual),decimals = 2)
+ >>> float(np.around(rmse(predict,actual),decimals = 2))
1.15
>>> actual = [1,1,1];predict = [1,1,1]
- >>> rmse(predict,actual)
+ >>> float(rmse(predict,actual))
0.0
"""
predict = np.array(predict)
@@ -84,12 +84,10 @@ def rmse(predict, actual):
def rmsle(predict, actual):
"""
Examples(rounded for precision):
- >>> actual = [10,10,30];predict = [10,2,30]
- >>> np.around(rmsle(predict,actual),decimals = 2)
+ >>> float(np.around(rmsle(predict=[10, 2, 30], actual=[10, 10, 30]), decimals=2))
0.75
- >>> actual = [1,1,1];predict = [1,1,1]
- >>> rmsle(predict,actual)
+ >>> float(rmsle(predict=[1, 1, 1], actual=[1, 1, 1]))
0.0
"""
predict = np.array(predict)
@@ -117,12 +115,12 @@ def mbd(predict, actual):
Here the model overpredicts
>>> actual = [1,2,3];predict = [2,3,4]
- >>> np.around(mbd(predict,actual),decimals = 2)
+ >>> float(np.around(mbd(predict,actual),decimals = 2))
50.0
Here the model underpredicts
>>> actual = [1,2,3];predict = [0,1,1]
- >>> np.around(mbd(predict,actual),decimals = 2)
+ >>> float(np.around(mbd(predict,actual),decimals = 2))
-66.67
"""
predict = np.array(predict)
diff --git a/machine_learning/self_organizing_map.py b/machine_learning/self_organizing_map.py
new file mode 100644
index 000000000000..fb9d0074e791
--- /dev/null
+++ b/machine_learning/self_organizing_map.py
@@ -0,0 +1,73 @@
+"""
+https://en.wikipedia.org/wiki/Self-organizing_map
+"""
+
+import math
+
+
+class SelfOrganizingMap:
+ def get_winner(self, weights: list[list[float]], sample: list[int]) -> int:
+ """
+ Compute the winning vector by Euclidean distance
+
+ >>> SelfOrganizingMap().get_winner([[1, 2, 3], [4, 5, 6]], [1, 2, 3])
+ 1
+ """
+ d0 = 0.0
+ d1 = 0.0
+ for i in range(len(sample)):
+ d0 += math.pow((sample[i] - weights[0][i]), 2)
+ d1 += math.pow((sample[i] - weights[1][i]), 2)
+ return 0 if d0 > d1 else 1
+ return 0
+
+ def update(
+ self, weights: list[list[int | float]], sample: list[int], j: int, alpha: float
+ ) -> list[list[int | float]]:
+ """
+ Update the winning vector.
+
+ >>> SelfOrganizingMap().update([[1, 2, 3], [4, 5, 6]], [1, 2, 3], 1, 0.1)
+ [[1, 2, 3], [3.7, 4.7, 6]]
+ """
+ for i in range(len(weights)):
+ weights[j][i] += alpha * (sample[i] - weights[j][i])
+ return weights
+
+
+# Driver code
+def main() -> None:
+ # Training Examples ( m, n )
+ training_samples = [[1, 1, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 0, 1, 1]]
+
+ # weight initialization ( n, C )
+ weights = [[0.2, 0.6, 0.5, 0.9], [0.8, 0.4, 0.7, 0.3]]
+
+ # training
+ self_organizing_map = SelfOrganizingMap()
+ epochs = 3
+ alpha = 0.5
+
+ for _ in range(epochs):
+ for j in range(len(training_samples)):
+ # training sample
+ sample = training_samples[j]
+
+ # Compute the winning vector
+ winner = self_organizing_map.get_winner(weights, sample)
+
+ # Update the winning vector
+ weights = self_organizing_map.update(weights, sample, winner, alpha)
+
+ # classify test sample
+ sample = [0, 0, 0, 1]
+ winner = self_organizing_map.get_winner(weights, sample)
+
+ # results
+ print(f"Clusters that the test sample belongs to : {winner}")
+ print(f"Weights that have been trained : {weights}")
+
+
+# running the main() function
+if __name__ == "__main__":
+ main()
diff --git a/machine_learning/sequential_minimum_optimization.py b/machine_learning/sequential_minimum_optimization.py
index 98ce05c46cff..625fc28fe60c 100644
--- a/machine_learning/sequential_minimum_optimization.py
+++ b/machine_learning/sequential_minimum_optimization.py
@@ -1,632 +1,622 @@
-"""
- Implementation of sequential minimal optimization (SMO) for support vector machines
- (SVM).
-
- Sequential minimal optimization (SMO) is an algorithm for solving the quadratic
- programming (QP) problem that arises during the training of support vector
- machines.
- It was invented by John Platt in 1998.
-
-Input:
- 0: type: numpy.ndarray.
- 1: first column of ndarray must be tags of samples, must be 1 or -1.
- 2: rows of ndarray represent samples.
-
-Usage:
- Command:
- python3 sequential_minimum_optimization.py
- Code:
- from sequential_minimum_optimization import SmoSVM, Kernel
-
- kernel = Kernel(kernel='poly', degree=3., coef0=1., gamma=0.5)
- init_alphas = np.zeros(train.shape[0])
- SVM = SmoSVM(train=train, alpha_list=init_alphas, kernel_func=kernel, cost=0.4,
- b=0.0, tolerance=0.001)
- SVM.fit()
- predict = SVM.predict(test_samples)
-
-Reference:
- https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/smo-book.pdf
- https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/tr-98-14.pdf
- http://web.cs.iastate.edu/~honavar/smo-svm.pdf
-"""
-
-
-import os
-import sys
-import urllib.request
-
-import numpy as np
-import pandas as pd
-from matplotlib import pyplot as plt
-from sklearn.datasets import make_blobs, make_circles
-from sklearn.preprocessing import StandardScaler
-
-CANCER_DATASET_URL = (
- "http://archive.ics.uci.edu/ml/machine-learning-databases/"
- "breast-cancer-wisconsin/wdbc.data"
-)
-
-
-class SmoSVM:
- def __init__(
- self,
- train,
- kernel_func,
- alpha_list=None,
- cost=0.4,
- b=0.0,
- tolerance=0.001,
- auto_norm=True,
- ):
- self._init = True
- self._auto_norm = auto_norm
- self._c = np.float64(cost)
- self._b = np.float64(b)
- self._tol = np.float64(tolerance) if tolerance > 0.0001 else np.float64(0.001)
-
- self.tags = train[:, 0]
- self.samples = self._norm(train[:, 1:]) if self._auto_norm else train[:, 1:]
- self.alphas = alpha_list if alpha_list is not None else np.zeros(train.shape[0])
- self.Kernel = kernel_func
-
- self._eps = 0.001
- self._all_samples = list(range(self.length))
- self._K_matrix = self._calculate_k_matrix()
- self._error = np.zeros(self.length)
- self._unbound = []
-
- self.choose_alpha = self._choose_alphas()
-
- # Calculate alphas using SMO algorithm
- def fit(self):
- K = self._k
- state = None
- while True:
-
- # 1: Find alpha1, alpha2
- try:
- i1, i2 = self.choose_alpha.send(state)
- state = None
- except StopIteration:
- print("Optimization done!\nEvery sample satisfy the KKT condition!")
- break
-
- # 2: calculate new alpha2 and new alpha1
- y1, y2 = self.tags[i1], self.tags[i2]
- a1, a2 = self.alphas[i1].copy(), self.alphas[i2].copy()
- e1, e2 = self._e(i1), self._e(i2)
- args = (i1, i2, a1, a2, e1, e2, y1, y2)
- a1_new, a2_new = self._get_new_alpha(*args)
- if not a1_new and not a2_new:
- state = False
- continue
- self.alphas[i1], self.alphas[i2] = a1_new, a2_new
-
- # 3: update threshold(b)
- b1_new = np.float64(
- -e1
- - y1 * K(i1, i1) * (a1_new - a1)
- - y2 * K(i2, i1) * (a2_new - a2)
- + self._b
- )
- b2_new = np.float64(
- -e2
- - y2 * K(i2, i2) * (a2_new - a2)
- - y1 * K(i1, i2) * (a1_new - a1)
- + self._b
- )
- if 0.0 < a1_new < self._c:
- b = b1_new
- if 0.0 < a2_new < self._c:
- b = b2_new
- if not (np.float64(0) < a2_new < self._c) and not (
- np.float64(0) < a1_new < self._c
- ):
- b = (b1_new + b2_new) / 2.0
- b_old = self._b
- self._b = b
-
- # 4: update error value,here we only calculate those non-bound samples'
- # error
- self._unbound = [i for i in self._all_samples if self._is_unbound(i)]
- for s in self.unbound:
- if s == i1 or s == i2:
- continue
- self._error[s] += (
- y1 * (a1_new - a1) * K(i1, s)
- + y2 * (a2_new - a2) * K(i2, s)
- + (self._b - b_old)
- )
-
- # if i1 or i2 is non-bound,update there error value to zero
- if self._is_unbound(i1):
- self._error[i1] = 0
- if self._is_unbound(i2):
- self._error[i2] = 0
-
- # Predict test samles
- def predict(self, test_samples, classify=True):
-
- if test_samples.shape[1] > self.samples.shape[1]:
- raise ValueError(
- "Test samples' feature length does not equal to that of train samples"
- )
-
- if self._auto_norm:
- test_samples = self._norm(test_samples)
-
- results = []
- for test_sample in test_samples:
- result = self._predict(test_sample)
- if classify:
- results.append(1 if result > 0 else -1)
- else:
- results.append(result)
- return np.array(results)
-
- # Check if alpha violate KKT condition
- def _check_obey_kkt(self, index):
- alphas = self.alphas
- tol = self._tol
- r = self._e(index) * self.tags[index]
- c = self._c
-
- return (r < -tol and alphas[index] < c) or (r > tol and alphas[index] > 0.0)
-
- # Get value calculated from kernel function
- def _k(self, i1, i2):
- # for test samples,use Kernel function
- if isinstance(i2, np.ndarray):
- return self.Kernel(self.samples[i1], i2)
- # for train samples,Kernel values have been saved in matrix
- else:
- return self._K_matrix[i1, i2]
-
- # Get sample's error
- def _e(self, index):
- """
- Two cases:
- 1:Sample[index] is non-bound,Fetch error from list: _error
- 2:sample[index] is bound,Use predicted value deduct true value: g(xi) - yi
-
- """
- # get from error data
- if self._is_unbound(index):
- return self._error[index]
- # get by g(xi) - yi
- else:
- gx = np.dot(self.alphas * self.tags, self._K_matrix[:, index]) + self._b
- yi = self.tags[index]
- return gx - yi
-
- # Calculate Kernel matrix of all possible i1,i2 ,saving time
- def _calculate_k_matrix(self):
- k_matrix = np.zeros([self.length, self.length])
- for i in self._all_samples:
- for j in self._all_samples:
- k_matrix[i, j] = np.float64(
- self.Kernel(self.samples[i, :], self.samples[j, :])
- )
- return k_matrix
-
- # Predict test sample's tag
- def _predict(self, sample):
- k = self._k
- predicted_value = (
- np.sum(
- [
- self.alphas[i1] * self.tags[i1] * k(i1, sample)
- for i1 in self._all_samples
- ]
- )
- + self._b
- )
- return predicted_value
-
- # Choose alpha1 and alpha2
- def _choose_alphas(self):
- locis = yield from self._choose_a1()
- if not locis:
- return
- return locis
-
- def _choose_a1(self):
- """
- Choose first alpha ;steps:
- 1:First loop over all sample
- 2:Second loop over all non-bound samples till all non-bound samples does not
- voilate kkt condition.
- 3:Repeat this two process endlessly,till all samples does not voilate kkt
- condition samples after first loop.
- """
- while True:
- all_not_obey = True
- # all sample
- print("scanning all sample!")
- for i1 in [i for i in self._all_samples if self._check_obey_kkt(i)]:
- all_not_obey = False
- yield from self._choose_a2(i1)
-
- # non-bound sample
- print("scanning non-bound sample!")
- while True:
- not_obey = True
- for i1 in [
- i
- for i in self._all_samples
- if self._check_obey_kkt(i) and self._is_unbound(i)
- ]:
- not_obey = False
- yield from self._choose_a2(i1)
- if not_obey:
- print("all non-bound samples fit the KKT condition!")
- break
- if all_not_obey:
- print("all samples fit the KKT condition! Optimization done!")
- break
- return False
-
- def _choose_a2(self, i1):
- """
- Choose the second alpha by using heuristic algorithm ;steps:
- 1: Choose alpha2 which gets the maximum step size (|E1 - E2|).
- 2: Start in a random point,loop over all non-bound samples till alpha1 and
- alpha2 are optimized.
- 3: Start in a random point,loop over all samples till alpha1 and alpha2 are
- optimized.
- """
- self._unbound = [i for i in self._all_samples if self._is_unbound(i)]
-
- if len(self.unbound) > 0:
- tmp_error = self._error.copy().tolist()
- tmp_error_dict = {
- index: value
- for index, value in enumerate(tmp_error)
- if self._is_unbound(index)
- }
- if self._e(i1) >= 0:
- i2 = min(tmp_error_dict, key=lambda index: tmp_error_dict[index])
- else:
- i2 = max(tmp_error_dict, key=lambda index: tmp_error_dict[index])
- cmd = yield i1, i2
- if cmd is None:
- return
-
- for i2 in np.roll(self.unbound, np.random.choice(self.length)):
- cmd = yield i1, i2
- if cmd is None:
- return
-
- for i2 in np.roll(self._all_samples, np.random.choice(self.length)):
- cmd = yield i1, i2
- if cmd is None:
- return
-
- # Get the new alpha2 and new alpha1
- def _get_new_alpha(self, i1, i2, a1, a2, e1, e2, y1, y2):
- K = self._k
- if i1 == i2:
- return None, None
-
- # calculate L and H which bound the new alpha2
- s = y1 * y2
- if s == -1:
- L, H = max(0.0, a2 - a1), min(self._c, self._c + a2 - a1)
- else:
- L, H = max(0.0, a2 + a1 - self._c), min(self._c, a2 + a1)
- if L == H:
- return None, None
-
- # calculate eta
- k11 = K(i1, i1)
- k22 = K(i2, i2)
- k12 = K(i1, i2)
- eta = k11 + k22 - 2.0 * k12
-
- # select the new alpha2 which could get the minimal objectives
- if eta > 0.0:
- a2_new_unc = a2 + (y2 * (e1 - e2)) / eta
- # a2_new has a boundary
- if a2_new_unc >= H:
- a2_new = H
- elif a2_new_unc <= L:
- a2_new = L
- else:
- a2_new = a2_new_unc
- else:
- b = self._b
- l1 = a1 + s * (a2 - L)
- h1 = a1 + s * (a2 - H)
-
- # way 1
- f1 = y1 * (e1 + b) - a1 * K(i1, i1) - s * a2 * K(i1, i2)
- f2 = y2 * (e2 + b) - a2 * K(i2, i2) - s * a1 * K(i1, i2)
- ol = (
- l1 * f1
- + L * f2
- + 1 / 2 * l1 ** 2 * K(i1, i1)
- + 1 / 2 * L ** 2 * K(i2, i2)
- + s * L * l1 * K(i1, i2)
- )
- oh = (
- h1 * f1
- + H * f2
- + 1 / 2 * h1 ** 2 * K(i1, i1)
- + 1 / 2 * H ** 2 * K(i2, i2)
- + s * H * h1 * K(i1, i2)
- )
- """
- # way 2
- Use objective function check which alpha2 new could get the minimal
- objectives
- """
- if ol < (oh - self._eps):
- a2_new = L
- elif ol > oh + self._eps:
- a2_new = H
- else:
- a2_new = a2
-
- # a1_new has a boundary too
- a1_new = a1 + s * (a2 - a2_new)
- if a1_new < 0:
- a2_new += s * a1_new
- a1_new = 0
- if a1_new > self._c:
- a2_new += s * (a1_new - self._c)
- a1_new = self._c
-
- return a1_new, a2_new
-
- # Normalise data using min_max way
- def _norm(self, data):
- if self._init:
- self._min = np.min(data, axis=0)
- self._max = np.max(data, axis=0)
- self._init = False
- return (data - self._min) / (self._max - self._min)
- else:
- return (data - self._min) / (self._max - self._min)
-
- def _is_unbound(self, index):
- if 0.0 < self.alphas[index] < self._c:
- return True
- else:
- return False
-
- def _is_support(self, index):
- if self.alphas[index] > 0:
- return True
- else:
- return False
-
- @property
- def unbound(self):
- return self._unbound
-
- @property
- def support(self):
- return [i for i in range(self.length) if self._is_support(i)]
-
- @property
- def length(self):
- return self.samples.shape[0]
-
-
-class Kernel:
- def __init__(self, kernel, degree=1.0, coef0=0.0, gamma=1.0):
- self.degree = np.float64(degree)
- self.coef0 = np.float64(coef0)
- self.gamma = np.float64(gamma)
- self._kernel_name = kernel
- self._kernel = self._get_kernel(kernel_name=kernel)
- self._check()
-
- def _polynomial(self, v1, v2):
- return (self.gamma * np.inner(v1, v2) + self.coef0) ** self.degree
-
- def _linear(self, v1, v2):
- return np.inner(v1, v2) + self.coef0
-
- def _rbf(self, v1, v2):
- return np.exp(-1 * (self.gamma * np.linalg.norm(v1 - v2) ** 2))
-
- def _check(self):
- if self._kernel == self._rbf:
- if self.gamma < 0:
- raise ValueError("gamma value must greater than 0")
-
- def _get_kernel(self, kernel_name):
- maps = {"linear": self._linear, "poly": self._polynomial, "rbf": self._rbf}
- return maps[kernel_name]
-
- def __call__(self, v1, v2):
- return self._kernel(v1, v2)
-
- def __repr__(self):
- return self._kernel_name
-
-
-def count_time(func):
- def call_func(*args, **kwargs):
- import time
-
- start_time = time.time()
- func(*args, **kwargs)
- end_time = time.time()
- print(f"smo algorithm cost {end_time - start_time} seconds")
-
- return call_func
-
-
-@count_time
-def test_cancel_data():
- print("Hello!\nStart test svm by smo algorithm!")
- # 0: download dataset and load into pandas' dataframe
- if not os.path.exists(r"cancel_data.csv"):
- request = urllib.request.Request(
- CANCER_DATASET_URL,
- headers={"User-Agent": "Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)"},
- )
- response = urllib.request.urlopen(request)
- content = response.read().decode("utf-8")
- with open(r"cancel_data.csv", "w") as f:
- f.write(content)
-
- data = pd.read_csv(r"cancel_data.csv", header=None)
-
- # 1: pre-processing data
- del data[data.columns.tolist()[0]]
- data = data.dropna(axis=0)
- data = data.replace({"M": np.float64(1), "B": np.float64(-1)})
- samples = np.array(data)[:, :]
-
- # 2: dividing data into train_data data and test_data data
- train_data, test_data = samples[:328, :], samples[328:, :]
- test_tags, test_samples = test_data[:, 0], test_data[:, 1:]
-
- # 3: choose kernel function,and set initial alphas to zero(optional)
- mykernel = Kernel(kernel="rbf", degree=5, coef0=1, gamma=0.5)
- al = np.zeros(train_data.shape[0])
-
- # 4: calculating best alphas using SMO algorithm and predict test_data samples
- mysvm = SmoSVM(
- train=train_data,
- kernel_func=mykernel,
- alpha_list=al,
- cost=0.4,
- b=0.0,
- tolerance=0.001,
- )
- mysvm.fit()
- predict = mysvm.predict(test_samples)
-
- # 5: check accuracy
- score = 0
- test_num = test_tags.shape[0]
- for i in range(test_tags.shape[0]):
- if test_tags[i] == predict[i]:
- score += 1
- print(f"\nall: {test_num}\nright: {score}\nfalse: {test_num - score}")
- print(f"Rough Accuracy: {score / test_tags.shape[0]}")
-
-
-def test_demonstration():
- # change stdout
- print("\nStart plot,please wait!!!")
- sys.stdout = open(os.devnull, "w")
-
- ax1 = plt.subplot2grid((2, 2), (0, 0))
- ax2 = plt.subplot2grid((2, 2), (0, 1))
- ax3 = plt.subplot2grid((2, 2), (1, 0))
- ax4 = plt.subplot2grid((2, 2), (1, 1))
- ax1.set_title("linear svm,cost:0.1")
- test_linear_kernel(ax1, cost=0.1)
- ax2.set_title("linear svm,cost:500")
- test_linear_kernel(ax2, cost=500)
- ax3.set_title("rbf kernel svm,cost:0.1")
- test_rbf_kernel(ax3, cost=0.1)
- ax4.set_title("rbf kernel svm,cost:500")
- test_rbf_kernel(ax4, cost=500)
-
- sys.stdout = sys.__stdout__
- print("Plot done!!!")
-
-
-def test_linear_kernel(ax, cost):
- train_x, train_y = make_blobs(
- n_samples=500, centers=2, n_features=2, random_state=1
- )
- train_y[train_y == 0] = -1
- scaler = StandardScaler()
- train_x_scaled = scaler.fit_transform(train_x, train_y)
- train_data = np.hstack((train_y.reshape(500, 1), train_x_scaled))
- mykernel = Kernel(kernel="linear", degree=5, coef0=1, gamma=0.5)
- mysvm = SmoSVM(
- train=train_data,
- kernel_func=mykernel,
- cost=cost,
- tolerance=0.001,
- auto_norm=False,
- )
- mysvm.fit()
- plot_partition_boundary(mysvm, train_data, ax=ax)
-
-
-def test_rbf_kernel(ax, cost):
- train_x, train_y = make_circles(
- n_samples=500, noise=0.1, factor=0.1, random_state=1
- )
- train_y[train_y == 0] = -1
- scaler = StandardScaler()
- train_x_scaled = scaler.fit_transform(train_x, train_y)
- train_data = np.hstack((train_y.reshape(500, 1), train_x_scaled))
- mykernel = Kernel(kernel="rbf", degree=5, coef0=1, gamma=0.5)
- mysvm = SmoSVM(
- train=train_data,
- kernel_func=mykernel,
- cost=cost,
- tolerance=0.001,
- auto_norm=False,
- )
- mysvm.fit()
- plot_partition_boundary(mysvm, train_data, ax=ax)
-
-
-def plot_partition_boundary(
- model, train_data, ax, resolution=100, colors=("b", "k", "r")
-):
- """
- We can not get the optimum w of our kernel svm model which is different from linear
- svm. For this reason, we generate randomly distributed points with high desity and
- prediced values of these points are calculated by using our tained model. Then we
- could use this prediced values to draw contour map.
- And this contour map can represent svm's partition boundary.
- """
- train_data_x = train_data[:, 1]
- train_data_y = train_data[:, 2]
- train_data_tags = train_data[:, 0]
- xrange = np.linspace(train_data_x.min(), train_data_x.max(), resolution)
- yrange = np.linspace(train_data_y.min(), train_data_y.max(), resolution)
- test_samples = np.array([(x, y) for x in xrange for y in yrange]).reshape(
- resolution * resolution, 2
- )
-
- test_tags = model.predict(test_samples, classify=False)
- grid = test_tags.reshape((len(xrange), len(yrange)))
-
- # Plot contour map which represents the partition boundary
- ax.contour(
- xrange,
- yrange,
- np.mat(grid).T,
- levels=(-1, 0, 1),
- linestyles=("--", "-", "--"),
- linewidths=(1, 1, 1),
- colors=colors,
- )
- # Plot all train samples
- ax.scatter(
- train_data_x,
- train_data_y,
- c=train_data_tags,
- cmap=plt.cm.Dark2,
- lw=0,
- alpha=0.5,
- )
-
- # Plot support vectors
- support = model.support
- ax.scatter(
- train_data_x[support],
- train_data_y[support],
- c=train_data_tags[support],
- cmap=plt.cm.Dark2,
- )
-
-
-if __name__ == "__main__":
- test_cancel_data()
- test_demonstration()
- plt.show()
+"""
+Sequential minimal optimization (SMO) for support vector machines (SVM)
+
+Sequential minimal optimization (SMO) is an algorithm for solving the quadratic
+programming (QP) problem that arises during the training of SVMs. It was invented by
+John Platt in 1998.
+
+Input:
+ 0: type: numpy.ndarray.
+ 1: first column of ndarray must be tags of samples, must be 1 or -1.
+ 2: rows of ndarray represent samples.
+
+Usage:
+ Command:
+ python3 sequential_minimum_optimization.py
+ Code:
+ from sequential_minimum_optimization import SmoSVM, Kernel
+
+ kernel = Kernel(kernel='poly', degree=3., coef0=1., gamma=0.5)
+ init_alphas = np.zeros(train.shape[0])
+ SVM = SmoSVM(train=train, alpha_list=init_alphas, kernel_func=kernel, cost=0.4,
+ b=0.0, tolerance=0.001)
+ SVM.fit()
+ predict = SVM.predict(test_samples)
+
+Reference:
+ https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/smo-book.pdf
+ https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/tr-98-14.pdf
+"""
+
+import os
+import sys
+import urllib.request
+
+import numpy as np
+import pandas as pd
+from matplotlib import pyplot as plt
+from sklearn.datasets import make_blobs, make_circles
+from sklearn.preprocessing import StandardScaler
+
+CANCER_DATASET_URL = (
+ "https://archive.ics.uci.edu/ml/machine-learning-databases/"
+ "breast-cancer-wisconsin/wdbc.data"
+)
+
+
+class SmoSVM:
+ def __init__(
+ self,
+ train,
+ kernel_func,
+ alpha_list=None,
+ cost=0.4,
+ b=0.0,
+ tolerance=0.001,
+ auto_norm=True,
+ ):
+ self._init = True
+ self._auto_norm = auto_norm
+ self._c = np.float64(cost)
+ self._b = np.float64(b)
+ self._tol = np.float64(tolerance) if tolerance > 0.0001 else np.float64(0.001)
+
+ self.tags = train[:, 0]
+ self.samples = self._norm(train[:, 1:]) if self._auto_norm else train[:, 1:]
+ self.alphas = alpha_list if alpha_list is not None else np.zeros(train.shape[0])
+ self.Kernel = kernel_func
+
+ self._eps = 0.001
+ self._all_samples = list(range(self.length))
+ self._K_matrix = self._calculate_k_matrix()
+ self._error = np.zeros(self.length)
+ self._unbound = []
+
+ self.choose_alpha = self._choose_alphas()
+
+ # Calculate alphas using SMO algorithm
+ def fit(self):
+ k = self._k
+ state = None
+ while True:
+ # 1: Find alpha1, alpha2
+ try:
+ i1, i2 = self.choose_alpha.send(state)
+ state = None
+ except StopIteration:
+ print("Optimization done!\nEvery sample satisfy the KKT condition!")
+ break
+
+ # 2: calculate new alpha2 and new alpha1
+ y1, y2 = self.tags[i1], self.tags[i2]
+ a1, a2 = self.alphas[i1].copy(), self.alphas[i2].copy()
+ e1, e2 = self._e(i1), self._e(i2)
+ args = (i1, i2, a1, a2, e1, e2, y1, y2)
+ a1_new, a2_new = self._get_new_alpha(*args)
+ if not a1_new and not a2_new:
+ state = False
+ continue
+ self.alphas[i1], self.alphas[i2] = a1_new, a2_new
+
+ # 3: update threshold(b)
+ b1_new = np.float64(
+ -e1
+ - y1 * k(i1, i1) * (a1_new - a1)
+ - y2 * k(i2, i1) * (a2_new - a2)
+ + self._b
+ )
+ b2_new = np.float64(
+ -e2
+ - y2 * k(i2, i2) * (a2_new - a2)
+ - y1 * k(i1, i2) * (a1_new - a1)
+ + self._b
+ )
+ if 0.0 < a1_new < self._c:
+ b = b1_new
+ if 0.0 < a2_new < self._c:
+ b = b2_new
+ if not (np.float64(0) < a2_new < self._c) and not (
+ np.float64(0) < a1_new < self._c
+ ):
+ b = (b1_new + b2_new) / 2.0
+ b_old = self._b
+ self._b = b
+
+ # 4: update error, here we only calculate the error for non-bound samples
+ self._unbound = [i for i in self._all_samples if self._is_unbound(i)]
+ for s in self.unbound:
+ if s in (i1, i2):
+ continue
+ self._error[s] += (
+ y1 * (a1_new - a1) * k(i1, s)
+ + y2 * (a2_new - a2) * k(i2, s)
+ + (self._b - b_old)
+ )
+
+ # if i1 or i2 is non-bound, update their error value to zero
+ if self._is_unbound(i1):
+ self._error[i1] = 0
+ if self._is_unbound(i2):
+ self._error[i2] = 0
+
+ # Predict test samples
+ def predict(self, test_samples, classify=True):
+ if test_samples.shape[1] > self.samples.shape[1]:
+ raise ValueError(
+ "Test samples' feature length does not equal to that of train samples"
+ )
+
+ if self._auto_norm:
+ test_samples = self._norm(test_samples)
+
+ results = []
+ for test_sample in test_samples:
+ result = self._predict(test_sample)
+ if classify:
+ results.append(1 if result > 0 else -1)
+ else:
+ results.append(result)
+ return np.array(results)
+
+ # Check if alpha violates the KKT condition
+ def _check_obey_kkt(self, index):
+ alphas = self.alphas
+ tol = self._tol
+ r = self._e(index) * self.tags[index]
+ c = self._c
+
+ return (r < -tol and alphas[index] < c) or (r > tol and alphas[index] > 0.0)
+
+ # Get value calculated from kernel function
+ def _k(self, i1, i2):
+ # for test samples, use kernel function
+ if isinstance(i2, np.ndarray):
+ return self.Kernel(self.samples[i1], i2)
+ # for training samples, kernel values have been saved in matrix
+ else:
+ return self._K_matrix[i1, i2]
+
+ # Get error for sample
+ def _e(self, index):
+ """
+ Two cases:
+ 1: Sample[index] is non-bound, fetch error from list: _error
+ 2: sample[index] is bound, use predicted value minus true value: g(xi) - yi
+ """
+ # get from error data
+ if self._is_unbound(index):
+ return self._error[index]
+ # get by g(xi) - yi
+ else:
+ gx = np.dot(self.alphas * self.tags, self._K_matrix[:, index]) + self._b
+ yi = self.tags[index]
+ return gx - yi
+
+ # Calculate kernel matrix of all possible i1, i2, saving time
+ def _calculate_k_matrix(self):
+ k_matrix = np.zeros([self.length, self.length])
+ for i in self._all_samples:
+ for j in self._all_samples:
+ k_matrix[i, j] = np.float64(
+ self.Kernel(self.samples[i, :], self.samples[j, :])
+ )
+ return k_matrix
+
+ # Predict tag for test sample
+ def _predict(self, sample):
+ k = self._k
+ predicted_value = (
+ np.sum(
+ [
+ self.alphas[i1] * self.tags[i1] * k(i1, sample)
+ for i1 in self._all_samples
+ ]
+ )
+ + self._b
+ )
+ return predicted_value
+
+ # Choose alpha1 and alpha2
+ def _choose_alphas(self):
+ loci = yield from self._choose_a1()
+ if not loci:
+ return None
+ return loci
+
+ def _choose_a1(self):
+ """
+ Choose first alpha
+ Steps:
+ 1: First loop over all samples
+ 2: Second loop over all non-bound samples until no non-bound samples violate
+ the KKT condition.
+ 3: Repeat these two processes until no samples violate the KKT condition
+ after the first loop.
+ """
+ while True:
+ all_not_obey = True
+ # all sample
+ print("Scanning all samples!")
+ for i1 in [i for i in self._all_samples if self._check_obey_kkt(i)]:
+ all_not_obey = False
+ yield from self._choose_a2(i1)
+
+ # non-bound sample
+ print("Scanning non-bound samples!")
+ while True:
+ not_obey = True
+ for i1 in [
+ i
+ for i in self._all_samples
+ if self._check_obey_kkt(i) and self._is_unbound(i)
+ ]:
+ not_obey = False
+ yield from self._choose_a2(i1)
+ if not_obey:
+ print("All non-bound samples satisfy the KKT condition!")
+ break
+ if all_not_obey:
+ print("All samples satisfy the KKT condition!")
+ break
+ return False
+
+ def _choose_a2(self, i1):
+ """
+ Choose the second alpha using a heuristic algorithm
+ Steps:
+ 1: Choose alpha2 that maximizes the step size (|E1 - E2|).
+ 2: Start in a random point, loop over all non-bound samples till alpha1 and
+ alpha2 are optimized.
+ 3: Start in a random point, loop over all samples till alpha1 and alpha2 are
+ optimized.
+ """
+ self._unbound = [i for i in self._all_samples if self._is_unbound(i)]
+
+ if len(self.unbound) > 0:
+ tmp_error = self._error.copy().tolist()
+ tmp_error_dict = {
+ index: value
+ for index, value in enumerate(tmp_error)
+ if self._is_unbound(index)
+ }
+ if self._e(i1) >= 0:
+ i2 = min(tmp_error_dict, key=lambda index: tmp_error_dict[index])
+ else:
+ i2 = max(tmp_error_dict, key=lambda index: tmp_error_dict[index])
+ cmd = yield i1, i2
+ if cmd is None:
+ return
+
+ rng = np.random.default_rng()
+ for i2 in np.roll(self.unbound, rng.choice(self.length)):
+ cmd = yield i1, i2
+ if cmd is None:
+ return
+
+ for i2 in np.roll(self._all_samples, rng.choice(self.length)):
+ cmd = yield i1, i2
+ if cmd is None:
+ return
+
+ # Get the new alpha2 and new alpha1
+ def _get_new_alpha(self, i1, i2, a1, a2, e1, e2, y1, y2):
+ k = self._k
+ if i1 == i2:
+ return None, None
+
+ # calculate L and H which bound the new alpha2
+ s = y1 * y2
+ if s == -1:
+ l, h = max(0.0, a2 - a1), min(self._c, self._c + a2 - a1) # noqa: E741
+ else:
+ l, h = max(0.0, a2 + a1 - self._c), min(self._c, a2 + a1) # noqa: E741
+ if l == h:
+ return None, None
+
+ # calculate eta
+ k11 = k(i1, i1)
+ k22 = k(i2, i2)
+ k12 = k(i1, i2)
+
+ # select the new alpha2 which could achieve the minimal objectives
+ if (eta := k11 + k22 - 2.0 * k12) > 0.0:
+ a2_new_unc = a2 + (y2 * (e1 - e2)) / eta
+ # a2_new has a boundary
+ if a2_new_unc >= h:
+ a2_new = h
+ elif a2_new_unc <= l:
+ a2_new = l
+ else:
+ a2_new = a2_new_unc
+ else:
+ b = self._b
+ l1 = a1 + s * (a2 - l)
+ h1 = a1 + s * (a2 - h)
+
+ # Method 1
+ f1 = y1 * (e1 + b) - a1 * k(i1, i1) - s * a2 * k(i1, i2)
+ f2 = y2 * (e2 + b) - a2 * k(i2, i2) - s * a1 * k(i1, i2)
+ ol = (
+ l1 * f1
+ + l * f2
+ + 1 / 2 * l1**2 * k(i1, i1)
+ + 1 / 2 * l**2 * k(i2, i2)
+ + s * l * l1 * k(i1, i2)
+ )
+ oh = (
+ h1 * f1
+ + h * f2
+ + 1 / 2 * h1**2 * k(i1, i1)
+ + 1 / 2 * h**2 * k(i2, i2)
+ + s * h * h1 * k(i1, i2)
+ )
+ """
+ Method 2: Use objective function to check which alpha2_new could achieve the
+ minimal objectives
+ """
+ if ol < (oh - self._eps):
+ a2_new = l
+ elif ol > oh + self._eps:
+ a2_new = h
+ else:
+ a2_new = a2
+
+ # a1_new has a boundary too
+ a1_new = a1 + s * (a2 - a2_new)
+ if a1_new < 0:
+ a2_new += s * a1_new
+ a1_new = 0
+ if a1_new > self._c:
+ a2_new += s * (a1_new - self._c)
+ a1_new = self._c
+
+ return a1_new, a2_new
+
+ # Normalize data using min-max method
+ def _norm(self, data):
+ if self._init:
+ self._min = np.min(data, axis=0)
+ self._max = np.max(data, axis=0)
+ self._init = False
+ return (data - self._min) / (self._max - self._min)
+ else:
+ return (data - self._min) / (self._max - self._min)
+
+ def _is_unbound(self, index):
+ return bool(0.0 < self.alphas[index] < self._c)
+
+ def _is_support(self, index):
+ return bool(self.alphas[index] > 0)
+
+ @property
+ def unbound(self):
+ return self._unbound
+
+ @property
+ def support(self):
+ return [i for i in range(self.length) if self._is_support(i)]
+
+ @property
+ def length(self):
+ return self.samples.shape[0]
+
+
+class Kernel:
+ def __init__(self, kernel, degree=1.0, coef0=0.0, gamma=1.0):
+ self.degree = np.float64(degree)
+ self.coef0 = np.float64(coef0)
+ self.gamma = np.float64(gamma)
+ self._kernel_name = kernel
+ self._kernel = self._get_kernel(kernel_name=kernel)
+ self._check()
+
+ def _polynomial(self, v1, v2):
+ return (self.gamma * np.inner(v1, v2) + self.coef0) ** self.degree
+
+ def _linear(self, v1, v2):
+ return np.inner(v1, v2) + self.coef0
+
+ def _rbf(self, v1, v2):
+ return np.exp(-1 * (self.gamma * np.linalg.norm(v1 - v2) ** 2))
+
+ def _check(self):
+ if self._kernel == self._rbf and self.gamma < 0:
+ raise ValueError("gamma value must be non-negative")
+
+ def _get_kernel(self, kernel_name):
+ maps = {"linear": self._linear, "poly": self._polynomial, "rbf": self._rbf}
+ return maps[kernel_name]
+
+ def __call__(self, v1, v2):
+ return self._kernel(v1, v2)
+
+ def __repr__(self):
+ return self._kernel_name
+
+
+def count_time(func):
+ def call_func(*args, **kwargs):
+ import time
+
+ start_time = time.time()
+ func(*args, **kwargs)
+ end_time = time.time()
+ print(f"SMO algorithm cost {end_time - start_time} seconds")
+
+ return call_func
+
+
+@count_time
+def test_cancer_data():
+ print("Hello!\nStart test SVM using the SMO algorithm!")
+ # 0: download dataset and load into pandas' dataframe
+ if not os.path.exists(r"cancer_data.csv"):
+ request = urllib.request.Request( # noqa: S310
+ CANCER_DATASET_URL,
+ headers={"User-Agent": "Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)"},
+ )
+ response = urllib.request.urlopen(request) # noqa: S310
+ content = response.read().decode("utf-8")
+ with open(r"cancer_data.csv", "w") as f:
+ f.write(content)
+
+ data = pd.read_csv(
+ "cancer_data.csv",
+ header=None,
+ dtype={0: str}, # Assuming the first column contains string data
+ )
+
+ # 1: pre-processing data
+ del data[data.columns.tolist()[0]]
+ data = data.dropna(axis=0)
+ data = data.replace({"M": np.float64(1), "B": np.float64(-1)})
+ samples = np.array(data)[:, :]
+
+ # 2: dividing data into train_data data and test_data data
+ train_data, test_data = samples[:328, :], samples[328:, :]
+ test_tags, test_samples = test_data[:, 0], test_data[:, 1:]
+
+ # 3: choose kernel function, and set initial alphas to zero (optional)
+ my_kernel = Kernel(kernel="rbf", degree=5, coef0=1, gamma=0.5)
+ al = np.zeros(train_data.shape[0])
+
+ # 4: calculating best alphas using SMO algorithm and predict test_data samples
+ mysvm = SmoSVM(
+ train=train_data,
+ kernel_func=my_kernel,
+ alpha_list=al,
+ cost=0.4,
+ b=0.0,
+ tolerance=0.001,
+ )
+ mysvm.fit()
+ predict = mysvm.predict(test_samples)
+
+ # 5: check accuracy
+ score = 0
+ test_num = test_tags.shape[0]
+ for i in range(test_tags.shape[0]):
+ if test_tags[i] == predict[i]:
+ score += 1
+ print(f"\nAll: {test_num}\nCorrect: {score}\nIncorrect: {test_num - score}")
+ print(f"Rough Accuracy: {score / test_tags.shape[0]}")
+
+
+def test_demonstration():
+ # change stdout
+ print("\nStarting plot, please wait!")
+ sys.stdout = open(os.devnull, "w")
+
+ ax1 = plt.subplot2grid((2, 2), (0, 0))
+ ax2 = plt.subplot2grid((2, 2), (0, 1))
+ ax3 = plt.subplot2grid((2, 2), (1, 0))
+ ax4 = plt.subplot2grid((2, 2), (1, 1))
+ ax1.set_title("Linear SVM, cost = 0.1")
+ test_linear_kernel(ax1, cost=0.1)
+ ax2.set_title("Linear SVM, cost = 500")
+ test_linear_kernel(ax2, cost=500)
+ ax3.set_title("RBF kernel SVM, cost = 0.1")
+ test_rbf_kernel(ax3, cost=0.1)
+ ax4.set_title("RBF kernel SVM, cost = 500")
+ test_rbf_kernel(ax4, cost=500)
+
+ sys.stdout = sys.__stdout__
+ print("Plot done!")
+
+
+def test_linear_kernel(ax, cost):
+ train_x, train_y = make_blobs(
+ n_samples=500, centers=2, n_features=2, random_state=1
+ )
+ train_y[train_y == 0] = -1
+ scaler = StandardScaler()
+ train_x_scaled = scaler.fit_transform(train_x, train_y)
+ train_data = np.hstack((train_y.reshape(500, 1), train_x_scaled))
+ my_kernel = Kernel(kernel="linear", degree=5, coef0=1, gamma=0.5)
+ mysvm = SmoSVM(
+ train=train_data,
+ kernel_func=my_kernel,
+ cost=cost,
+ tolerance=0.001,
+ auto_norm=False,
+ )
+ mysvm.fit()
+ plot_partition_boundary(mysvm, train_data, ax=ax)
+
+
+def test_rbf_kernel(ax, cost):
+ train_x, train_y = make_circles(
+ n_samples=500, noise=0.1, factor=0.1, random_state=1
+ )
+ train_y[train_y == 0] = -1
+ scaler = StandardScaler()
+ train_x_scaled = scaler.fit_transform(train_x, train_y)
+ train_data = np.hstack((train_y.reshape(500, 1), train_x_scaled))
+ my_kernel = Kernel(kernel="rbf", degree=5, coef0=1, gamma=0.5)
+ mysvm = SmoSVM(
+ train=train_data,
+ kernel_func=my_kernel,
+ cost=cost,
+ tolerance=0.001,
+ auto_norm=False,
+ )
+ mysvm.fit()
+ plot_partition_boundary(mysvm, train_data, ax=ax)
+
+
+def plot_partition_boundary(
+ model, train_data, ax, resolution=100, colors=("b", "k", "r")
+):
+ """
+ We cannot get the optimal w of our kernel SVM model, which is different from a
+ linear SVM. For this reason, we generate randomly distributed points with high
+ density, and predicted values of these points are calculated using our trained
+ model. Then we could use this predicted values to draw contour map, and this contour
+ map represents the SVM's partition boundary.
+ """
+ train_data_x = train_data[:, 1]
+ train_data_y = train_data[:, 2]
+ train_data_tags = train_data[:, 0]
+ xrange = np.linspace(train_data_x.min(), train_data_x.max(), resolution)
+ yrange = np.linspace(train_data_y.min(), train_data_y.max(), resolution)
+ test_samples = np.array([(x, y) for x in xrange for y in yrange]).reshape(
+ resolution * resolution, 2
+ )
+
+ test_tags = model.predict(test_samples, classify=False)
+ grid = test_tags.reshape((len(xrange), len(yrange)))
+
+ # Plot contour map which represents the partition boundary
+ ax.contour(
+ xrange,
+ yrange,
+ np.asmatrix(grid).T,
+ levels=(-1, 0, 1),
+ linestyles=("--", "-", "--"),
+ linewidths=(1, 1, 1),
+ colors=colors,
+ )
+ # Plot all train samples
+ ax.scatter(
+ train_data_x,
+ train_data_y,
+ c=train_data_tags,
+ cmap=plt.cm.Dark2,
+ lw=0,
+ alpha=0.5,
+ )
+
+ # Plot support vectors
+ support = model.support
+ ax.scatter(
+ train_data_x[support],
+ train_data_y[support],
+ c=train_data_tags[support],
+ cmap=plt.cm.Dark2,
+ )
+
+
+if __name__ == "__main__":
+ test_cancer_data()
+ test_demonstration()
+ plt.show()
diff --git a/machine_learning/similarity_search.py b/machine_learning/similarity_search.py
index 6bfb12ed88cb..c8a573796882 100644
--- a/machine_learning/similarity_search.py
+++ b/machine_learning/similarity_search.py
@@ -7,9 +7,13 @@
1. the nearest vector
2. distance between the vector and the nearest vector (float)
"""
+
+from __future__ import annotations
+
import math
import numpy as np
+from numpy.linalg import norm
def euclidean(input_a: np.ndarray, input_b: np.ndarray) -> float:
@@ -30,7 +34,9 @@ def euclidean(input_a: np.ndarray, input_b: np.ndarray) -> float:
return math.sqrt(sum(pow(a - b, 2) for a, b in zip(input_a, input_b)))
-def similarity_search(dataset: np.ndarray, value_array: np.ndarray) -> list:
+def similarity_search(
+ dataset: np.ndarray, value_array: np.ndarray
+) -> list[list[list[float] | float]]:
"""
:param dataset: Set containing the vectors. Should be ndarray.
:param value_array: vector/vectors we want to know the nearest vector from dataset.
@@ -66,7 +72,7 @@ def similarity_search(dataset: np.ndarray, value_array: np.ndarray) -> list:
>>> value_array = np.array([1])
>>> similarity_search(dataset, value_array)
Traceback (most recent call last):
- ...
+ ...
ValueError: Wrong input data's dimensions... dataset : 2, value_array : 1
2. If data's shapes are different.
@@ -76,7 +82,7 @@ def similarity_search(dataset: np.ndarray, value_array: np.ndarray) -> list:
>>> value_array = np.array([[0, 0, 0], [0, 0, 1]])
>>> similarity_search(dataset, value_array)
Traceback (most recent call last):
- ...
+ ...
ValueError: Wrong input data's shape... dataset : 2, value_array : 3
3. If data types are different.
@@ -86,32 +92,35 @@ def similarity_search(dataset: np.ndarray, value_array: np.ndarray) -> list:
>>> value_array = np.array([[0, 0], [0, 1]], dtype=np.int32)
>>> similarity_search(dataset, value_array) # doctest: +NORMALIZE_WHITESPACE
Traceback (most recent call last):
- ...
+ ...
TypeError: Input data have different datatype...
dataset : float32, value_array : int32
"""
if dataset.ndim != value_array.ndim:
- raise ValueError(
- f"Wrong input data's dimensions... dataset : {dataset.ndim}, "
- f"value_array : {value_array.ndim}"
+ msg = (
+ "Wrong input data's dimensions... "
+ f"dataset : {dataset.ndim}, value_array : {value_array.ndim}"
)
+ raise ValueError(msg)
try:
if dataset.shape[1] != value_array.shape[1]:
- raise ValueError(
- f"Wrong input data's shape... dataset : {dataset.shape[1]}, "
- f"value_array : {value_array.shape[1]}"
+ msg = (
+ "Wrong input data's shape... "
+ f"dataset : {dataset.shape[1]}, value_array : {value_array.shape[1]}"
)
+ raise ValueError(msg)
except IndexError:
if dataset.ndim != value_array.ndim:
raise TypeError("Wrong shape")
if dataset.dtype != value_array.dtype:
- raise TypeError(
- f"Input data have different datatype... dataset : {dataset.dtype}, "
- f"value_array : {value_array.dtype}"
+ msg = (
+ "Input data have different datatype... "
+ f"dataset : {dataset.dtype}, value_array : {value_array.dtype}"
)
+ raise TypeError(msg)
answer = []
@@ -131,6 +140,22 @@ def similarity_search(dataset: np.ndarray, value_array: np.ndarray) -> list:
return answer
+def cosine_similarity(input_a: np.ndarray, input_b: np.ndarray) -> float:
+ """
+ Calculates cosine similarity between two data.
+ :param input_a: ndarray of first vector.
+ :param input_b: ndarray of second vector.
+ :return: Cosine similarity of input_a and input_b. By using math.sqrt(),
+ result will be float.
+
+ >>> cosine_similarity(np.array([1]), np.array([1]))
+ 1.0
+ >>> cosine_similarity(np.array([1, 2]), np.array([6, 32]))
+ 0.9615239476408232
+ """
+ return float(np.dot(input_a, input_b) / (norm(input_a) * norm(input_b)))
+
+
if __name__ == "__main__":
import doctest
diff --git a/machine_learning/support_vector_machines.py b/machine_learning/support_vector_machines.py
index c5e5085d8748..d17c9044a3e9 100644
--- a/machine_learning/support_vector_machines.py
+++ b/machine_learning/support_vector_machines.py
@@ -1,55 +1,203 @@
-from sklearn import svm
-from sklearn.datasets import load_iris
-from sklearn.model_selection import train_test_split
+import numpy as np
+from numpy import ndarray
+from scipy.optimize import Bounds, LinearConstraint, minimize
-# different functions implementing different types of SVM's
-def NuSVC(train_x, train_y):
- svc_NuSVC = svm.NuSVC()
- svc_NuSVC.fit(train_x, train_y)
- return svc_NuSVC
-
+def norm_squared(vector: ndarray) -> float:
+ """
+ Return the squared second norm of vector
+ norm_squared(v) = sum(x * x for x in v)
-def Linearsvc(train_x, train_y):
- svc_linear = svm.LinearSVC(tol=10e-2)
- svc_linear.fit(train_x, train_y)
- return svc_linear
+ Args:
+ vector (ndarray): input vector
+ Returns:
+ float: squared second norm of vector
-def SVC(train_x, train_y):
- # svm.SVC(C=1.0, kernel='rbf', degree=3, gamma=0.0, coef0=0.0, shrinking=True,
- # probability=False,tol=0.001, cache_size=200, class_weight=None, verbose=False,
- # max_iter=1000, random_state=None)
- # various parameters like "kernel","gamma","C" can effectively tuned for a given
- # machine learning model.
- SVC = svm.SVC(gamma="auto")
- SVC.fit(train_x, train_y)
- return SVC
+ >>> int(norm_squared([1, 2]))
+ 5
+ >>> int(norm_squared(np.asarray([1, 2])))
+ 5
+ >>> int(norm_squared([0, 0]))
+ 0
+ """
+ return np.dot(vector, vector)
-def test(X_new):
+class SVC:
"""
- 3 test cases to be passed
- an array containing the sepal length (cm), sepal width (cm), petal length (cm),
- petal width (cm) based on which the target name will be predicted
- >>> test([1,2,1,4])
- 'virginica'
- >>> test([5, 2, 4, 1])
- 'versicolor'
- >>> test([6,3,4,1])
- 'versicolor'
+ Support Vector Classifier
+
+ Args:
+ kernel (str): kernel to use. Default: linear
+ Possible choices:
+ - linear
+ regularization: constraint for soft margin (data not linearly separable)
+ Default: unbound
+
+ >>> SVC(kernel="asdf")
+ Traceback (most recent call last):
+ ...
+ ValueError: Unknown kernel: asdf
+
+ >>> SVC(kernel="rbf")
+ Traceback (most recent call last):
+ ...
+ ValueError: rbf kernel requires gamma
+
+ >>> SVC(kernel="rbf", gamma=-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: gamma must be > 0
"""
- iris = load_iris()
- # splitting the dataset to test and train
- train_x, test_x, train_y, test_y = train_test_split(
- iris["data"], iris["target"], random_state=4
- )
- # any of the 3 types of SVM can be used
- # current_model=SVC(train_x, train_y)
- # current_model=NuSVC(train_x, train_y)
- current_model = Linearsvc(train_x, train_y)
- prediction = current_model.predict([X_new])
- return iris["target_names"][prediction][0]
+
+ def __init__(
+ self,
+ *,
+ regularization: float = np.inf,
+ kernel: str = "linear",
+ gamma: float = 0.0,
+ ) -> None:
+ self.regularization = regularization
+ self.gamma = gamma
+ if kernel == "linear":
+ self.kernel = self.__linear
+ elif kernel == "rbf":
+ if self.gamma == 0:
+ raise ValueError("rbf kernel requires gamma")
+ if not isinstance(self.gamma, (float, int)):
+ raise ValueError("gamma must be float or int")
+ if not self.gamma > 0:
+ raise ValueError("gamma must be > 0")
+ self.kernel = self.__rbf
+ # in the future, there could be a default value like in sklearn
+ # sklear: def_gamma = 1/(n_features * X.var()) (wiki)
+ # previously it was 1/(n_features)
+ else:
+ msg = f"Unknown kernel: {kernel}"
+ raise ValueError(msg)
+
+ # kernels
+ def __linear(self, vector1: ndarray, vector2: ndarray) -> float:
+ """Linear kernel (as if no kernel used at all)"""
+ return np.dot(vector1, vector2)
+
+ def __rbf(self, vector1: ndarray, vector2: ndarray) -> float:
+ """
+ RBF: Radial Basis Function Kernel
+
+ Note: for more information see:
+ https://en.wikipedia.org/wiki/Radial_basis_function_kernel
+
+ Args:
+ vector1 (ndarray): first vector
+ vector2 (ndarray): second vector)
+
+ Returns:
+ float: exp(-(gamma * norm_squared(vector1 - vector2)))
+ """
+ return np.exp(-(self.gamma * norm_squared(vector1 - vector2)))
+
+ def fit(self, observations: list[ndarray], classes: ndarray) -> None:
+ """
+ Fits the SVC with a set of observations.
+
+ Args:
+ observations (list[ndarray]): list of observations
+ classes (ndarray): classification of each observation (in {1, -1})
+ """
+
+ self.observations = observations
+ self.classes = classes
+
+ # using Wolfe's Dual to calculate w.
+ # Primal problem: minimize 1/2*norm_squared(w)
+ # constraint: yn(w . xn + b) >= 1
+ #
+ # With l a vector
+ # Dual problem: maximize sum_n(ln) -
+ # 1/2 * sum_n(sum_m(ln*lm*yn*ym*xn . xm))
+ # constraint: self.C >= ln >= 0
+ # and sum_n(ln*yn) = 0
+ # Then we get w using w = sum_n(ln*yn*xn)
+ # At the end we can get b ~= mean(yn - w . xn)
+ #
+ # Since we use kernels, we only need l_star to calculate b
+ # and to classify observations
+
+ (n,) = np.shape(classes)
+
+ def to_minimize(candidate: ndarray) -> float:
+ """
+ Opposite of the function to maximize
+
+ Args:
+ candidate (ndarray): candidate array to test
+
+ Return:
+ float: Wolfe's Dual result to minimize
+ """
+ s = 0
+ (n,) = np.shape(candidate)
+ for i in range(n):
+ for j in range(n):
+ s += (
+ candidate[i]
+ * candidate[j]
+ * classes[i]
+ * classes[j]
+ * self.kernel(observations[i], observations[j])
+ )
+ return 1 / 2 * s - sum(candidate)
+
+ ly_contraint = LinearConstraint(classes, 0, 0)
+ l_bounds = Bounds(0, self.regularization)
+
+ l_star = minimize(
+ to_minimize, np.ones(n), bounds=l_bounds, constraints=[ly_contraint]
+ ).x
+ self.optimum = l_star
+
+ # calculating mean offset of separation plane to points
+ s = 0
+ for i in range(n):
+ for j in range(n):
+ s += classes[i] - classes[i] * self.optimum[i] * self.kernel(
+ observations[i], observations[j]
+ )
+ self.offset = s / n
+
+ def predict(self, observation: ndarray) -> int:
+ """
+ Get the expected class of an observation
+
+ Args:
+ observation (Vector): observation
+
+ Returns:
+ int {1, -1}: expected class
+
+ >>> xs = [
+ ... np.asarray([0, 1]), np.asarray([0, 2]),
+ ... np.asarray([1, 1]), np.asarray([1, 2])
+ ... ]
+ >>> y = np.asarray([1, 1, -1, -1])
+ >>> s = SVC()
+ >>> s.fit(xs, y)
+ >>> s.predict(np.asarray([0, 1]))
+ 1
+ >>> s.predict(np.asarray([1, 1]))
+ -1
+ >>> s.predict(np.asarray([2, 2]))
+ -1
+ """
+ s = sum(
+ self.optimum[n]
+ * self.classes[n]
+ * self.kernel(self.observations[n], observation)
+ for n in range(len(self.classes))
+ )
+ return 1 if s + self.offset >= 0 else -1
if __name__ == "__main__":
diff --git a/machine_learning/word_frequency_functions.py b/machine_learning/word_frequency_functions.py
index 9cf7b694c6be..8fd2741f611c 100644
--- a/machine_learning/word_frequency_functions.py
+++ b/machine_learning/word_frequency_functions.py
@@ -61,7 +61,7 @@ def term_frequency(term: str, document: str) -> int:
return len([word for word in tokenize_document if word.lower() == term.lower()])
-def document_frequency(term: str, corpus: str) -> int:
+def document_frequency(term: str, corpus: str) -> tuple[int, int]:
"""
Calculate the number of documents in a corpus that contain a
given term
@@ -83,7 +83,7 @@ def document_frequency(term: str, corpus: str) -> int:
return (len([doc for doc in docs if term in doc]), len(docs))
-def inverse_document_frequency(df: int, N: int, smoothing=False) -> float:
+def inverse_document_frequency(df: int, n: int, smoothing=False) -> float:
"""
Return an integer denoting the importance
of a word. This measure of importance is
@@ -109,15 +109,15 @@ def inverse_document_frequency(df: int, N: int, smoothing=False) -> float:
1.477
"""
if smoothing:
- if N == 0:
+ if n == 0:
raise ValueError("log10(0) is undefined.")
- return round(1 + log10(N / (1 + df)), 3)
+ return round(1 + log10(n / (1 + df)), 3)
if df == 0:
raise ZeroDivisionError("df must be > 0")
- elif N == 0:
+ elif n == 0:
raise ValueError("log10(0) is undefined.")
- return round(log10(N / df), 3)
+ return round(log10(n / df), 3)
def tf_idf(tf: int, idf: int) -> float:
diff --git a/machine_learning/xgboost_classifier.py b/machine_learning/xgboost_classifier.py
new file mode 100644
index 000000000000..1da933cf690f
--- /dev/null
+++ b/machine_learning/xgboost_classifier.py
@@ -0,0 +1,81 @@
+# XGBoost Classifier Example
+import numpy as np
+from matplotlib import pyplot as plt
+from sklearn.datasets import load_iris
+from sklearn.metrics import ConfusionMatrixDisplay
+from sklearn.model_selection import train_test_split
+from xgboost import XGBClassifier
+
+
+def data_handling(data: dict) -> tuple:
+ # Split dataset into features and target
+ # data is features
+ """
+ >>> data_handling(({'data':'[5.1, 3.5, 1.4, 0.2]','target':([0])}))
+ ('[5.1, 3.5, 1.4, 0.2]', [0])
+ >>> data_handling(
+ ... {'data': '[4.9, 3.0, 1.4, 0.2], [4.7, 3.2, 1.3, 0.2]', 'target': ([0, 0])}
+ ... )
+ ('[4.9, 3.0, 1.4, 0.2], [4.7, 3.2, 1.3, 0.2]', [0, 0])
+ """
+ return (data["data"], data["target"])
+
+
+def xgboost(features: np.ndarray, target: np.ndarray) -> XGBClassifier:
+ """
+ # THIS TEST IS BROKEN!! >>> xgboost(np.array([[5.1, 3.6, 1.4, 0.2]]), np.array([0]))
+ XGBClassifier(base_score=0.5, booster='gbtree', callbacks=None,
+ colsample_bylevel=1, colsample_bynode=1, colsample_bytree=1,
+ early_stopping_rounds=None, enable_categorical=False,
+ eval_metric=None, gamma=0, gpu_id=-1, grow_policy='depthwise',
+ importance_type=None, interaction_constraints='',
+ learning_rate=0.300000012, max_bin=256, max_cat_to_onehot=4,
+ max_delta_step=0, max_depth=6, max_leaves=0, min_child_weight=1,
+ missing=nan, monotone_constraints='()', n_estimators=100,
+ n_jobs=0, num_parallel_tree=1, predictor='auto', random_state=0,
+ reg_alpha=0, reg_lambda=1, ...)
+ """
+ classifier = XGBClassifier()
+ classifier.fit(features, target)
+ return classifier
+
+
+def main() -> None:
+ """
+ >>> main()
+
+ Url for the algorithm:
+ https://xgboost.readthedocs.io/en/stable/
+ Iris type dataset is used to demonstrate algorithm.
+ """
+
+ # Load Iris dataset
+ iris = load_iris()
+ features, targets = data_handling(iris)
+ x_train, x_test, y_train, y_test = train_test_split(
+ features, targets, test_size=0.25
+ )
+
+ names = iris["target_names"]
+
+ # Create an XGBoost Classifier from the training data
+ xgboost_classifier = xgboost(x_train, y_train)
+
+ # Display the confusion matrix of the classifier with both training and test sets
+ ConfusionMatrixDisplay.from_estimator(
+ xgboost_classifier,
+ x_test,
+ y_test,
+ display_labels=names,
+ cmap="Blues",
+ normalize="true",
+ )
+ plt.title("Normalized Confusion Matrix - IRIS Dataset")
+ plt.show()
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod(verbose=True)
+ main()
diff --git a/machine_learning/xgboost_regressor.py b/machine_learning/xgboost_regressor.py
new file mode 100644
index 000000000000..52e041c55ea2
--- /dev/null
+++ b/machine_learning/xgboost_regressor.py
@@ -0,0 +1,66 @@
+# XGBoost Regressor Example
+import numpy as np
+from sklearn.datasets import fetch_california_housing
+from sklearn.metrics import mean_absolute_error, mean_squared_error
+from sklearn.model_selection import train_test_split
+from xgboost import XGBRegressor
+
+
+def data_handling(data: dict) -> tuple:
+ # Split dataset into features and target. Data is features.
+ """
+ >>> data_handling((
+ ... {'data':'[ 8.3252 41. 6.9841269 1.02380952 322. 2.55555556 37.88 -122.23 ]'
+ ... ,'target':([4.526])}))
+ ('[ 8.3252 41. 6.9841269 1.02380952 322. 2.55555556 37.88 -122.23 ]', [4.526])
+ """
+ return (data["data"], data["target"])
+
+
+def xgboost(
+ features: np.ndarray, target: np.ndarray, test_features: np.ndarray
+) -> np.ndarray:
+ """
+ >>> xgboost(np.array([[ 2.3571 , 52. , 6.00813008, 1.06775068,
+ ... 907. , 2.45799458, 40.58 , -124.26]]),np.array([1.114]),
+ ... np.array([[1.97840000e+00, 3.70000000e+01, 4.98858447e+00, 1.03881279e+00,
+ ... 1.14300000e+03, 2.60958904e+00, 3.67800000e+01, -1.19780000e+02]]))
+ array([[1.1139996]], dtype=float32)
+ """
+ xgb = XGBRegressor(
+ verbosity=0, random_state=42, tree_method="exact", base_score=0.5
+ )
+ xgb.fit(features, target)
+ # Predict target for test data
+ predictions = xgb.predict(test_features)
+ predictions = predictions.reshape(len(predictions), 1)
+ return predictions
+
+
+def main() -> None:
+ """
+ The URL for this algorithm
+ https://xgboost.readthedocs.io/en/stable/
+ California house price dataset is used to demonstrate the algorithm.
+
+ Expected error values:
+ Mean Absolute Error: 0.30957163379906033
+ Mean Square Error: 0.22611560196662744
+ """
+ # Load California house price dataset
+ california = fetch_california_housing()
+ data, target = data_handling(california)
+ x_train, x_test, y_train, y_test = train_test_split(
+ data, target, test_size=0.25, random_state=1
+ )
+ predictions = xgboost(x_train, y_train, x_test)
+ # Error printing
+ print(f"Mean Absolute Error: {mean_absolute_error(y_test, predictions)}")
+ print(f"Mean Square Error: {mean_squared_error(y_test, predictions)}")
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod(verbose=True)
+ main()
diff --git a/maths/3n_plus_1.py b/maths/3n_plus_1.py
deleted file mode 100644
index 28c9fd7b426f..000000000000
--- a/maths/3n_plus_1.py
+++ /dev/null
@@ -1,149 +0,0 @@
-from __future__ import annotations
-
-
-def n31(a: int) -> tuple[list[int], int]:
- """
- Returns the Collatz sequence and its length of any positive integer.
- >>> n31(4)
- ([4, 2, 1], 3)
- """
-
- if not isinstance(a, int):
- raise TypeError("Must be int, not {}".format(type(a).__name__))
- if a < 1:
- raise ValueError(f"Given integer must be greater than 1, not {a}")
-
- path = [a]
- while a != 1:
- if a % 2 == 0:
- a = a // 2
- else:
- a = 3 * a + 1
- path += [a]
- return path, len(path)
-
-
-def test_n31():
- """
- >>> test_n31()
- """
- assert n31(4) == ([4, 2, 1], 3)
- assert n31(11) == ([11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1], 15)
- assert n31(31) == (
- [
- 31,
- 94,
- 47,
- 142,
- 71,
- 214,
- 107,
- 322,
- 161,
- 484,
- 242,
- 121,
- 364,
- 182,
- 91,
- 274,
- 137,
- 412,
- 206,
- 103,
- 310,
- 155,
- 466,
- 233,
- 700,
- 350,
- 175,
- 526,
- 263,
- 790,
- 395,
- 1186,
- 593,
- 1780,
- 890,
- 445,
- 1336,
- 668,
- 334,
- 167,
- 502,
- 251,
- 754,
- 377,
- 1132,
- 566,
- 283,
- 850,
- 425,
- 1276,
- 638,
- 319,
- 958,
- 479,
- 1438,
- 719,
- 2158,
- 1079,
- 3238,
- 1619,
- 4858,
- 2429,
- 7288,
- 3644,
- 1822,
- 911,
- 2734,
- 1367,
- 4102,
- 2051,
- 6154,
- 3077,
- 9232,
- 4616,
- 2308,
- 1154,
- 577,
- 1732,
- 866,
- 433,
- 1300,
- 650,
- 325,
- 976,
- 488,
- 244,
- 122,
- 61,
- 184,
- 92,
- 46,
- 23,
- 70,
- 35,
- 106,
- 53,
- 160,
- 80,
- 40,
- 20,
- 10,
- 5,
- 16,
- 8,
- 4,
- 2,
- 1,
- ],
- 107,
- )
-
-
-if __name__ == "__main__":
- num = 4
- path, length = n31(num)
- print(f"The Collatz sequence of {num} took {length} steps. \nPath: {path}")
diff --git a/maths/abs.py b/maths/abs.py
index 68c99a1d51d8..b357e98d8680 100644
--- a/maths/abs.py
+++ b/maths/abs.py
@@ -1,7 +1,7 @@
"""Absolute Value."""
-def abs_val(num):
+def abs_val(num: float) -> float:
"""
Find the absolute value of a number.
@@ -15,14 +15,80 @@ def abs_val(num):
return -num if num < 0 else num
+def abs_min(x: list[int]) -> int:
+ """
+ >>> abs_min([0,5,1,11])
+ 0
+ >>> abs_min([3,-10,-2])
+ -2
+ >>> abs_min([])
+ Traceback (most recent call last):
+ ...
+ ValueError: abs_min() arg is an empty sequence
+ """
+ if len(x) == 0:
+ raise ValueError("abs_min() arg is an empty sequence")
+ j = x[0]
+ for i in x:
+ if abs_val(i) < abs_val(j):
+ j = i
+ return j
+
+
+def abs_max(x: list[int]) -> int:
+ """
+ >>> abs_max([0,5,1,11])
+ 11
+ >>> abs_max([3,-10,-2])
+ -10
+ >>> abs_max([])
+ Traceback (most recent call last):
+ ...
+ ValueError: abs_max() arg is an empty sequence
+ """
+ if len(x) == 0:
+ raise ValueError("abs_max() arg is an empty sequence")
+ j = x[0]
+ for i in x:
+ if abs(i) > abs(j):
+ j = i
+ return j
+
+
+def abs_max_sort(x: list[int]) -> int:
+ """
+ >>> abs_max_sort([0,5,1,11])
+ 11
+ >>> abs_max_sort([3,-10,-2])
+ -10
+ >>> abs_max_sort([])
+ Traceback (most recent call last):
+ ...
+ ValueError: abs_max_sort() arg is an empty sequence
+ """
+ if len(x) == 0:
+ raise ValueError("abs_max_sort() arg is an empty sequence")
+ return sorted(x, key=abs)[-1]
+
+
def test_abs_val():
"""
>>> test_abs_val()
"""
- assert 0 == abs_val(0)
- assert 34 == abs_val(34)
- assert 100000000000 == abs_val(-100000000000)
+ assert abs_val(0) == 0
+ assert abs_val(34) == 34
+ assert abs_val(-100000000000) == 100000000000
+
+ a = [-3, -1, 2, -11]
+ assert abs_max(a) == -11
+ assert abs_max_sort(a) == -11
+ assert abs_min(a) == -1
if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+
+ test_abs_val()
print(abs_val(-34)) # --> 34
diff --git a/maths/abs_max.py b/maths/abs_max.py
deleted file mode 100644
index e5a8219657ac..000000000000
--- a/maths/abs_max.py
+++ /dev/null
@@ -1,35 +0,0 @@
-from __future__ import annotations
-
-
-def abs_max(x: list[int]) -> int:
- """
- >>> abs_max([0,5,1,11])
- 11
- >>> abs_max([3,-10,-2])
- -10
- """
- j = x[0]
- for i in x:
- if abs(i) > abs(j):
- j = i
- return j
-
-
-def abs_max_sort(x):
- """
- >>> abs_max_sort([0,5,1,11])
- 11
- >>> abs_max_sort([3,-10,-2])
- -10
- """
- return sorted(x, key=abs)[-1]
-
-
-def main():
- a = [1, 2, -11]
- assert abs_max(a) == -11
- assert abs_max_sort(a) == -11
-
-
-if __name__ == "__main__":
- main()
diff --git a/maths/abs_min.py b/maths/abs_min.py
deleted file mode 100644
index eb84de37ce23..000000000000
--- a/maths/abs_min.py
+++ /dev/null
@@ -1,24 +0,0 @@
-from .abs import abs_val
-
-
-def absMin(x):
- """
- >>> absMin([0,5,1,11])
- 0
- >>> absMin([3,-10,-2])
- -2
- """
- j = x[0]
- for i in x:
- if abs_val(i) < abs_val(j):
- j = i
- return j
-
-
-def main():
- a = [-3, -1, 2, -11]
- print(absMin(a)) # = -1
-
-
-if __name__ == "__main__":
- main()
diff --git a/maths/add.py b/maths/add.py
deleted file mode 100644
index 0bc7da9697d3..000000000000
--- a/maths/add.py
+++ /dev/null
@@ -1,19 +0,0 @@
-"""
-Just to check
-"""
-
-
-def add(a, b):
- """
- >>> add(2, 2)
- 4
- >>> add(2, -2)
- 0
- """
- return a + b
-
-
-if __name__ == "__main__":
- a = 5
- b = 6
- print(f"The sum of {a} + {b} is {add(a, b)}")
diff --git a/maths/addition_without_arithmetic.py b/maths/addition_without_arithmetic.py
new file mode 100644
index 000000000000..409604e4c08a
--- /dev/null
+++ b/maths/addition_without_arithmetic.py
@@ -0,0 +1,39 @@
+"""
+Illustrate how to add the integer without arithmetic operation
+Author: suraj Kumar
+Time Complexity: 1
+https://en.wikipedia.org/wiki/Bitwise_operation
+"""
+
+
+def add(first: int, second: int) -> int:
+ """
+ Implementation of addition of integer
+
+ Examples:
+ >>> add(3, 5)
+ 8
+ >>> add(13, 5)
+ 18
+ >>> add(-7, 2)
+ -5
+ >>> add(0, -7)
+ -7
+ >>> add(-321, 0)
+ -321
+ """
+ while second != 0:
+ c = first & second
+ first ^= second
+ second = c << 1
+ return first
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+
+ first = int(input("Enter the first number: ").strip())
+ second = int(input("Enter the second number: ").strip())
+ print(f"{add(first, second) = }")
diff --git a/maths/allocation_number.py b/maths/allocation_number.py
index d419e74d01ff..52f1ac4bdb23 100644
--- a/maths/allocation_number.py
+++ b/maths/allocation_number.py
@@ -5,6 +5,7 @@
for i in allocation_list:
requests.get(url,headers={'Range':f'bytes={i}'})
"""
+
from __future__ import annotations
diff --git a/maths/arc_length.py b/maths/arc_length.py
new file mode 100644
index 000000000000..4c518f321dc7
--- /dev/null
+++ b/maths/arc_length.py
@@ -0,0 +1,17 @@
+from math import pi
+
+
+def arc_length(angle: int, radius: int) -> float:
+ """
+ >>> arc_length(45, 5)
+ 3.9269908169872414
+ >>> arc_length(120, 15)
+ 31.415926535897928
+ >>> arc_length(90, 10)
+ 15.707963267948966
+ """
+ return 2 * pi * radius * (angle / 360)
+
+
+if __name__ == "__main__":
+ print(arc_length(90, 10))
diff --git a/maths/area.py b/maths/area.py
index 24216e223ebf..31a654206977 100644
--- a/maths/area.py
+++ b/maths/area.py
@@ -1,7 +1,9 @@
"""
Find the area of various geometric shapes
+Wikipedia reference: https://en.wikipedia.org/wiki/Area
"""
-from math import pi
+
+from math import pi, sqrt, tan
def surface_area_cube(side_length: float) -> float:
@@ -10,6 +12,10 @@ def surface_area_cube(side_length: float) -> float:
>>> surface_area_cube(1)
6
+ >>> surface_area_cube(1.6)
+ 15.360000000000003
+ >>> surface_area_cube(0)
+ 0
>>> surface_area_cube(3)
54
>>> surface_area_cube(-1)
@@ -19,19 +25,51 @@ def surface_area_cube(side_length: float) -> float:
"""
if side_length < 0:
raise ValueError("surface_area_cube() only accepts non-negative values")
- return 6 * side_length ** 2
+ return 6 * side_length**2
+
+
+def surface_area_cuboid(length: float, breadth: float, height: float) -> float:
+ """
+ Calculate the Surface Area of a Cuboid.
+
+ >>> surface_area_cuboid(1, 2, 3)
+ 22
+ >>> surface_area_cuboid(0, 0, 0)
+ 0
+ >>> surface_area_cuboid(1.6, 2.6, 3.6)
+ 38.56
+ >>> surface_area_cuboid(-1, 2, 3)
+ Traceback (most recent call last):
+ ...
+ ValueError: surface_area_cuboid() only accepts non-negative values
+ >>> surface_area_cuboid(1, -2, 3)
+ Traceback (most recent call last):
+ ...
+ ValueError: surface_area_cuboid() only accepts non-negative values
+ >>> surface_area_cuboid(1, 2, -3)
+ Traceback (most recent call last):
+ ...
+ ValueError: surface_area_cuboid() only accepts non-negative values
+ """
+ if length < 0 or breadth < 0 or height < 0:
+ raise ValueError("surface_area_cuboid() only accepts non-negative values")
+ return 2 * ((length * breadth) + (breadth * height) + (length * height))
def surface_area_sphere(radius: float) -> float:
"""
Calculate the Surface Area of a Sphere.
Wikipedia reference: https://en.wikipedia.org/wiki/Sphere
- :return 4 * pi * r^2
+ Formula: 4 * pi * r^2
>>> surface_area_sphere(5)
314.1592653589793
>>> surface_area_sphere(1)
12.566370614359172
+ >>> surface_area_sphere(1.6)
+ 32.169908772759484
+ >>> surface_area_sphere(0)
+ 0.0
>>> surface_area_sphere(-1)
Traceback (most recent call last):
...
@@ -39,15 +77,175 @@ def surface_area_sphere(radius: float) -> float:
"""
if radius < 0:
raise ValueError("surface_area_sphere() only accepts non-negative values")
- return 4 * pi * radius ** 2
+ return 4 * pi * radius**2
+
+
+def surface_area_hemisphere(radius: float) -> float:
+ """
+ Calculate the Surface Area of a Hemisphere.
+ Formula: 3 * pi * r^2
+
+ >>> surface_area_hemisphere(5)
+ 235.61944901923448
+ >>> surface_area_hemisphere(1)
+ 9.42477796076938
+ >>> surface_area_hemisphere(0)
+ 0.0
+ >>> surface_area_hemisphere(1.1)
+ 11.40398133253095
+ >>> surface_area_hemisphere(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: surface_area_hemisphere() only accepts non-negative values
+ """
+ if radius < 0:
+ raise ValueError("surface_area_hemisphere() only accepts non-negative values")
+ return 3 * pi * radius**2
+
+
+def surface_area_cone(radius: float, height: float) -> float:
+ """
+ Calculate the Surface Area of a Cone.
+ Wikipedia reference: https://en.wikipedia.org/wiki/Cone
+ Formula: pi * r * (r + (h ** 2 + r ** 2) ** 0.5)
+
+ >>> surface_area_cone(10, 24)
+ 1130.9733552923256
+ >>> surface_area_cone(6, 8)
+ 301.59289474462014
+ >>> surface_area_cone(1.6, 2.6)
+ 23.387862992395807
+ >>> surface_area_cone(0, 0)
+ 0.0
+ >>> surface_area_cone(-1, -2)
+ Traceback (most recent call last):
+ ...
+ ValueError: surface_area_cone() only accepts non-negative values
+ >>> surface_area_cone(1, -2)
+ Traceback (most recent call last):
+ ...
+ ValueError: surface_area_cone() only accepts non-negative values
+ >>> surface_area_cone(-1, 2)
+ Traceback (most recent call last):
+ ...
+ ValueError: surface_area_cone() only accepts non-negative values
+ """
+ if radius < 0 or height < 0:
+ raise ValueError("surface_area_cone() only accepts non-negative values")
+ return pi * radius * (radius + (height**2 + radius**2) ** 0.5)
+
+
+def surface_area_conical_frustum(
+ radius_1: float, radius_2: float, height: float
+) -> float:
+ """
+ Calculate the Surface Area of a Conical Frustum.
+
+ >>> surface_area_conical_frustum(1, 2, 3)
+ 45.511728065337266
+ >>> surface_area_conical_frustum(4, 5, 6)
+ 300.7913575056268
+ >>> surface_area_conical_frustum(0, 0, 0)
+ 0.0
+ >>> surface_area_conical_frustum(1.6, 2.6, 3.6)
+ 78.57907060751548
+ >>> surface_area_conical_frustum(-1, 2, 3)
+ Traceback (most recent call last):
+ ...
+ ValueError: surface_area_conical_frustum() only accepts non-negative values
+ >>> surface_area_conical_frustum(1, -2, 3)
+ Traceback (most recent call last):
+ ...
+ ValueError: surface_area_conical_frustum() only accepts non-negative values
+ >>> surface_area_conical_frustum(1, 2, -3)
+ Traceback (most recent call last):
+ ...
+ ValueError: surface_area_conical_frustum() only accepts non-negative values
+ """
+ if radius_1 < 0 or radius_2 < 0 or height < 0:
+ raise ValueError(
+ "surface_area_conical_frustum() only accepts non-negative values"
+ )
+ slant_height = (height**2 + (radius_1 - radius_2) ** 2) ** 0.5
+ return pi * ((slant_height * (radius_1 + radius_2)) + radius_1**2 + radius_2**2)
+
+
+def surface_area_cylinder(radius: float, height: float) -> float:
+ """
+ Calculate the Surface Area of a Cylinder.
+ Wikipedia reference: https://en.wikipedia.org/wiki/Cylinder
+ Formula: 2 * pi * r * (h + r)
+
+ >>> surface_area_cylinder(7, 10)
+ 747.6990515543707
+ >>> surface_area_cylinder(1.6, 2.6)
+ 42.22300526424682
+ >>> surface_area_cylinder(0, 0)
+ 0.0
+ >>> surface_area_cylinder(6, 8)
+ 527.7875658030853
+ >>> surface_area_cylinder(-1, -2)
+ Traceback (most recent call last):
+ ...
+ ValueError: surface_area_cylinder() only accepts non-negative values
+ >>> surface_area_cylinder(1, -2)
+ Traceback (most recent call last):
+ ...
+ ValueError: surface_area_cylinder() only accepts non-negative values
+ >>> surface_area_cylinder(-1, 2)
+ Traceback (most recent call last):
+ ...
+ ValueError: surface_area_cylinder() only accepts non-negative values
+ """
+ if radius < 0 or height < 0:
+ raise ValueError("surface_area_cylinder() only accepts non-negative values")
+ return 2 * pi * radius * (height + radius)
+
+
+def surface_area_torus(torus_radius: float, tube_radius: float) -> float:
+ """Calculate the Area of a Torus.
+ Wikipedia reference: https://en.wikipedia.org/wiki/Torus
+ :return 4pi^2 * torus_radius * tube_radius
+ >>> surface_area_torus(1, 1)
+ 39.47841760435743
+ >>> surface_area_torus(4, 3)
+ 473.7410112522892
+ >>> surface_area_torus(3, 4)
+ Traceback (most recent call last):
+ ...
+ ValueError: surface_area_torus() does not support spindle or self intersecting tori
+ >>> surface_area_torus(1.6, 1.6)
+ 101.06474906715503
+ >>> surface_area_torus(0, 0)
+ 0.0
+ >>> surface_area_torus(-1, 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: surface_area_torus() only accepts non-negative values
+ >>> surface_area_torus(1, -1)
+ Traceback (most recent call last):
+ ...
+ ValueError: surface_area_torus() only accepts non-negative values
+ """
+ if torus_radius < 0 or tube_radius < 0:
+ raise ValueError("surface_area_torus() only accepts non-negative values")
+ if torus_radius < tube_radius:
+ raise ValueError(
+ "surface_area_torus() does not support spindle or self intersecting tori"
+ )
+ return 4 * pow(pi, 2) * torus_radius * tube_radius
def area_rectangle(length: float, width: float) -> float:
"""
- Calculate the area of a rectangle
+ Calculate the area of a rectangle.
>>> area_rectangle(10, 20)
200
+ >>> area_rectangle(1.6, 2.6)
+ 4.16
+ >>> area_rectangle(0, 0)
+ 0
>>> area_rectangle(-1, -2)
Traceback (most recent call last):
...
@@ -68,10 +266,14 @@ def area_rectangle(length: float, width: float) -> float:
def area_square(side_length: float) -> float:
"""
- Calculate the area of a square
+ Calculate the area of a square.
>>> area_square(10)
100
+ >>> area_square(0)
+ 0
+ >>> area_square(1.6)
+ 2.5600000000000005
>>> area_square(-1)
Traceback (most recent call last):
...
@@ -79,15 +281,19 @@ def area_square(side_length: float) -> float:
"""
if side_length < 0:
raise ValueError("area_square() only accepts non-negative values")
- return side_length ** 2
+ return side_length**2
def area_triangle(base: float, height: float) -> float:
"""
- Calculate the area of a triangle
+ Calculate the area of a triangle given the base and height.
>>> area_triangle(10, 10)
50.0
+ >>> area_triangle(1.6, 2.6)
+ 2.08
+ >>> area_triangle(0, 0)
+ 0.0
>>> area_triangle(-1, -2)
Traceback (most recent call last):
...
@@ -106,12 +312,64 @@ def area_triangle(base: float, height: float) -> float:
return (base * height) / 2
+def area_triangle_three_sides(side1: float, side2: float, side3: float) -> float:
+ """
+ Calculate area of triangle when the length of 3 sides are known.
+ This function uses Heron's formula: https://en.wikipedia.org/wiki/Heron%27s_formula
+
+ >>> area_triangle_three_sides(5, 12, 13)
+ 30.0
+ >>> area_triangle_three_sides(10, 11, 12)
+ 51.521233486786784
+ >>> area_triangle_three_sides(0, 0, 0)
+ 0.0
+ >>> area_triangle_three_sides(1.6, 2.6, 3.6)
+ 1.8703742940919619
+ >>> area_triangle_three_sides(-1, -2, -1)
+ Traceback (most recent call last):
+ ...
+ ValueError: area_triangle_three_sides() only accepts non-negative values
+ >>> area_triangle_three_sides(1, -2, 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: area_triangle_three_sides() only accepts non-negative values
+ >>> area_triangle_three_sides(2, 4, 7)
+ Traceback (most recent call last):
+ ...
+ ValueError: Given three sides do not form a triangle
+ >>> area_triangle_three_sides(2, 7, 4)
+ Traceback (most recent call last):
+ ...
+ ValueError: Given three sides do not form a triangle
+ >>> area_triangle_three_sides(7, 2, 4)
+ Traceback (most recent call last):
+ ...
+ ValueError: Given three sides do not form a triangle
+ """
+ if side1 < 0 or side2 < 0 or side3 < 0:
+ raise ValueError("area_triangle_three_sides() only accepts non-negative values")
+ elif side1 + side2 < side3 or side1 + side3 < side2 or side2 + side3 < side1:
+ raise ValueError("Given three sides do not form a triangle")
+ semi_perimeter = (side1 + side2 + side3) / 2
+ area = sqrt(
+ semi_perimeter
+ * (semi_perimeter - side1)
+ * (semi_perimeter - side2)
+ * (semi_perimeter - side3)
+ )
+ return area
+
+
def area_parallelogram(base: float, height: float) -> float:
"""
- Calculate the area of a parallelogram
+ Calculate the area of a parallelogram.
>>> area_parallelogram(10, 20)
200
+ >>> area_parallelogram(1.6, 2.6)
+ 4.16
+ >>> area_parallelogram(0, 0)
+ 0
>>> area_parallelogram(-1, -2)
Traceback (most recent call last):
...
@@ -132,10 +390,14 @@ def area_parallelogram(base: float, height: float) -> float:
def area_trapezium(base1: float, base2: float, height: float) -> float:
"""
- Calculate the area of a trapezium
+ Calculate the area of a trapezium.
>>> area_trapezium(10, 20, 30)
450.0
+ >>> area_trapezium(1.6, 2.6, 3.6)
+ 7.5600000000000005
+ >>> area_trapezium(0, 0, 0)
+ 0.0
>>> area_trapezium(-1, -2, -3)
Traceback (most recent call last):
...
@@ -172,10 +434,14 @@ def area_trapezium(base1: float, base2: float, height: float) -> float:
def area_circle(radius: float) -> float:
"""
- Calculate the area of a circle
+ Calculate the area of a circle.
>>> area_circle(20)
1256.6370614359173
+ >>> area_circle(1.6)
+ 8.042477193189871
+ >>> area_circle(0)
+ 0.0
>>> area_circle(-1)
Traceback (most recent call last):
...
@@ -183,17 +449,21 @@ def area_circle(radius: float) -> float:
"""
if radius < 0:
raise ValueError("area_circle() only accepts non-negative values")
- return pi * radius ** 2
+ return pi * radius**2
def area_ellipse(radius_x: float, radius_y: float) -> float:
"""
- Calculate the area of a ellipse
+ Calculate the area of a ellipse.
>>> area_ellipse(10, 10)
314.1592653589793
>>> area_ellipse(10, 20)
628.3185307179587
+ >>> area_ellipse(0, 0)
+ 0.0
+ >>> area_ellipse(1.6, 2.6)
+ 13.06902543893354
>>> area_ellipse(-10, 20)
Traceback (most recent call last):
...
@@ -214,10 +484,14 @@ def area_ellipse(radius_x: float, radius_y: float) -> float:
def area_rhombus(diagonal_1: float, diagonal_2: float) -> float:
"""
- Calculate the area of a rhombus
+ Calculate the area of a rhombus.
>>> area_rhombus(10, 20)
100.0
+ >>> area_rhombus(1.6, 2.6)
+ 2.08
+ >>> area_rhombus(0, 0)
+ 0.0
>>> area_rhombus(-1, -2)
Traceback (most recent call last):
...
@@ -236,24 +510,75 @@ def area_rhombus(diagonal_1: float, diagonal_2: float) -> float:
return 1 / 2 * diagonal_1 * diagonal_2
-def main():
- print("Areas of various geometric shapes: \n")
- print(f"Rectangle: {area_rectangle(10, 20)}")
- print(f"Square: {area_square(10)}")
- print(f"Triangle: {area_triangle(10, 10)}")
- print(f"Parallelogram: {area_parallelogram(10, 20)}")
- print(f"Trapezium: {area_trapezium(10, 20, 30)}")
- print(f"Circle: {area_circle(20)}")
- print("\nSurface Areas of various geometric shapes: \n")
- print(f"Cube: {surface_area_cube(20)}")
- print(f"Sphere: {surface_area_sphere(20)}")
- print(f"Rhombus: {area_rhombus(10, 20)}")
+def area_reg_polygon(sides: int, length: float) -> float:
+ """
+ Calculate the area of a regular polygon.
+ Wikipedia reference: https://en.wikipedia.org/wiki/Polygon#Regular_polygons
+ Formula: (n*s^2*cot(pi/n))/4
+
+ >>> area_reg_polygon(3, 10)
+ 43.301270189221945
+ >>> area_reg_polygon(4, 10)
+ 100.00000000000001
+ >>> area_reg_polygon(0, 0)
+ Traceback (most recent call last):
+ ...
+ ValueError: area_reg_polygon() only accepts integers greater than or equal to \
+three as number of sides
+ >>> area_reg_polygon(-1, -2)
+ Traceback (most recent call last):
+ ...
+ ValueError: area_reg_polygon() only accepts integers greater than or equal to \
+three as number of sides
+ >>> area_reg_polygon(5, -2)
+ Traceback (most recent call last):
+ ...
+ ValueError: area_reg_polygon() only accepts non-negative values as \
+length of a side
+ >>> area_reg_polygon(-1, 2)
+ Traceback (most recent call last):
+ ...
+ ValueError: area_reg_polygon() only accepts integers greater than or equal to \
+three as number of sides
+ """
+ if not isinstance(sides, int) or sides < 3:
+ raise ValueError(
+ "area_reg_polygon() only accepts integers greater than or \
+equal to three as number of sides"
+ )
+ elif length < 0:
+ raise ValueError(
+ "area_reg_polygon() only accepts non-negative values as \
+length of a side"
+ )
+ return (sides * length**2) / (4 * tan(pi / sides))
+ return (sides * length**2) / (4 * tan(pi / sides))
if __name__ == "__main__":
-
import doctest
doctest.testmod(verbose=True) # verbose so we can see methods missing tests
- main()
+ print("[DEMO] Areas of various geometric shapes: \n")
+ print(f"Rectangle: {area_rectangle(10, 20) = }")
+ print(f"Square: {area_square(10) = }")
+ print(f"Triangle: {area_triangle(10, 10) = }")
+ print(f"Triangle: {area_triangle_three_sides(5, 12, 13) = }")
+ print(f"Parallelogram: {area_parallelogram(10, 20) = }")
+ print(f"Rhombus: {area_rhombus(10, 20) = }")
+ print(f"Trapezium: {area_trapezium(10, 20, 30) = }")
+ print(f"Circle: {area_circle(20) = }")
+ print(f"Ellipse: {area_ellipse(10, 20) = }")
+ print("\nSurface Areas of various geometric shapes: \n")
+ print(f"Cube: {surface_area_cube(20) = }")
+ print(f"Cuboid: {surface_area_cuboid(10, 20, 30) = }")
+ print(f"Sphere: {surface_area_sphere(20) = }")
+ print(f"Hemisphere: {surface_area_hemisphere(20) = }")
+ print(f"Cone: {surface_area_cone(10, 20) = }")
+ print(f"Conical Frustum: {surface_area_conical_frustum(10, 20, 30) = }")
+ print(f"Cylinder: {surface_area_cylinder(10, 20) = }")
+ print(f"Torus: {surface_area_torus(20, 10) = }")
+ print(f"Equilateral Triangle: {area_reg_polygon(3, 10) = }")
+ print(f"Square: {area_reg_polygon(4, 10) = }")
+ print(f"Reqular Pentagon: {area_reg_polygon(5, 10) = }")
diff --git a/maths/area_under_curve.py b/maths/area_under_curve.py
index 2d01e414b63b..10aec768fa09 100644
--- a/maths/area_under_curve.py
+++ b/maths/area_under_curve.py
@@ -2,13 +2,15 @@
Approximates the area under the curve using the trapezoidal rule
"""
-from typing import Callable, Union
+from __future__ import annotations
+
+from collections.abc import Callable
def trapezoidal_area(
- fnc: Callable[[Union[int, float]], Union[int, float]],
- x_start: Union[int, float],
- x_end: Union[int, float],
+ fnc: Callable[[float], float],
+ x_start: float,
+ x_end: float,
steps: int = 100,
) -> float:
"""
@@ -34,7 +36,7 @@ def trapezoidal_area(
x1 = x_start
fx1 = fnc(x_start)
area = 0.0
- for i in range(steps):
+ for _ in range(steps):
# Approximates small segments of curve as linear and solve
# for trapezoidal area
x2 = (x_end - x_start) / steps + x1
@@ -49,7 +51,7 @@ def trapezoidal_area(
if __name__ == "__main__":
def f(x):
- return x ** 3 + x ** 2
+ return x**3 + x**2
print("f(x) = x^3 + x^2")
print("The area between the curve, x = -5, x = 5 and the x axis is:")
diff --git a/maths/armstrong_numbers.py b/maths/armstrong_numbers.py
deleted file mode 100644
index d30ed2e430a0..000000000000
--- a/maths/armstrong_numbers.py
+++ /dev/null
@@ -1,69 +0,0 @@
-"""
-An Armstrong number is equal to the sum of the cubes of its digits.
-For example, 370 is an Armstrong number because 3*3*3 + 7*7*7 + 0*0*0 = 370.
-An Armstrong number is often called Narcissistic number.
-"""
-
-
-def armstrong_number(n: int) -> bool:
- """
- Return True if n is an Armstrong number or False if it is not.
-
- >>> armstrong_number(153)
- True
- >>> armstrong_number(200)
- False
- >>> armstrong_number(1634)
- True
- >>> armstrong_number(0)
- False
- >>> armstrong_number(-1)
- False
- >>> armstrong_number(1.2)
- False
- """
- if not isinstance(n, int) or n < 1:
- return False
-
- # Initialization of sum and number of digits.
- sum = 0
- number_of_digits = 0
- temp = n
- # Calculation of digits of the number
- while temp > 0:
- number_of_digits += 1
- temp //= 10
- # Dividing number into separate digits and find Armstrong number
- temp = n
- while temp > 0:
- rem = temp % 10
- sum += rem ** number_of_digits
- temp //= 10
- return n == sum
-
-
-def narcissistic_number(n: int) -> bool:
- """Return True if n is a narcissistic number or False if it is not"""
-
- expo = len(str(n)) # power, all number will be raised to
- # each digit will be multiplied expo times
- temp = [(int(i) ** expo) for i in str(n)]
-
- # check if sum of cube of each digit is equal to number
- return n == sum(temp)
-
-
-def main():
- """
- Request that user input an integer and tell them if it is Armstrong number.
- """
- num = int(input("Enter an integer to see if it is an Armstrong number: ").strip())
- print(f"{num} is {'' if armstrong_number(num) else 'not '}an Armstrong number.")
- print(f"{num} is {'' if narcissistic_number(num) else 'not '}an Armstrong number.")
-
-
-if __name__ == "__main__":
- import doctest
-
- doctest.testmod()
- main()
diff --git a/maths/average_absolute_deviation.py b/maths/average_absolute_deviation.py
new file mode 100644
index 000000000000..193d94a2f265
--- /dev/null
+++ b/maths/average_absolute_deviation.py
@@ -0,0 +1,29 @@
+def average_absolute_deviation(nums: list[int]) -> float:
+ """
+ Return the average absolute deviation of a list of numbers.
+ Wiki: https://en.wikipedia.org/wiki/Average_absolute_deviation
+
+ >>> average_absolute_deviation([0])
+ 0.0
+ >>> average_absolute_deviation([4, 1, 3, 2])
+ 1.0
+ >>> average_absolute_deviation([2, 70, 6, 50, 20, 8, 4, 0])
+ 20.0
+ >>> average_absolute_deviation([-20, 0, 30, 15])
+ 16.25
+ >>> average_absolute_deviation([])
+ Traceback (most recent call last):
+ ...
+ ValueError: List is empty
+ """
+ if not nums: # Makes sure that the list is not empty
+ raise ValueError("List is empty")
+
+ average = sum(nums) / len(nums) # Calculate the average
+ return sum(abs(x - average) for x in nums) / len(nums)
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/average_mean.py b/maths/average_mean.py
index 4beca1f741a0..274c434ab885 100644
--- a/maths/average_mean.py
+++ b/maths/average_mean.py
@@ -1,20 +1,28 @@
-"""Find mean of a list of numbers."""
+from __future__ import annotations
-def average(nums):
- """Find mean of a list of numbers."""
- return sum(nums) / len(nums)
-
-
-def test_average():
+def mean(nums: list) -> float:
"""
- >>> test_average()
+ Find mean of a list of numbers.
+ Wiki: https://en.wikipedia.org/wiki/Mean
+
+ >>> mean([3, 6, 9, 12, 15, 18, 21])
+ 12.0
+ >>> mean([5, 10, 15, 20, 25, 30, 35])
+ 20.0
+ >>> mean([1, 2, 3, 4, 5, 6, 7, 8])
+ 4.5
+ >>> mean([])
+ Traceback (most recent call last):
+ ...
+ ValueError: List is empty
"""
- assert 12.0 == average([3, 6, 9, 12, 15, 18, 21])
- assert 20 == average([5, 10, 15, 20, 25, 30, 35])
- assert 4.5 == average([1, 2, 3, 4, 5, 6, 7, 8])
+ if not nums:
+ raise ValueError("List is empty")
+ return sum(nums) / len(nums)
if __name__ == "__main__":
- """Call average module to find mean of a specific list of numbers."""
- print(average([2, 4, 6, 8, 20, 50, 70]))
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/average_median.py b/maths/average_median.py
index 0257e3f76f1a..f24e525736b3 100644
--- a/maths/average_median.py
+++ b/maths/average_median.py
@@ -1,10 +1,14 @@
-def median(nums):
+from __future__ import annotations
+
+
+def median(nums: list) -> int | float:
"""
Find median of a list of numbers.
+ Wiki: https://en.wikipedia.org/wiki/Median
>>> median([0])
0
- >>> median([4,1,3,2])
+ >>> median([4, 1, 3, 2])
2.5
>>> median([2, 70, 6, 50, 20, 8, 4])
8
@@ -15,7 +19,9 @@ def median(nums):
Returns:
Median.
"""
- sorted_list = sorted(nums)
+ # The sorted function returns list[SupportsRichComparisonT@sorted]
+ # which does not support `+`
+ sorted_list: list[int] = sorted(nums)
length = len(sorted_list)
mid_index = length >> 1
return (
diff --git a/maths/average_mode.py b/maths/average_mode.py
index d472dc04d4bf..40f88f41f8ca 100644
--- a/maths/average_mode.py
+++ b/maths/average_mode.py
@@ -1,31 +1,32 @@
-import statistics
+from typing import Any
-def mode(input_list): # Defining function "mode."
+def mode(input_list: list) -> list[Any]:
"""This function returns the mode(Mode as in the measures of
central tendency) of the input data.
The input list may contain any Datastructure or any Datatype.
- >>> input_list = [2, 3, 4, 5, 3, 4, 2, 5, 2, 2, 4, 2, 2, 2]
- >>> mode(input_list)
- 2
- >>> input_list = [2, 3, 4, 5, 3, 4, 2, 5, 2, 2, 4, 2, 2, 2]
- >>> mode(input_list) == statistics.mode(input_list)
- True
+ >>> mode([2, 3, 4, 5, 3, 4, 2, 5, 2, 2, 4, 2, 2, 2])
+ [2]
+ >>> mode([3, 4, 5, 3, 4, 2, 5, 2, 2, 4, 4, 2, 2, 2])
+ [2]
+ >>> mode([3, 4, 5, 3, 4, 2, 5, 2, 2, 4, 4, 4, 2, 2, 4, 2])
+ [2, 4]
+ >>> mode(["x", "y", "y", "z"])
+ ['y']
+ >>> mode(["x", "x" , "y", "y", "z"])
+ ['x', 'y']
"""
- # Copying input_list to check with the index number later.
- check_list = input_list.copy()
- result = list() # Empty list to store the counts of elements in input_list
- for x in input_list:
- result.append(input_list.count(x))
- input_list.remove(x)
- y = max(result) # Gets the maximum value in the result list.
- # Returns the value with the maximum number of repetitions.
- return check_list[result.index(y)]
+ if not input_list:
+ return []
+ result = [input_list.count(value) for value in input_list]
+ y = max(result) # Gets the maximum count in the input list.
+ # Gets values of modes
+ return sorted({input_list[i] for i, value in enumerate(result) if value == y})
if __name__ == "__main__":
- data = [2, 3, 4, 5, 3, 4, 2, 5, 2, 2, 4, 2, 2, 2]
- print(mode(data))
- print(statistics.mode(data))
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/bailey_borwein_plouffe.py b/maths/bailey_borwein_plouffe.py
index febf7e975516..389b1566e9de 100644
--- a/maths/bailey_borwein_plouffe.py
+++ b/maths/bailey_borwein_plouffe.py
@@ -67,10 +67,9 @@ def _subsum(
@param precision: same as precision in main function
@return: floating-point number whose integer part is not important
"""
- sum = 0.0
+ total = 0.0
for sum_index in range(digit_pos_to_extract + precision):
denominator = 8 * sum_index + denominator_addend
- exponential_term = 0.0
if sum_index < digit_pos_to_extract:
# if the exponential term is an integer and we mod it by the denominator
# before dividing, only the integer part of the sum will change;
@@ -80,8 +79,8 @@ def _subsum(
)
else:
exponential_term = pow(16, digit_pos_to_extract - 1 - sum_index)
- sum += exponential_term / denominator
- return sum
+ total += exponential_term / denominator
+ return total
if __name__ == "__main__":
diff --git a/maths/base_neg2_conversion.py b/maths/base_neg2_conversion.py
new file mode 100644
index 000000000000..81d40d37e79d
--- /dev/null
+++ b/maths/base_neg2_conversion.py
@@ -0,0 +1,37 @@
+def decimal_to_negative_base_2(num: int) -> int:
+ """
+ This function returns the number negative base 2
+ of the decimal number of the input data.
+
+ Args:
+ int: The decimal number to convert.
+
+ Returns:
+ int: The negative base 2 number.
+
+ Examples:
+ >>> decimal_to_negative_base_2(0)
+ 0
+ >>> decimal_to_negative_base_2(-19)
+ 111101
+ >>> decimal_to_negative_base_2(4)
+ 100
+ >>> decimal_to_negative_base_2(7)
+ 11011
+ """
+ if num == 0:
+ return 0
+ ans = ""
+ while num != 0:
+ num, rem = divmod(num, -2)
+ if rem < 0:
+ rem += 2
+ num += 1
+ ans = str(rem) + ans
+ return int(ans)
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/basic_maths.py b/maths/basic_maths.py
index 07ee3b3df296..833f31c18b9e 100644
--- a/maths/basic_maths.py
+++ b/maths/basic_maths.py
@@ -1,4 +1,5 @@
"""Implementation of Basic Math in Python."""
+
import math
@@ -6,7 +7,17 @@ def prime_factors(n: int) -> list:
"""Find Prime Factors.
>>> prime_factors(100)
[2, 2, 5, 5]
+ >>> prime_factors(0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Only positive integers have prime factors
+ >>> prime_factors(-10)
+ Traceback (most recent call last):
+ ...
+ ValueError: Only positive integers have prime factors
"""
+ if n <= 0:
+ raise ValueError("Only positive integers have prime factors")
pf = []
while n % 2 == 0:
pf.append(2)
@@ -24,7 +35,17 @@ def number_of_divisors(n: int) -> int:
"""Calculate Number of Divisors of an Integer.
>>> number_of_divisors(100)
9
+ >>> number_of_divisors(0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Only positive numbers are accepted
+ >>> number_of_divisors(-10)
+ Traceback (most recent call last):
+ ...
+ ValueError: Only positive numbers are accepted
"""
+ if n <= 0:
+ raise ValueError("Only positive numbers are accepted")
div = 1
temp = 1
while n % 2 == 0:
@@ -37,6 +58,8 @@ def number_of_divisors(n: int) -> int:
temp += 1
n = int(n / i)
div *= temp
+ if n > 1:
+ div *= 2
return div
@@ -44,21 +67,31 @@ def sum_of_divisors(n: int) -> int:
"""Calculate Sum of Divisors.
>>> sum_of_divisors(100)
217
+ >>> sum_of_divisors(0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Only positive numbers are accepted
+ >>> sum_of_divisors(-10)
+ Traceback (most recent call last):
+ ...
+ ValueError: Only positive numbers are accepted
"""
+ if n <= 0:
+ raise ValueError("Only positive numbers are accepted")
s = 1
temp = 1
while n % 2 == 0:
temp += 1
n = int(n / 2)
if temp > 1:
- s *= (2 ** temp - 1) / (2 - 1)
+ s *= (2**temp - 1) / (2 - 1)
for i in range(3, int(math.sqrt(n)) + 1, 2):
temp = 1
while n % i == 0:
temp += 1
n = int(n / i)
if temp > 1:
- s *= (i ** temp - 1) / (i - 1)
+ s *= (i**temp - 1) / (i - 1)
return int(s)
@@ -66,7 +99,17 @@ def euler_phi(n: int) -> int:
"""Calculate Euler's Phi Function.
>>> euler_phi(100)
40
+ >>> euler_phi(0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Only positive numbers are accepted
+ >>> euler_phi(-10)
+ Traceback (most recent call last):
+ ...
+ ValueError: Only positive numbers are accepted
"""
+ if n <= 0:
+ raise ValueError("Only positive numbers are accepted")
s = n
for x in set(prime_factors(n)):
s *= (x - 1) / x
@@ -74,7 +117,6 @@ def euler_phi(n: int) -> int:
if __name__ == "__main__":
- print(prime_factors(100))
- print(number_of_divisors(100))
- print(sum_of_divisors(100))
- print(euler_phi(100))
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/binary_exp_mod.py b/maths/binary_exp_mod.py
deleted file mode 100644
index 67dd1e728b18..000000000000
--- a/maths/binary_exp_mod.py
+++ /dev/null
@@ -1,28 +0,0 @@
-def bin_exp_mod(a, n, b):
- """
- >>> bin_exp_mod(3, 4, 5)
- 1
- >>> bin_exp_mod(7, 13, 10)
- 7
- """
- # mod b
- assert not (b == 0), "This cannot accept modulo that is == 0"
- if n == 0:
- return 1
-
- if n % 2 == 1:
- return (bin_exp_mod(a, n - 1, b) * a) % b
-
- r = bin_exp_mod(a, n / 2, b)
- return (r * r) % b
-
-
-if __name__ == "__main__":
- try:
- BASE = int(input("Enter Base : ").strip())
- POWER = int(input("Enter Power : ").strip())
- MODULO = int(input("Enter Modulo : ").strip())
- except ValueError:
- print("Invalid literal for integer")
-
- print(bin_exp_mod(BASE, POWER, MODULO))
diff --git a/maths/binary_exponentiation.py b/maths/binary_exponentiation.py
index 8dda5245cf44..51ce86d26c41 100644
--- a/maths/binary_exponentiation.py
+++ b/maths/binary_exponentiation.py
@@ -1,28 +1,196 @@
-"""Binary Exponentiation."""
+"""
+Binary Exponentiation
-# Author : Junth Basnet
-# Time Complexity : O(logn)
+This is a method to find a^b in O(log b) time complexity and is one of the most commonly
+used methods of exponentiation. The method is also useful for modular exponentiation,
+when the solution to (a^b) % c is required.
+To calculate a^b:
+- If b is even, then a^b = (a * a)^(b / 2)
+- If b is odd, then a^b = a * a^(b - 1)
+Repeat until b = 1 or b = 0
-def binary_exponentiation(a, n):
+For modular exponentiation, we use the fact that (a * b) % c = ((a % c) * (b % c)) % c
+"""
- if n == 0:
+
+def binary_exp_recursive(base: float, exponent: int) -> float:
+ """
+ Computes a^b recursively, where a is the base and b is the exponent
+
+ >>> binary_exp_recursive(3, 5)
+ 243
+ >>> binary_exp_recursive(11, 13)
+ 34522712143931
+ >>> binary_exp_recursive(-1, 3)
+ -1
+ >>> binary_exp_recursive(0, 5)
+ 0
+ >>> binary_exp_recursive(3, 1)
+ 3
+ >>> binary_exp_recursive(3, 0)
+ 1
+ >>> binary_exp_recursive(1.5, 4)
+ 5.0625
+ >>> binary_exp_recursive(3, -1)
+ Traceback (most recent call last):
+ ...
+ ValueError: Exponent must be a non-negative integer
+ """
+ if exponent < 0:
+ raise ValueError("Exponent must be a non-negative integer")
+
+ if exponent == 0:
+ return 1
+
+ if exponent % 2 == 1:
+ return binary_exp_recursive(base, exponent - 1) * base
+
+ b = binary_exp_recursive(base, exponent // 2)
+ return b * b
+
+
+def binary_exp_iterative(base: float, exponent: int) -> float:
+ """
+ Computes a^b iteratively, where a is the base and b is the exponent
+
+ >>> binary_exp_iterative(3, 5)
+ 243
+ >>> binary_exp_iterative(11, 13)
+ 34522712143931
+ >>> binary_exp_iterative(-1, 3)
+ -1
+ >>> binary_exp_iterative(0, 5)
+ 0
+ >>> binary_exp_iterative(3, 1)
+ 3
+ >>> binary_exp_iterative(3, 0)
+ 1
+ >>> binary_exp_iterative(1.5, 4)
+ 5.0625
+ >>> binary_exp_iterative(3, -1)
+ Traceback (most recent call last):
+ ...
+ ValueError: Exponent must be a non-negative integer
+ """
+ if exponent < 0:
+ raise ValueError("Exponent must be a non-negative integer")
+
+ res: int | float = 1
+ while exponent > 0:
+ if exponent & 1:
+ res *= base
+
+ base *= base
+ exponent >>= 1
+
+ return res
+
+
+def binary_exp_mod_recursive(base: float, exponent: int, modulus: int) -> float:
+ """
+ Computes a^b % c recursively, where a is the base, b is the exponent, and c is the
+ modulus
+
+ >>> binary_exp_mod_recursive(3, 4, 5)
+ 1
+ >>> binary_exp_mod_recursive(11, 13, 7)
+ 4
+ >>> binary_exp_mod_recursive(1.5, 4, 3)
+ 2.0625
+ >>> binary_exp_mod_recursive(7, -1, 10)
+ Traceback (most recent call last):
+ ...
+ ValueError: Exponent must be a non-negative integer
+ >>> binary_exp_mod_recursive(7, 13, 0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Modulus must be a positive integer
+ """
+ if exponent < 0:
+ raise ValueError("Exponent must be a non-negative integer")
+ if modulus <= 0:
+ raise ValueError("Modulus must be a positive integer")
+
+ if exponent == 0:
return 1
- elif n % 2 == 1:
- return binary_exponentiation(a, n - 1) * a
+ if exponent % 2 == 1:
+ return (binary_exp_mod_recursive(base, exponent - 1, modulus) * base) % modulus
+
+ r = binary_exp_mod_recursive(base, exponent // 2, modulus)
+ return (r * r) % modulus
+
- else:
- b = binary_exponentiation(a, n / 2)
- return b * b
+def binary_exp_mod_iterative(base: float, exponent: int, modulus: int) -> float:
+ """
+ Computes a^b % c iteratively, where a is the base, b is the exponent, and c is the
+ modulus
+
+ >>> binary_exp_mod_iterative(3, 4, 5)
+ 1
+ >>> binary_exp_mod_iterative(11, 13, 7)
+ 4
+ >>> binary_exp_mod_iterative(1.5, 4, 3)
+ 2.0625
+ >>> binary_exp_mod_iterative(7, -1, 10)
+ Traceback (most recent call last):
+ ...
+ ValueError: Exponent must be a non-negative integer
+ >>> binary_exp_mod_iterative(7, 13, 0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Modulus must be a positive integer
+ """
+ if exponent < 0:
+ raise ValueError("Exponent must be a non-negative integer")
+ if modulus <= 0:
+ raise ValueError("Modulus must be a positive integer")
+
+ res: int | float = 1
+ while exponent > 0:
+ if exponent & 1:
+ res = ((res % modulus) * (base % modulus)) % modulus
+
+ base *= base
+ exponent >>= 1
+
+ return res
if __name__ == "__main__":
- try:
- BASE = int(input("Enter Base : ").strip())
- POWER = int(input("Enter Power : ").strip())
- except ValueError:
- print("Invalid literal for integer")
-
- RESULT = binary_exponentiation(BASE, POWER)
- print(f"{BASE}^({POWER}) : {RESULT}")
+ from timeit import timeit
+
+ a = 1269380576
+ b = 374
+ c = 34
+
+ runs = 100_000
+ print(
+ timeit(
+ f"binary_exp_recursive({a}, {b})",
+ setup="from __main__ import binary_exp_recursive",
+ number=runs,
+ )
+ )
+ print(
+ timeit(
+ f"binary_exp_iterative({a}, {b})",
+ setup="from __main__ import binary_exp_iterative",
+ number=runs,
+ )
+ )
+ print(
+ timeit(
+ f"binary_exp_mod_recursive({a}, {b}, {c})",
+ setup="from __main__ import binary_exp_mod_recursive",
+ number=runs,
+ )
+ )
+ print(
+ timeit(
+ f"binary_exp_mod_iterative({a}, {b}, {c})",
+ setup="from __main__ import binary_exp_mod_iterative",
+ number=runs,
+ )
+ )
diff --git a/maths/binary_multiplication.py b/maths/binary_multiplication.py
new file mode 100644
index 000000000000..0cc5a575f445
--- /dev/null
+++ b/maths/binary_multiplication.py
@@ -0,0 +1,101 @@
+"""
+Binary Multiplication
+This is a method to find a*b in a time complexity of O(log b)
+This is one of the most commonly used methods of finding result of multiplication.
+Also useful in cases where solution to (a*b)%c is required,
+where a,b,c can be numbers over the computers calculation limits.
+Done using iteration, can also be done using recursion
+
+Let's say you need to calculate a * b
+RULE 1 : a * b = (a+a) * (b/2) ---- example : 4 * 4 = (4+4) * (4/2) = 8 * 2
+RULE 2 : IF b is odd, then ---- a * b = a + (a * (b - 1)), where (b - 1) is even.
+Once b is even, repeat the process to get a * b
+Repeat the process until b = 1 or b = 0, because a*1 = a and a*0 = 0
+
+As far as the modulo is concerned,
+the fact : (a+b) % c = ((a%c) + (b%c)) % c
+Now apply RULE 1 or 2, whichever is required.
+
+@author chinmoy159
+"""
+
+
+def binary_multiply(a: int, b: int) -> int:
+ """
+ Multiply 'a' and 'b' using bitwise multiplication.
+
+ Parameters:
+ a (int): The first number.
+ b (int): The second number.
+
+ Returns:
+ int: a * b
+
+ Examples:
+ >>> binary_multiply(2, 3)
+ 6
+ >>> binary_multiply(5, 0)
+ 0
+ >>> binary_multiply(3, 4)
+ 12
+ >>> binary_multiply(10, 5)
+ 50
+ >>> binary_multiply(0, 5)
+ 0
+ >>> binary_multiply(2, 1)
+ 2
+ >>> binary_multiply(1, 10)
+ 10
+ """
+ res = 0
+ while b > 0:
+ if b & 1:
+ res += a
+
+ a += a
+ b >>= 1
+
+ return res
+
+
+def binary_mod_multiply(a: int, b: int, modulus: int) -> int:
+ """
+ Calculate (a * b) % c using binary multiplication and modular arithmetic.
+
+ Parameters:
+ a (int): The first number.
+ b (int): The second number.
+ modulus (int): The modulus.
+
+ Returns:
+ int: (a * b) % modulus.
+
+ Examples:
+ >>> binary_mod_multiply(2, 3, 5)
+ 1
+ >>> binary_mod_multiply(5, 0, 7)
+ 0
+ >>> binary_mod_multiply(3, 4, 6)
+ 0
+ >>> binary_mod_multiply(10, 5, 13)
+ 11
+ >>> binary_mod_multiply(2, 1, 5)
+ 2
+ >>> binary_mod_multiply(1, 10, 3)
+ 1
+ """
+ res = 0
+ while b > 0:
+ if b & 1:
+ res = ((res % modulus) + (a % modulus)) % modulus
+
+ a += a
+ b >>= 1
+
+ return res
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/binomial_coefficient.py b/maths/binomial_coefficient.py
index 4def041492f3..24c54326e305 100644
--- a/maths/binomial_coefficient.py
+++ b/maths/binomial_coefficient.py
@@ -1,20 +1,62 @@
-def binomial_coefficient(n, r):
+def binomial_coefficient(n: int, r: int) -> int:
"""
- Find binomial coefficient using pascals triangle.
+ Find binomial coefficient using Pascal's triangle.
+
+ Calculate C(n, r) using Pascal's triangle.
+
+ :param n: The total number of items.
+ :param r: The number of items to choose.
+ :return: The binomial coefficient C(n, r).
>>> binomial_coefficient(10, 5)
252
+ >>> binomial_coefficient(10, 0)
+ 1
+ >>> binomial_coefficient(0, 10)
+ 1
+ >>> binomial_coefficient(10, 10)
+ 1
+ >>> binomial_coefficient(5, 2)
+ 10
+ >>> binomial_coefficient(5, 6)
+ 0
+ >>> binomial_coefficient(3, 5)
+ 0
+ >>> binomial_coefficient(-2, 3)
+ Traceback (most recent call last):
+ ...
+ ValueError: n and r must be non-negative integers
+ >>> binomial_coefficient(5, -1)
+ Traceback (most recent call last):
+ ...
+ ValueError: n and r must be non-negative integers
+ >>> binomial_coefficient(10.1, 5)
+ Traceback (most recent call last):
+ ...
+ TypeError: 'float' object cannot be interpreted as an integer
+ >>> binomial_coefficient(10, 5.1)
+ Traceback (most recent call last):
+ ...
+ TypeError: 'float' object cannot be interpreted as an integer
"""
- C = [0 for i in range(r + 1)]
+ if n < 0 or r < 0:
+ raise ValueError("n and r must be non-negative integers")
+ if 0 in (n, r):
+ return 1
+ c = [0 for i in range(r + 1)]
# nc0 = 1
- C[0] = 1
+ c[0] = 1
for i in range(1, n + 1):
# to compute current row from previous row.
j = min(i, r)
while j > 0:
- C[j] += C[j - 1]
+ c[j] += c[j - 1]
j -= 1
- return C[r]
+ return c[r]
+
+if __name__ == "__main__":
+ from doctest import testmod
-print(binomial_coefficient(n=10, r=5))
+ testmod()
+ print(binomial_coefficient(n=10, r=5))
diff --git a/maths/binomial_distribution.py b/maths/binomial_distribution.py
index a74a5a7ed994..eabcaea0d1b2 100644
--- a/maths/binomial_distribution.py
+++ b/maths/binomial_distribution.py
@@ -1,5 +1,6 @@
"""For more information about the Binomial Distribution -
- https://en.wikipedia.org/wiki/Binomial_distribution"""
+https://en.wikipedia.org/wiki/Binomial_distribution"""
+
from math import factorial
@@ -24,7 +25,7 @@ def binomial_distribution(successes: int, trials: int, prob: float) -> float:
raise ValueError("the function is defined for non-negative integers")
if not 0 < prob < 1:
raise ValueError("prob has to be in range of 1 - 0")
- probability = (prob ** successes) * ((1 - prob) ** (trials - successes))
+ probability = (prob**successes) * ((1 - prob) ** (trials - successes))
# Calculate the binomial coefficient: n! / k!(n-k)!
coefficient = float(factorial(trials))
coefficient /= factorial(successes) * factorial(trials - successes)
diff --git a/maths/ceil.py b/maths/ceil.py
index 97578265c1a9..909e02b3f780 100644
--- a/maths/ceil.py
+++ b/maths/ceil.py
@@ -3,7 +3,7 @@
"""
-def ceil(x) -> int:
+def ceil(x: float) -> int:
"""
Return the ceiling of x as an Integral.
diff --git a/maths/chebyshev_distance.py b/maths/chebyshev_distance.py
new file mode 100644
index 000000000000..4801d391621f
--- /dev/null
+++ b/maths/chebyshev_distance.py
@@ -0,0 +1,20 @@
+def chebyshev_distance(point_a: list[float], point_b: list[float]) -> float:
+ """
+ This function calculates the Chebyshev distance (also known as the
+ Chessboard distance) between two n-dimensional points represented as lists.
+
+ https://en.wikipedia.org/wiki/Chebyshev_distance
+
+ >>> chebyshev_distance([1.0, 1.0], [2.0, 2.0])
+ 1.0
+ >>> chebyshev_distance([1.0, 1.0, 9.0], [2.0, 2.0, -5.2])
+ 14.2
+ >>> chebyshev_distance([1.0], [2.0, 2.0])
+ Traceback (most recent call last):
+ ...
+ ValueError: Both points must have the same dimension.
+ """
+ if len(point_a) != len(point_b):
+ raise ValueError("Both points must have the same dimension.")
+
+ return max(abs(a - b) for a, b in zip(point_a, point_b))
diff --git a/maths/check_polygon.py b/maths/check_polygon.py
new file mode 100644
index 000000000000..1e8dce7183ad
--- /dev/null
+++ b/maths/check_polygon.py
@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+
+def check_polygon(nums: list[float]) -> bool:
+ """
+ Takes list of possible side lengths and determines whether a
+ two-dimensional polygon with such side lengths can exist.
+
+ Returns a boolean value for the < comparison
+ of the largest side length with sum of the rest.
+ Wiki: https://en.wikipedia.org/wiki/Triangle_inequality
+
+ >>> check_polygon([6, 10, 5])
+ True
+ >>> check_polygon([3, 7, 13, 2])
+ False
+ >>> check_polygon([1, 4.3, 5.2, 12.2])
+ False
+ >>> nums = [3, 7, 13, 2]
+ >>> _ = check_polygon(nums) # Run function, do not show answer in output
+ >>> nums # Check numbers are not reordered
+ [3, 7, 13, 2]
+ >>> check_polygon([])
+ Traceback (most recent call last):
+ ...
+ ValueError: Monogons and Digons are not polygons in the Euclidean space
+ >>> check_polygon([-2, 5, 6])
+ Traceback (most recent call last):
+ ...
+ ValueError: All values must be greater than 0
+ """
+ if len(nums) < 2:
+ raise ValueError("Monogons and Digons are not polygons in the Euclidean space")
+ if any(i <= 0 for i in nums):
+ raise ValueError("All values must be greater than 0")
+ copy_nums = nums.copy()
+ copy_nums.sort()
+ return copy_nums[-1] < sum(copy_nums[:-1])
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/blockchain/chinese_remainder_theorem.py b/maths/chinese_remainder_theorem.py
similarity index 69%
rename from blockchain/chinese_remainder_theorem.py
rename to maths/chinese_remainder_theorem.py
index b6a486f0b1ed..18af63d106e8 100644
--- a/blockchain/chinese_remainder_theorem.py
+++ b/maths/chinese_remainder_theorem.py
@@ -1,18 +1,22 @@
-# Chinese Remainder Theorem:
-# GCD ( Greatest Common Divisor ) or HCF ( Highest Common Factor )
+"""
+Chinese Remainder Theorem:
+GCD ( Greatest Common Divisor ) or HCF ( Highest Common Factor )
-# If GCD(a,b) = 1, then for any remainder ra modulo a and any remainder rb modulo b
-# there exists integer n, such that n = ra (mod a) and n = ra(mod b). If n1 and n2 are
-# two such integers, then n1=n2(mod ab)
+If GCD(a,b) = 1, then for any remainder ra modulo a and any remainder rb modulo b
+there exists integer n, such that n = ra (mod a) and n = ra(mod b). If n1 and n2 are
+two such integers, then n1=n2(mod ab)
-# Algorithm :
+Algorithm :
-# 1. Use extended euclid algorithm to find x,y such that a*x + b*y = 1
-# 2. Take n = ra*by + rb*ax
+1. Use extended euclid algorithm to find x,y such that a*x + b*y = 1
+2. Take n = ra*by + rb*ax
+"""
+
+from __future__ import annotations
# Extended Euclid
-def extended_euclid(a, b):
+def extended_euclid(a: int, b: int) -> tuple[int, int]:
"""
>>> extended_euclid(10, 6)
(-1, 2)
@@ -29,7 +33,7 @@ def extended_euclid(a, b):
# Uses ExtendedEuclid to find inverses
-def chinese_remainder_theorem(n1, r1, n2, r2):
+def chinese_remainder_theorem(n1: int, r1: int, n2: int, r2: int) -> int:
"""
>>> chinese_remainder_theorem(5,1,7,3)
31
@@ -50,8 +54,9 @@ def chinese_remainder_theorem(n1, r1, n2, r2):
# ----------SAME SOLUTION USING InvertModulo instead ExtendedEuclid----------------
+
# This function find the inverses of a i.e., a^(-1)
-def invert_modulo(a, n):
+def invert_modulo(a: int, n: int) -> int:
"""
>>> invert_modulo(2, 5)
3
@@ -67,7 +72,7 @@ def invert_modulo(a, n):
# Same a above using InvertingModulo
-def chinese_remainder_theorem2(n1, r1, n2, r2):
+def chinese_remainder_theorem2(n1: int, r1: int, n2: int, r2: int) -> int:
"""
>>> chinese_remainder_theorem2(5,1,7,3)
31
diff --git a/maths/chudnovsky_algorithm.py b/maths/chudnovsky_algorithm.py
index aaee7462822e..d122bf0756f7 100644
--- a/maths/chudnovsky_algorithm.py
+++ b/maths/chudnovsky_algorithm.py
@@ -5,7 +5,7 @@
def pi(precision: int) -> str:
"""
The Chudnovsky algorithm is a fast method for calculating the digits of PI,
- based on Ramanujan’s PI formulae.
+ based on Ramanujan's PI formulae.
https://en.wikipedia.org/wiki/Chudnovsky_algorithm
diff --git a/maths/collatz_sequence.py b/maths/collatz_sequence.py
index 7b3636de69f4..b00dca8d70b7 100644
--- a/maths/collatz_sequence.py
+++ b/maths/collatz_sequence.py
@@ -1,43 +1,66 @@
+"""
+The Collatz conjecture is a famous unsolved problem in mathematics. Given a starting
+positive integer, define the following sequence:
+- If the current term n is even, then the next term is n/2.
+- If the current term n is odd, then the next term is 3n + 1.
+The conjecture claims that this sequence will always reach 1 for any starting number.
+
+Other names for this problem include the 3n + 1 problem, the Ulam conjecture, Kakutani's
+problem, the Thwaites conjecture, Hasse's algorithm, the Syracuse problem, and the
+hailstone sequence.
+
+Reference: https://en.wikipedia.org/wiki/Collatz_conjecture
+"""
+
from __future__ import annotations
+from collections.abc import Generator
-def collatz_sequence(n: int) -> list[int]:
+
+def collatz_sequence(n: int) -> Generator[int]:
"""
- Collatz conjecture: start with any positive integer n. The next term is
- obtained as follows:
- If n term is even, the next term is: n / 2 .
- If n is odd, the next term is: 3 * n + 1.
-
- The conjecture states the sequence will always reach 1 for any starting value n.
- Example:
- >>> collatz_sequence(2.1)
+ Generate the Collatz sequence starting at n.
+ >>> tuple(collatz_sequence(2.1))
Traceback (most recent call last):
...
- Exception: Sequence only defined for natural numbers
- >>> collatz_sequence(0)
+ Exception: Sequence only defined for positive integers
+ >>> tuple(collatz_sequence(0))
Traceback (most recent call last):
...
- Exception: Sequence only defined for natural numbers
- >>> collatz_sequence(43) # doctest: +NORMALIZE_WHITESPACE
- [43, 130, 65, 196, 98, 49, 148, 74, 37, 112, 56, 28, 14, 7,
- 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]
+ Exception: Sequence only defined for positive integers
+ >>> tuple(collatz_sequence(4))
+ (4, 2, 1)
+ >>> tuple(collatz_sequence(11))
+ (11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1)
+ >>> tuple(collatz_sequence(31)) # doctest: +NORMALIZE_WHITESPACE
+ (31, 94, 47, 142, 71, 214, 107, 322, 161, 484, 242, 121, 364, 182, 91, 274, 137,
+ 412, 206, 103, 310, 155, 466, 233, 700, 350, 175, 526, 263, 790, 395, 1186, 593,
+ 1780, 890, 445, 1336, 668, 334, 167, 502, 251, 754, 377, 1132, 566, 283, 850, 425,
+ 1276, 638, 319, 958, 479, 1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644,
+ 1822, 911, 2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308, 1154, 577, 1732,
+ 866, 433, 1300, 650, 325, 976, 488, 244, 122, 61, 184, 92, 46, 23, 70, 35, 106, 53,
+ 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1)
+ >>> tuple(collatz_sequence(43)) # doctest: +NORMALIZE_WHITESPACE
+ (43, 130, 65, 196, 98, 49, 148, 74, 37, 112, 56, 28, 14, 7, 22, 11, 34, 17, 52, 26,
+ 13, 40, 20, 10, 5, 16, 8, 4, 2, 1)
"""
-
if not isinstance(n, int) or n < 1:
- raise Exception("Sequence only defined for natural numbers")
+ raise Exception("Sequence only defined for positive integers")
- sequence = [n]
+ yield n
while n != 1:
- n = 3 * n + 1 if n & 1 else n // 2
- sequence.append(n)
- return sequence
+ if n % 2 == 0:
+ n //= 2
+ else:
+ n = 3 * n + 1
+ yield n
def main():
- n = 43
- sequence = collatz_sequence(n)
+ n = int(input("Your number: "))
+ sequence = tuple(collatz_sequence(n))
print(sequence)
- print(f"collatz sequence from {n} took {len(sequence)} steps.")
+ print(f"Collatz sequence from {n} took {len(sequence)} steps.")
if __name__ == "__main__":
diff --git a/maths/combinations.py b/maths/combinations.py
index 40f4f7a9f850..6e9e1a807067 100644
--- a/maths/combinations.py
+++ b/maths/combinations.py
@@ -1,7 +1,6 @@
"""
https://en.wikipedia.org/wiki/Combination
"""
-from math import factorial
def combinations(n: int, k: int) -> int:
@@ -35,18 +34,21 @@ def combinations(n: int, k: int) -> int:
# to calculate a factorial of a negative number, which is not possible
if n < k or k < 0:
raise ValueError("Please enter positive integers for n and k where n >= k")
- return int(factorial(n) / ((factorial(k)) * (factorial(n - k))))
+ res = 1
+ for i in range(k):
+ res *= n - i
+ res //= i + 1
+ return res
if __name__ == "__main__":
-
print(
- "\nThe number of five-card hands possible from a standard",
- f"fifty-two card deck is: {combinations(52, 5)}",
+ "The number of five-card hands possible from a standard",
+ f"fifty-two card deck is: {combinations(52, 5)}\n",
)
print(
- "\nIf a class of 40 students must be arranged into groups of",
+ "If a class of 40 students must be arranged into groups of",
f"4 for group projects, there are {combinations(40, 4)} ways",
"to arrange them.\n",
)
@@ -54,5 +56,5 @@ def combinations(n: int, k: int) -> int:
print(
"If 10 teams are competing in a Formula One race, there",
f"are {combinations(10, 3)} ways that first, second and",
- "third place can be awarded.\n",
+ "third place can be awarded.",
)
diff --git a/maths/continued_fraction.py b/maths/continued_fraction.py
new file mode 100644
index 000000000000..2c38bf88b1e9
--- /dev/null
+++ b/maths/continued_fraction.py
@@ -0,0 +1,57 @@
+"""
+Finding the continuous fraction for a rational number using python
+
+https://en.wikipedia.org/wiki/Continued_fraction
+"""
+
+from fractions import Fraction
+from math import floor
+
+
+def continued_fraction(num: Fraction) -> list[int]:
+ """
+ :param num:
+ Fraction of the number whose continued fractions to be found.
+ Use Fraction(str(number)) for more accurate results due to
+ float inaccuracies.
+
+ :return:
+ The continued fraction of rational number.
+ It is the all commas in the (n + 1)-tuple notation.
+
+ >>> continued_fraction(Fraction(2))
+ [2]
+ >>> continued_fraction(Fraction("3.245"))
+ [3, 4, 12, 4]
+ >>> continued_fraction(Fraction("2.25"))
+ [2, 4]
+ >>> continued_fraction(1/Fraction("2.25"))
+ [0, 2, 4]
+ >>> continued_fraction(Fraction("415/93"))
+ [4, 2, 6, 7]
+ >>> continued_fraction(Fraction(0))
+ [0]
+ >>> continued_fraction(Fraction(0.75))
+ [0, 1, 3]
+ >>> continued_fraction(Fraction("-2.25")) # -2.25 = -3 + 0.75
+ [-3, 1, 3]
+ """
+ numerator, denominator = num.as_integer_ratio()
+ continued_fraction_list: list[int] = []
+ while True:
+ integer_part = floor(numerator / denominator)
+ continued_fraction_list.append(integer_part)
+ numerator -= integer_part * denominator
+ if numerator == 0:
+ break
+ numerator, denominator = denominator, numerator
+
+ return continued_fraction_list
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+
+ print("Continued Fraction of 0.84375 is: ", continued_fraction(Fraction("0.84375")))
diff --git a/maths/decimal_isolate.py b/maths/decimal_isolate.py
index 0e3967a4671d..058ed1bb90d1 100644
--- a/maths/decimal_isolate.py
+++ b/maths/decimal_isolate.py
@@ -4,8 +4,7 @@
"""
-def decimal_isolate(number, digitAmount):
-
+def decimal_isolate(number: float, digit_amount: int) -> float:
"""
Isolates the decimal part of a number.
If digitAmount > 0 round to that decimal place, else print the entire decimal.
@@ -28,8 +27,8 @@ def decimal_isolate(number, digitAmount):
>>> decimal_isolate(-14.123, 3)
-0.123
"""
- if digitAmount > 0:
- return round(number - int(number), digitAmount)
+ if digit_amount > 0:
+ return round(number - int(number), digit_amount)
return number - int(number)
diff --git a/maths/decimal_to_fraction.py b/maths/decimal_to_fraction.py
new file mode 100644
index 000000000000..be42b9fb3b5a
--- /dev/null
+++ b/maths/decimal_to_fraction.py
@@ -0,0 +1,62 @@
+def decimal_to_fraction(decimal: float | str) -> tuple[int, int]:
+ """
+ Return a decimal number in its simplest fraction form
+ >>> decimal_to_fraction(2)
+ (2, 1)
+ >>> decimal_to_fraction(89.)
+ (89, 1)
+ >>> decimal_to_fraction("67")
+ (67, 1)
+ >>> decimal_to_fraction("45.0")
+ (45, 1)
+ >>> decimal_to_fraction(1.5)
+ (3, 2)
+ >>> decimal_to_fraction("6.25")
+ (25, 4)
+ >>> decimal_to_fraction("78td")
+ Traceback (most recent call last):
+ ValueError: Please enter a valid number
+ >>> decimal_to_fraction(0)
+ (0, 1)
+ >>> decimal_to_fraction(-2.5)
+ (-5, 2)
+ >>> decimal_to_fraction(0.125)
+ (1, 8)
+ >>> decimal_to_fraction(1000000.25)
+ (4000001, 4)
+ >>> decimal_to_fraction(1.3333)
+ (13333, 10000)
+ >>> decimal_to_fraction("1.23e2")
+ (123, 1)
+ >>> decimal_to_fraction("0.500")
+ (1, 2)
+ """
+ try:
+ decimal = float(decimal)
+ except ValueError:
+ raise ValueError("Please enter a valid number")
+ fractional_part = decimal - int(decimal)
+ if fractional_part == 0:
+ return int(decimal), 1
+ else:
+ number_of_frac_digits = len(str(decimal).split(".")[1])
+ numerator = int(decimal * (10**number_of_frac_digits))
+ denominator = 10**number_of_frac_digits
+ divisor, dividend = denominator, numerator
+ while True:
+ remainder = dividend % divisor
+ if remainder == 0:
+ break
+ dividend, divisor = divisor, remainder
+ numerator, denominator = numerator // divisor, denominator // divisor
+ return numerator, denominator
+
+
+if __name__ == "__main__":
+ print(f"{decimal_to_fraction(2) = }")
+ print(f"{decimal_to_fraction(89.0) = }")
+ print(f"{decimal_to_fraction('67') = }")
+ print(f"{decimal_to_fraction('45.0') = }")
+ print(f"{decimal_to_fraction(1.5) = }")
+ print(f"{decimal_to_fraction('6.25') = }")
+ print(f"{decimal_to_fraction('78td') = }")
diff --git a/maths/dodecahedron.py b/maths/dodecahedron.py
new file mode 100644
index 000000000000..856245f4a868
--- /dev/null
+++ b/maths/dodecahedron.py
@@ -0,0 +1,73 @@
+# dodecahedron.py
+
+"""
+A regular dodecahedron is a three-dimensional figure made up of
+12 pentagon faces having the same equal size.
+"""
+
+
+def dodecahedron_surface_area(edge: float) -> float:
+ """
+ Calculates the surface area of a regular dodecahedron
+ a = 3 * ((25 + 10 * (5** (1 / 2))) ** (1 / 2 )) * (e**2)
+ where:
+ a --> is the area of the dodecahedron
+ e --> is the length of the edge
+ reference-->"Dodecahedron" Study.com
+
+
+ :param edge: length of the edge of the dodecahedron
+ :type edge: float
+ :return: the surface area of the dodecahedron as a float
+
+
+ Tests:
+ >>> dodecahedron_surface_area(5)
+ 516.1432201766901
+ >>> dodecahedron_surface_area(10)
+ 2064.5728807067603
+ >>> dodecahedron_surface_area(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: Length must be a positive.
+ """
+
+ if edge <= 0 or not isinstance(edge, int):
+ raise ValueError("Length must be a positive.")
+ return 3 * ((25 + 10 * (5 ** (1 / 2))) ** (1 / 2)) * (edge**2)
+
+
+def dodecahedron_volume(edge: float) -> float:
+ """
+ Calculates the volume of a regular dodecahedron
+ v = ((15 + (7 * (5** (1 / 2)))) / 4) * (e**3)
+ where:
+ v --> is the volume of the dodecahedron
+ e --> is the length of the edge
+ reference-->"Dodecahedron" Study.com
+
+
+ :param edge: length of the edge of the dodecahedron
+ :type edge: float
+ :return: the volume of the dodecahedron as a float
+
+ Tests:
+ >>> dodecahedron_volume(5)
+ 957.8898700780791
+ >>> dodecahedron_volume(10)
+ 7663.118960624633
+ >>> dodecahedron_volume(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: Length must be a positive.
+ """
+
+ if edge <= 0 or not isinstance(edge, int):
+ raise ValueError("Length must be a positive.")
+ return ((15 + (7 * (5 ** (1 / 2)))) / 4) * (edge**3)
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/double_factorial.py b/maths/double_factorial.py
new file mode 100644
index 000000000000..3c3a28304e95
--- /dev/null
+++ b/maths/double_factorial.py
@@ -0,0 +1,60 @@
+def double_factorial_recursive(n: int) -> int:
+ """
+ Compute double factorial using recursive method.
+ Recursion can be costly for large numbers.
+
+ To learn about the theory behind this algorithm:
+ https://en.wikipedia.org/wiki/Double_factorial
+
+ >>> from math import prod
+ >>> all(double_factorial_recursive(i) == prod(range(i, 0, -2)) for i in range(20))
+ True
+ >>> double_factorial_recursive(0.1)
+ Traceback (most recent call last):
+ ...
+ ValueError: double_factorial_recursive() only accepts integral values
+ >>> double_factorial_recursive(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: double_factorial_recursive() not defined for negative values
+ """
+ if not isinstance(n, int):
+ raise ValueError("double_factorial_recursive() only accepts integral values")
+ if n < 0:
+ raise ValueError("double_factorial_recursive() not defined for negative values")
+ return 1 if n <= 1 else n * double_factorial_recursive(n - 2)
+
+
+def double_factorial_iterative(num: int) -> int:
+ """
+ Compute double factorial using iterative method.
+
+ To learn about the theory behind this algorithm:
+ https://en.wikipedia.org/wiki/Double_factorial
+
+ >>> from math import prod
+ >>> all(double_factorial_iterative(i) == prod(range(i, 0, -2)) for i in range(20))
+ True
+ >>> double_factorial_iterative(0.1)
+ Traceback (most recent call last):
+ ...
+ ValueError: double_factorial_iterative() only accepts integral values
+ >>> double_factorial_iterative(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: double_factorial_iterative() not defined for negative values
+ """
+ if not isinstance(num, int):
+ raise ValueError("double_factorial_iterative() only accepts integral values")
+ if num < 0:
+ raise ValueError("double_factorial_iterative() not defined for negative values")
+ value = 1
+ for i in range(num, 0, -2):
+ value *= i
+ return value
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/dual_number_automatic_differentiation.py b/maths/dual_number_automatic_differentiation.py
new file mode 100644
index 000000000000..09aeb17a4aea
--- /dev/null
+++ b/maths/dual_number_automatic_differentiation.py
@@ -0,0 +1,139 @@
+from math import factorial
+
+"""
+https://en.wikipedia.org/wiki/Automatic_differentiation#Automatic_differentiation_using_dual_numbers
+https://blog.jliszka.org/2013/10/24/exact-numeric-nth-derivatives.html
+
+Note this only works for basic functions, f(x) where the power of x is positive.
+"""
+
+
+class Dual:
+ def __init__(self, real, rank):
+ self.real = real
+ if isinstance(rank, int):
+ self.duals = [1] * rank
+ else:
+ self.duals = rank
+
+ def __repr__(self):
+ s = "+".join(f"{dual}E{n}" for n, dual in enumerate(self.duals, 1))
+ return f"{self.real}+{s}"
+
+ def reduce(self):
+ cur = self.duals.copy()
+ while cur[-1] == 0:
+ cur.pop(-1)
+ return Dual(self.real, cur)
+
+ def __add__(self, other):
+ if not isinstance(other, Dual):
+ return Dual(self.real + other, self.duals)
+ s_dual = self.duals.copy()
+ o_dual = other.duals.copy()
+ if len(s_dual) > len(o_dual):
+ o_dual.extend([1] * (len(s_dual) - len(o_dual)))
+ elif len(s_dual) < len(o_dual):
+ s_dual.extend([1] * (len(o_dual) - len(s_dual)))
+ new_duals = []
+ for i in range(len(s_dual)):
+ new_duals.append(s_dual[i] + o_dual[i])
+ return Dual(self.real + other.real, new_duals)
+
+ __radd__ = __add__
+
+ def __sub__(self, other):
+ return self + other * -1
+
+ def __mul__(self, other):
+ if not isinstance(other, Dual):
+ new_duals = []
+ for i in self.duals:
+ new_duals.append(i * other)
+ return Dual(self.real * other, new_duals)
+ new_duals = [0] * (len(self.duals) + len(other.duals) + 1)
+ for i, item in enumerate(self.duals):
+ for j, jtem in enumerate(other.duals):
+ new_duals[i + j + 1] += item * jtem
+ for k in range(len(self.duals)):
+ new_duals[k] += self.duals[k] * other.real
+ for index in range(len(other.duals)):
+ new_duals[index] += other.duals[index] * self.real
+ return Dual(self.real * other.real, new_duals)
+
+ __rmul__ = __mul__
+
+ def __truediv__(self, other):
+ if not isinstance(other, Dual):
+ new_duals = []
+ for i in self.duals:
+ new_duals.append(i / other)
+ return Dual(self.real / other, new_duals)
+ raise ValueError
+
+ def __floordiv__(self, other):
+ if not isinstance(other, Dual):
+ new_duals = []
+ for i in self.duals:
+ new_duals.append(i // other)
+ return Dual(self.real // other, new_duals)
+ raise ValueError
+
+ def __pow__(self, n):
+ if n < 0 or isinstance(n, float):
+ raise ValueError("power must be a positive integer")
+ if n == 0:
+ return 1
+ if n == 1:
+ return self
+ x = self
+ for _ in range(n - 1):
+ x *= self
+ return x
+
+
+def differentiate(func, position, order):
+ """
+ >>> differentiate(lambda x: x**2, 2, 2)
+ 2
+ >>> differentiate(lambda x: x**2 * x**4, 9, 2)
+ 196830
+ >>> differentiate(lambda y: 0.5 * (y + 3) ** 6, 3.5, 4)
+ 7605.0
+ >>> differentiate(lambda y: y ** 2, 4, 3)
+ 0
+ >>> differentiate(8, 8, 8)
+ Traceback (most recent call last):
+ ...
+ ValueError: differentiate() requires a function as input for func
+ >>> differentiate(lambda x: x **2, "", 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: differentiate() requires a float as input for position
+ >>> differentiate(lambda x: x**2, 3, "")
+ Traceback (most recent call last):
+ ...
+ ValueError: differentiate() requires an int as input for order
+ """
+ if not callable(func):
+ raise ValueError("differentiate() requires a function as input for func")
+ if not isinstance(position, (float, int)):
+ raise ValueError("differentiate() requires a float as input for position")
+ if not isinstance(order, int):
+ raise ValueError("differentiate() requires an int as input for order")
+ d = Dual(position, 1)
+ result = func(d)
+ if order == 0:
+ return result.real
+ return result.duals[order - 1] * factorial(order)
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+
+ def f(y):
+ return y**2 * y**4
+
+ print(differentiate(f, 9, 2))
diff --git a/maths/entropy.py b/maths/entropy.py
index 43bb3860fc12..b816f1d193f7 100644
--- a/maths/entropy.py
+++ b/maths/entropy.py
@@ -4,6 +4,7 @@
Implementation of entropy of information
https://en.wikipedia.org/wiki/Entropy_(information_theory)
"""
+
from __future__ import annotations
import math
@@ -20,10 +21,10 @@ def calculate_prob(text: str) -> None:
:return: Prints
1) Entropy of information based on 1 alphabet
2) Entropy of information based on couples of 2 alphabet
- 3) print Entropy of H(X n∣Xn−1)
+ 3) print Entropy of H(X n|Xn-1)
Text from random books. Also, random quotes.
- >>> text = ("Behind Winston’s back the voice "
+ >>> text = ("Behind Winston's back the voice "
... "from the telescreen was still "
... "babbling and the overfulfilment")
>>> calculate_prob(text)
@@ -68,7 +69,7 @@ def calculate_prob(text: str) -> None:
my_fir_sum += prob * math.log2(prob) # entropy formula.
# print entropy
- print("{:.1f}".format(round(-1 * my_fir_sum)))
+ print(f"{round(-1 * my_fir_sum):.1f}")
# two len string
all_sum = sum(two_char_strings.values())
@@ -83,10 +84,10 @@ def calculate_prob(text: str) -> None:
my_sec_sum += prob * math.log2(prob)
# print second entropy
- print("{:.1f}".format(round(-1 * my_sec_sum)))
+ print(f"{round(-1 * my_sec_sum):.1f}")
# print the difference between them
- print("{:.1f}".format(round((-1 * my_sec_sum) - (-1 * my_fir_sum))))
+ print(f"{round((-1 * my_sec_sum) - (-1 * my_fir_sum)):.1f}")
def analyze_text(text: str) -> tuple[dict, dict]:
@@ -95,13 +96,13 @@ def analyze_text(text: str) -> tuple[dict, dict]:
The first dictionary stores the frequency of single character strings.
The second dictionary stores the frequency of two character strings.
"""
- single_char_strings = Counter() # type: ignore
- two_char_strings = Counter() # type: ignore
+ single_char_strings = Counter() # type: ignore[var-annotated]
+ two_char_strings = Counter() # type: ignore[var-annotated]
single_char_strings[text[-1]] += 1
# first case when we have space at start.
two_char_strings[" " + text[0]] += 1
- for i in range(0, len(text) - 1):
+ for i in range(len(text) - 1):
single_char_strings[text[i]] += 1
two_char_strings[text[i : i + 2]] += 1
return single_char_strings, two_char_strings
diff --git a/maths/euclidean_distance.py b/maths/euclidean_distance.py
new file mode 100644
index 000000000000..aa7f3efc7684
--- /dev/null
+++ b/maths/euclidean_distance.py
@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import typing
+from collections.abc import Iterable
+
+import numpy as np
+
+Vector = typing.Union[Iterable[float], Iterable[int], np.ndarray] # noqa: UP007
+VectorOut = typing.Union[np.float64, int, float] # noqa: UP007
+
+
+def euclidean_distance(vector_1: Vector, vector_2: Vector) -> VectorOut:
+ """
+ Calculate the distance between the two endpoints of two vectors.
+ A vector is defined as a list, tuple, or numpy 1D array.
+ >>> float(euclidean_distance((0, 0), (2, 2)))
+ 2.8284271247461903
+ >>> float(euclidean_distance(np.array([0, 0, 0]), np.array([2, 2, 2])))
+ 3.4641016151377544
+ >>> float(euclidean_distance(np.array([1, 2, 3, 4]), np.array([5, 6, 7, 8])))
+ 8.0
+ >>> float(euclidean_distance([1, 2, 3, 4], [5, 6, 7, 8]))
+ 8.0
+ """
+ return np.sqrt(np.sum((np.asarray(vector_1) - np.asarray(vector_2)) ** 2))
+
+
+def euclidean_distance_no_np(vector_1: Vector, vector_2: Vector) -> VectorOut:
+ """
+ Calculate the distance between the two endpoints of two vectors without numpy.
+ A vector is defined as a list, tuple, or numpy 1D array.
+ >>> euclidean_distance_no_np((0, 0), (2, 2))
+ 2.8284271247461903
+ >>> euclidean_distance_no_np([1, 2, 3, 4], [5, 6, 7, 8])
+ 8.0
+ """
+ return sum((v1 - v2) ** 2 for v1, v2 in zip(vector_1, vector_2)) ** (1 / 2)
+
+
+if __name__ == "__main__":
+
+ def benchmark() -> None:
+ """
+ Benchmarks
+ """
+ from timeit import timeit
+
+ print("Without Numpy")
+ print(
+ timeit(
+ "euclidean_distance_no_np([1, 2, 3], [4, 5, 6])",
+ number=10000,
+ globals=globals(),
+ )
+ )
+ print("With Numpy")
+ print(
+ timeit(
+ "euclidean_distance([1, 2, 3], [4, 5, 6])",
+ number=10000,
+ globals=globals(),
+ )
+ )
+
+ benchmark()
diff --git a/maths/euler_method.py b/maths/euler_method.py
new file mode 100644
index 000000000000..c6adb07e2d3d
--- /dev/null
+++ b/maths/euler_method.py
@@ -0,0 +1,47 @@
+from collections.abc import Callable
+
+import numpy as np
+
+
+def explicit_euler(
+ ode_func: Callable, y0: float, x0: float, step_size: float, x_end: float
+) -> np.ndarray:
+ """Calculate numeric solution at each step to an ODE using Euler's Method
+
+ For reference to Euler's method refer to https://en.wikipedia.org/wiki/Euler_method.
+
+ Args:
+ ode_func (Callable): The ordinary differential equation
+ as a function of x and y.
+ y0 (float): The initial value for y.
+ x0 (float): The initial value for x.
+ step_size (float): The increment value for x.
+ x_end (float): The final value of x to be calculated.
+
+ Returns:
+ np.ndarray: Solution of y for every step in x.
+
+ >>> # the exact solution is math.exp(x)
+ >>> def f(x, y):
+ ... return y
+ >>> y0 = 1
+ >>> y = explicit_euler(f, y0, 0.0, 0.01, 5)
+ >>> float(y[-1])
+ 144.77277243257308
+ """
+ n = int(np.ceil((x_end - x0) / step_size))
+ y = np.zeros((n + 1,))
+ y[0] = y0
+ x = x0
+
+ for k in range(n):
+ y[k + 1] = y[k] + step_size * ode_func(x, y[k])
+ x += step_size
+
+ return y
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/euler_modified.py b/maths/euler_modified.py
new file mode 100644
index 000000000000..bb282e9f0ab9
--- /dev/null
+++ b/maths/euler_modified.py
@@ -0,0 +1,54 @@
+from collections.abc import Callable
+
+import numpy as np
+
+
+def euler_modified(
+ ode_func: Callable, y0: float, x0: float, step_size: float, x_end: float
+) -> np.ndarray:
+ """
+ Calculate solution at each step to an ODE using Euler's Modified Method
+ The Euler Method is straightforward to implement, but can't give accurate solutions.
+ So, some changes were proposed to improve accuracy.
+
+ https://en.wikipedia.org/wiki/Euler_method
+
+ Arguments:
+ ode_func -- The ode as a function of x and y
+ y0 -- the initial value for y
+ x0 -- the initial value for x
+ stepsize -- the increment value for x
+ x_end -- the end value for x
+
+ >>> # the exact solution is math.exp(x)
+ >>> def f1(x, y):
+ ... return -2*x*(y**2)
+ >>> y = euler_modified(f1, 1.0, 0.0, 0.2, 1.0)
+ >>> float(y[-1])
+ 0.503338255442106
+ >>> import math
+ >>> def f2(x, y):
+ ... return -2*y + (x**3)*math.exp(-2*x)
+ >>> y = euler_modified(f2, 1.0, 0.0, 0.1, 0.3)
+ >>> float(y[-1])
+ 0.5525976431951775
+ """
+ n = int(np.ceil((x_end - x0) / step_size))
+ y = np.zeros((n + 1,))
+ y[0] = y0
+ x = x0
+
+ for k in range(n):
+ y_get = y[k] + step_size * ode_func(x, y[k])
+ y[k + 1] = y[k] + (
+ (step_size / 2) * (ode_func(x, y[k]) + ode_func(x + step_size, y_get))
+ )
+ x += step_size
+
+ return y
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/eulers_totient.py b/maths/eulers_totient.py
index 6a35e69bde0b..00f0254c215a 100644
--- a/maths/eulers_totient.py
+++ b/maths/eulers_totient.py
@@ -1,12 +1,27 @@
# Eulers Totient function finds the number of relative primes of a number n from 1 to n
def totient(n: int) -> list:
+ """
+ >>> n = 10
+ >>> totient_calculation = totient(n)
+ >>> for i in range(1, n):
+ ... print(f"{i} has {totient_calculation[i]} relative primes.")
+ 1 has 0 relative primes.
+ 2 has 1 relative primes.
+ 3 has 2 relative primes.
+ 4 has 2 relative primes.
+ 5 has 4 relative primes.
+ 6 has 2 relative primes.
+ 7 has 6 relative primes.
+ 8 has 4 relative primes.
+ 9 has 6 relative primes.
+ """
is_prime = [True for i in range(n + 1)]
totients = [i - 1 for i in range(n + 1)]
primes = []
for i in range(2, n + 1):
if is_prime[i]:
primes.append(i)
- for j in range(0, len(primes)):
+ for j in range(len(primes)):
if i * primes[j] >= n:
break
is_prime[i * primes[j]] = False
@@ -20,25 +35,6 @@ def totient(n: int) -> list:
return totients
-def test_totient() -> None:
- """
- >>> n = 10
- >>> totient_calculation = totient(n)
- >>> for i in range(1, n):
- ... print(f"{i} has {totient_calculation[i]} relative primes.")
- 1 has 0 relative primes.
- 2 has 1 relative primes.
- 3 has 2 relative primes.
- 4 has 2 relative primes.
- 5 has 4 relative primes.
- 6 has 2 relative primes.
- 7 has 6 relative primes.
- 8 has 4 relative primes.
- 9 has 6 relative primes.
- """
- pass
-
-
if __name__ == "__main__":
import doctest
diff --git a/maths/explicit_euler.py b/maths/explicit_euler.py
deleted file mode 100644
index 7c780198602b..000000000000
--- a/maths/explicit_euler.py
+++ /dev/null
@@ -1,40 +0,0 @@
-import numpy as np
-
-
-def explicit_euler(ode_func, y0, x0, step_size, x_end):
- """
- Calculate numeric solution at each step to an ODE using Euler's Method
-
- https://en.wikipedia.org/wiki/Euler_method
-
- Arguments:
- ode_func -- The ode as a function of x and y
- y0 -- the initial value for y
- x0 -- the initial value for x
- stepsize -- the increment value for x
- x_end -- the end value for x
-
- >>> # the exact solution is math.exp(x)
- >>> def f(x, y):
- ... return y
- >>> y0 = 1
- >>> y = explicit_euler(f, y0, 0.0, 0.01, 5)
- >>> y[-1]
- 144.77277243257308
- """
- N = int(np.ceil((x_end - x0) / step_size))
- y = np.zeros((N + 1,))
- y[0] = y0
- x = x0
-
- for k in range(N):
- y[k + 1] = y[k] + step_size * ode_func(x, y[k])
- x += step_size
-
- return y
-
-
-if __name__ == "__main__":
- import doctest
-
- doctest.testmod()
diff --git a/maths/extended_euclidean_algorithm.py b/maths/extended_euclidean_algorithm.py
index e7087636ce09..c54909e19101 100644
--- a/maths/extended_euclidean_algorithm.py
+++ b/maths/extended_euclidean_algorithm.py
@@ -12,12 +12,12 @@
# @Email: silentcat@protonmail.com
# @Last modified by: pikulet
# @Last modified time: 2020-10-02
+from __future__ import annotations
import sys
-from typing import Tuple
-def extended_euclidean_algorithm(a: int, b: int) -> Tuple[int, int]:
+def extended_euclidean_algorithm(a: int, b: int) -> tuple[int, int]:
"""
Extended Euclidean Algorithm.
@@ -75,11 +75,12 @@ def main():
"""Call Extended Euclidean Algorithm."""
if len(sys.argv) < 3:
print("2 integer arguments required")
- exit(1)
+ return 1
a = int(sys.argv[1])
b = int(sys.argv[2])
print(extended_euclidean_algorithm(a, b))
+ return 0
if __name__ == "__main__":
- main()
+ raise SystemExit(main())
diff --git a/maths/factorial.py b/maths/factorial.py
new file mode 100644
index 000000000000..aaf90f384bb9
--- /dev/null
+++ b/maths/factorial.py
@@ -0,0 +1,68 @@
+"""
+Factorial of a positive integer -- https://en.wikipedia.org/wiki/Factorial
+"""
+
+
+def factorial(number: int) -> int:
+ """
+ Calculate the factorial of specified number (n!).
+
+ >>> import math
+ >>> all(factorial(i) == math.factorial(i) for i in range(20))
+ True
+ >>> factorial(0.1)
+ Traceback (most recent call last):
+ ...
+ ValueError: factorial() only accepts integral values
+ >>> factorial(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: factorial() not defined for negative values
+ >>> factorial(1)
+ 1
+ >>> factorial(6)
+ 720
+ >>> factorial(0)
+ 1
+ """
+ if number != int(number):
+ raise ValueError("factorial() only accepts integral values")
+ if number < 0:
+ raise ValueError("factorial() not defined for negative values")
+ value = 1
+ for i in range(1, number + 1):
+ value *= i
+ return value
+
+
+def factorial_recursive(n: int) -> int:
+ """
+ Calculate the factorial of a positive integer
+ https://en.wikipedia.org/wiki/Factorial
+
+ >>> import math
+ >>> all(factorial(i) == math.factorial(i) for i in range(20))
+ True
+ >>> factorial(0.1)
+ Traceback (most recent call last):
+ ...
+ ValueError: factorial() only accepts integral values
+ >>> factorial(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: factorial() not defined for negative values
+ """
+ if not isinstance(n, int):
+ raise ValueError("factorial() only accepts integral values")
+ if n < 0:
+ raise ValueError("factorial() not defined for negative values")
+ return 1 if n in {0, 1} else n * factorial(n - 1)
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+
+ n = int(input("Enter a positive integer: ").strip() or 0)
+ print(f"factorial{n} is {factorial(n)}")
diff --git a/maths/factorial_iterative.py b/maths/factorial_iterative.py
deleted file mode 100644
index 64314790c11c..000000000000
--- a/maths/factorial_iterative.py
+++ /dev/null
@@ -1,30 +0,0 @@
-# factorial of a positive integer -- https://en.wikipedia.org/wiki/Factorial
-
-
-def factorial(n: int) -> int:
- """
- >>> import math
- >>> all(factorial(i) == math.factorial(i) for i in range(20))
- True
- >>> factorial(0.1)
- Traceback (most recent call last):
- ...
- ValueError: factorial() only accepts integral values
- >>> factorial(-1)
- Traceback (most recent call last):
- ...
- ValueError: factorial() not defined for negative values
- """
- if n != int(n):
- raise ValueError("factorial() only accepts integral values")
- if n < 0:
- raise ValueError("factorial() not defined for negative values")
- value = 1
- for i in range(1, n + 1):
- value *= i
- return value
-
-
-if __name__ == "__main__":
- n = int(input("Enter a positive integer: ").strip() or 0)
- print(f"factorial{n} is {factorial(n)}")
diff --git a/maths/factorial_python.py b/maths/factorial_python.py
deleted file mode 100644
index 46688261af56..000000000000
--- a/maths/factorial_python.py
+++ /dev/null
@@ -1,34 +0,0 @@
-def factorial(input_number: int) -> int:
- """
- Calculate the factorial of specified number
-
- >>> factorial(1)
- 1
- >>> factorial(6)
- 720
- >>> factorial(0)
- 1
- >>> factorial(-1)
- Traceback (most recent call last):
- ...
- ValueError: factorial() not defined for negative values
- >>> factorial(0.1)
- Traceback (most recent call last):
- ...
- ValueError: factorial() only accepts integral values
- """
-
- if input_number < 0:
- raise ValueError("factorial() not defined for negative values")
- if not isinstance(input_number, int):
- raise ValueError("factorial() only accepts integral values")
- result = 1
- for i in range(1, input_number):
- result = result * (i + 1)
- return result
-
-
-if __name__ == "__main__":
- import doctest
-
- doctest.testmod()
diff --git a/maths/factorial_recursive.py b/maths/factorial_recursive.py
deleted file mode 100644
index 137112738905..000000000000
--- a/maths/factorial_recursive.py
+++ /dev/null
@@ -1,28 +0,0 @@
-def factorial(n: int) -> int:
- """
- Calculate the factorial of a positive integer
- https://en.wikipedia.org/wiki/Factorial
-
- >>> import math
- >>> all(factorial(i) == math.factorial(i) for i in range(20))
- True
- >>> factorial(0.1)
- Traceback (most recent call last):
- ...
- ValueError: factorial() only accepts integral values
- >>> factorial(-1)
- Traceback (most recent call last):
- ...
- ValueError: factorial() not defined for negative values
- """
- if not isinstance(n, int):
- raise ValueError("factorial() only accepts integral values")
- if n < 0:
- raise ValueError("factorial() not defined for negative values")
- return 1 if n == 0 or n == 1 else n * factorial(n - 1)
-
-
-if __name__ == "__main__":
- import doctest
-
- doctest.testmod()
diff --git a/maths/factors.py b/maths/factors.py
index e2fdc4063a13..ae2e5316cf65 100644
--- a/maths/factors.py
+++ b/maths/factors.py
@@ -1,3 +1,7 @@
+from doctest import testmod
+from math import sqrt
+
+
def factors_of_a_number(num: int) -> list:
"""
>>> factors_of_a_number(1)
@@ -9,10 +13,22 @@ def factors_of_a_number(num: int) -> list:
>>> factors_of_a_number(-24)
[]
"""
- return [i for i in range(1, num + 1) if num % i == 0]
+ facs: list[int] = []
+ if num < 1:
+ return facs
+ facs.append(1)
+ if num == 1:
+ return facs
+ facs.append(num)
+ for i in range(2, int(sqrt(num)) + 1):
+ if num % i == 0: # If i is a factor of num
+ facs.append(i)
+ d = num // i # num//i is the other factor of num
+ if d != i: # If d and i are distinct
+ facs.append(d) # we have found another factor
+ facs.sort()
+ return facs
if __name__ == "__main__":
- num = int(input("Enter a number to find its factors: "))
- factors = factors_of_a_number(num)
- print(f"{num} has {len(factors)} factors: {', '.join(str(f) for f in factors)}")
+ testmod(name="factors_of_a_number", verbose=True)
diff --git a/maths/fast_inverse_sqrt.py b/maths/fast_inverse_sqrt.py
new file mode 100644
index 000000000000..79385bb84877
--- /dev/null
+++ b/maths/fast_inverse_sqrt.py
@@ -0,0 +1,54 @@
+"""
+Fast inverse square root (1/sqrt(x)) using the Quake III algorithm.
+Reference: https://en.wikipedia.org/wiki/Fast_inverse_square_root
+Accuracy: https://en.wikipedia.org/wiki/Fast_inverse_square_root#Accuracy
+"""
+
+import struct
+
+
+def fast_inverse_sqrt(number: float) -> float:
+ """
+ Compute the fast inverse square root of a floating-point number using the famous
+ Quake III algorithm.
+
+ :param float number: Input number for which to calculate the inverse square root.
+ :return float: The fast inverse square root of the input number.
+
+ Example:
+ >>> fast_inverse_sqrt(10)
+ 0.3156857923527257
+ >>> fast_inverse_sqrt(4)
+ 0.49915357479239103
+ >>> fast_inverse_sqrt(4.1)
+ 0.4932849504615651
+ >>> fast_inverse_sqrt(0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input must be a positive number.
+ >>> fast_inverse_sqrt(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input must be a positive number.
+ >>> from math import isclose, sqrt
+ >>> all(isclose(fast_inverse_sqrt(i), 1 / sqrt(i), rel_tol=0.00132)
+ ... for i in range(50, 60))
+ True
+ """
+ if number <= 0:
+ raise ValueError("Input must be a positive number.")
+ i = struct.unpack(">i", struct.pack(">f", number))[0]
+ i = 0x5F3759DF - (i >> 1)
+ y = struct.unpack(">f", struct.pack(">i", i))[0]
+ return y * (1.5 - 0.5 * number * y * y)
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
+ # https://en.wikipedia.org/wiki/Fast_inverse_square_root#Accuracy
+ from math import sqrt
+
+ for i in range(5, 101, 5):
+ print(f"{i:>3}: {(1 / sqrt(i)) - fast_inverse_sqrt(i):.5f}")
diff --git a/maths/fermat_little_theorem.py b/maths/fermat_little_theorem.py
index 73af3e28c618..4a3ecd05ce91 100644
--- a/maths/fermat_little_theorem.py
+++ b/maths/fermat_little_theorem.py
@@ -5,8 +5,7 @@
# Wikipedia reference: https://en.wikipedia.org/wiki/Fermat%27s_little_theorem
-def binary_exponentiation(a, n, mod):
-
+def binary_exponentiation(a: int, n: float, mod: int) -> int:
if n == 0:
return 1
diff --git a/maths/fibonacci.py b/maths/fibonacci.py
index e6519035401e..24b2d7ae449e 100644
--- a/maths/fibonacci.py
+++ b/maths/fibonacci.py
@@ -1,130 +1,332 @@
-# fibonacci.py
-"""
-1. Calculates the iterative fibonacci sequence
-
-2. Calculates the fibonacci sequence with a formula
- an = [ Phin - (phi)n ]/Sqrt[5]
- reference-->Su, Francis E., et al. "Fibonacci Number Formula." Math Fun Facts.
-
-"""
-import functools
-import math
-import time
-from decimal import Decimal, getcontext
-
-getcontext().prec = 100
-
-
-def timer_decorator(func):
- @functools.wraps(func)
- def timer_wrapper(*args, **kwargs):
- start = time.time()
- func(*args, **kwargs)
- end = time.time()
- if int(end - start) > 0:
- print(f"Run time for {func.__name__}: {(end - start):0.2f}s")
- else:
- print(f"Run time for {func.__name__}: {(end - start)*1000:0.2f}ms")
- return func(*args, **kwargs)
-
- return timer_wrapper
-
-
-# define Python user-defined exceptions
-class Error(Exception):
- """Base class for other exceptions"""
-
-
-class ValueTooLargeError(Error):
- """Raised when the input value is too large"""
-
-
-class ValueTooSmallError(Error):
- """Raised when the input value is not greater than one"""
-
-
-class ValueLessThanZero(Error):
- """Raised when the input value is less than zero"""
-
-
-def _check_number_input(n, min_thresh, max_thresh=None):
- """
- :param n: single integer
- :type n: int
- :param min_thresh: min threshold, single integer
- :type min_thresh: int
- :param max_thresh: max threshold, single integer
- :type max_thresh: int
- :return: boolean
- """
- try:
- if n >= min_thresh and max_thresh is None:
- return True
- elif min_thresh <= n <= max_thresh:
- return True
- elif n < 0:
- raise ValueLessThanZero
- elif n < min_thresh:
- raise ValueTooSmallError
- elif n > max_thresh:
- raise ValueTooLargeError
- except ValueLessThanZero:
- print("Incorrect Input: number must not be less than 0")
- except ValueTooSmallError:
- print(
- f"Incorrect Input: input number must be > {min_thresh} for the recursive "
- "calculation"
- )
- except ValueTooLargeError:
- print(
- f"Incorrect Input: input number must be < {max_thresh} for the recursive "
- "calculation"
- )
- return False
-
-
-@timer_decorator
-def fib_iterative(n):
- """
- :param n: calculate Fibonacci to the nth integer
- :type n:int
- :return: Fibonacci sequence as a list
- """
- n = int(n)
- if _check_number_input(n, 2):
- seq_out = [0, 1]
- a, b = 0, 1
- for _ in range(n - len(seq_out)):
- a, b = b, a + b
- seq_out.append(b)
- return seq_out
-
-
-@timer_decorator
-def fib_formula(n):
- """
- :param n: calculate Fibonacci to the nth integer
- :type n:int
- :return: Fibonacci sequence as a list
- """
- seq_out = [0, 1]
- n = int(n)
- if _check_number_input(n, 2, 1000000):
- sqrt = Decimal(math.sqrt(5))
- phi_1 = Decimal(1 + sqrt) / Decimal(2)
- phi_2 = Decimal(1 - sqrt) / Decimal(2)
- for i in range(2, n):
- temp_out = ((phi_1 ** Decimal(i)) - (phi_2 ** Decimal(i))) * (
- Decimal(sqrt) ** Decimal(-1)
- )
- seq_out.append(int(temp_out))
- return seq_out
-
-
-if __name__ == "__main__":
- num = 20
- # print(f'{fib_recursive(num)}\n')
- # print(f'{fib_iterative(num)}\n')
- # print(f'{fib_formula(num)}\n')
- fib_iterative(num)
- fib_formula(num)
+"""
+Calculates the Fibonacci sequence using iteration, recursion, memoization,
+and a simplified form of Binet's formula
+
+NOTE 1: the iterative, recursive, memoization functions are more accurate than
+the Binet's formula function because the Binet formula function uses floats
+
+NOTE 2: the Binet's formula function is much more limited in the size of inputs
+that it can handle due to the size limitations of Python floats
+NOTE 3: the matrix function is the fastest and most memory efficient for large n
+
+
+See benchmark numbers in __main__ for performance comparisons/
+https://en.wikipedia.org/wiki/Fibonacci_number for more information
+"""
+
+import functools
+from collections.abc import Iterator
+from math import sqrt
+from time import time
+
+import numpy as np
+from numpy import ndarray
+
+
+def time_func(func, *args, **kwargs):
+ """
+ Times the execution of a function with parameters
+ """
+ start = time()
+ output = func(*args, **kwargs)
+ end = time()
+ if int(end - start) > 0:
+ print(f"{func.__name__} runtime: {(end - start):0.4f} s")
+ else:
+ print(f"{func.__name__} runtime: {(end - start) * 1000:0.4f} ms")
+ return output
+
+
+def fib_iterative_yield(n: int) -> Iterator[int]:
+ """
+ Calculates the first n (1-indexed) Fibonacci numbers using iteration with yield
+ >>> list(fib_iterative_yield(0))
+ [0]
+ >>> tuple(fib_iterative_yield(1))
+ (0, 1)
+ >>> tuple(fib_iterative_yield(5))
+ (0, 1, 1, 2, 3, 5)
+ >>> tuple(fib_iterative_yield(10))
+ (0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55)
+ >>> tuple(fib_iterative_yield(-1))
+ Traceback (most recent call last):
+ ...
+ ValueError: n is negative
+ """
+ if n < 0:
+ raise ValueError("n is negative")
+ a, b = 0, 1
+ yield a
+ for _ in range(n):
+ yield b
+ a, b = b, a + b
+
+
+def fib_iterative(n: int) -> list[int]:
+ """
+ Calculates the first n (0-indexed) Fibonacci numbers using iteration
+ >>> fib_iterative(0)
+ [0]
+ >>> fib_iterative(1)
+ [0, 1]
+ >>> fib_iterative(5)
+ [0, 1, 1, 2, 3, 5]
+ >>> fib_iterative(10)
+ [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+ >>> fib_iterative(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: n is negative
+ """
+ if n < 0:
+ raise ValueError("n is negative")
+ if n == 0:
+ return [0]
+ fib = [0, 1]
+ for _ in range(n - 1):
+ fib.append(fib[-1] + fib[-2])
+ return fib
+
+
+def fib_recursive(n: int) -> list[int]:
+ """
+ Calculates the first n (0-indexed) Fibonacci numbers using recursion
+ >>> fib_iterative(0)
+ [0]
+ >>> fib_iterative(1)
+ [0, 1]
+ >>> fib_iterative(5)
+ [0, 1, 1, 2, 3, 5]
+ >>> fib_iterative(10)
+ [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+ >>> fib_iterative(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: n is negative
+ """
+
+ def fib_recursive_term(i: int) -> int:
+ """
+ Calculates the i-th (0-indexed) Fibonacci number using recursion
+ >>> fib_recursive_term(0)
+ 0
+ >>> fib_recursive_term(1)
+ 1
+ >>> fib_recursive_term(5)
+ 5
+ >>> fib_recursive_term(10)
+ 55
+ >>> fib_recursive_term(-1)
+ Traceback (most recent call last):
+ ...
+ Exception: n is negative
+ """
+ if i < 0:
+ raise ValueError("n is negative")
+ if i < 2:
+ return i
+ return fib_recursive_term(i - 1) + fib_recursive_term(i - 2)
+
+ if n < 0:
+ raise ValueError("n is negative")
+ return [fib_recursive_term(i) for i in range(n + 1)]
+
+
+def fib_recursive_cached(n: int) -> list[int]:
+ """
+ Calculates the first n (0-indexed) Fibonacci numbers using recursion
+ >>> fib_iterative(0)
+ [0]
+ >>> fib_iterative(1)
+ [0, 1]
+ >>> fib_iterative(5)
+ [0, 1, 1, 2, 3, 5]
+ >>> fib_iterative(10)
+ [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+ >>> fib_iterative(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: n is negative
+ """
+
+ @functools.cache
+ def fib_recursive_term(i: int) -> int:
+ """
+ Calculates the i-th (0-indexed) Fibonacci number using recursion
+ """
+ if i < 0:
+ raise ValueError("n is negative")
+ if i < 2:
+ return i
+ return fib_recursive_term(i - 1) + fib_recursive_term(i - 2)
+
+ if n < 0:
+ raise ValueError("n is negative")
+ return [fib_recursive_term(i) for i in range(n + 1)]
+
+
+def fib_memoization(n: int) -> list[int]:
+ """
+ Calculates the first n (0-indexed) Fibonacci numbers using memoization
+ >>> fib_memoization(0)
+ [0]
+ >>> fib_memoization(1)
+ [0, 1]
+ >>> fib_memoization(5)
+ [0, 1, 1, 2, 3, 5]
+ >>> fib_memoization(10)
+ [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+ >>> fib_iterative(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: n is negative
+ """
+ if n < 0:
+ raise ValueError("n is negative")
+ # Cache must be outside recursuive function
+ # other it will reset every time it calls itself.
+ cache: dict[int, int] = {0: 0, 1: 1, 2: 1} # Prefilled cache
+
+ def rec_fn_memoized(num: int) -> int:
+ if num in cache:
+ return cache[num]
+
+ value = rec_fn_memoized(num - 1) + rec_fn_memoized(num - 2)
+ cache[num] = value
+ return value
+
+ return [rec_fn_memoized(i) for i in range(n + 1)]
+
+
+def fib_binet(n: int) -> list[int]:
+ """
+ Calculates the first n (0-indexed) Fibonacci numbers using a simplified form
+ of Binet's formula:
+ https://en.m.wikipedia.org/wiki/Fibonacci_number#Computation_by_rounding
+
+ NOTE 1: this function diverges from fib_iterative at around n = 71, likely
+ due to compounding floating-point arithmetic errors
+
+ NOTE 2: this function doesn't accept n >= 1475 because it overflows
+ thereafter due to the size limitations of Python floats
+ >>> fib_binet(0)
+ [0]
+ >>> fib_binet(1)
+ [0, 1]
+ >>> fib_binet(5)
+ [0, 1, 1, 2, 3, 5]
+ >>> fib_binet(10)
+ [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+ >>> fib_binet(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: n is negative
+ >>> fib_binet(1475)
+ Traceback (most recent call last):
+ ...
+ ValueError: n is too large
+ """
+ if n < 0:
+ raise ValueError("n is negative")
+ if n >= 1475:
+ raise ValueError("n is too large")
+ sqrt_5 = sqrt(5)
+ phi = (1 + sqrt_5) / 2
+ return [round(phi**i / sqrt_5) for i in range(n + 1)]
+
+
+def matrix_pow_np(m: ndarray, power: int) -> ndarray:
+ """
+ Raises a matrix to the power of 'power' using binary exponentiation.
+
+ Args:
+ m: Matrix as a numpy array.
+ power: The power to which the matrix is to be raised.
+
+ Returns:
+ The matrix raised to the power.
+
+ Raises:
+ ValueError: If power is negative.
+
+ >>> m = np.array([[1, 1], [1, 0]], dtype=int)
+ >>> matrix_pow_np(m, 0) # Identity matrix when raised to the power of 0
+ array([[1, 0],
+ [0, 1]])
+
+ >>> matrix_pow_np(m, 1) # Same matrix when raised to the power of 1
+ array([[1, 1],
+ [1, 0]])
+
+ >>> matrix_pow_np(m, 5)
+ array([[8, 5],
+ [5, 3]])
+
+ >>> matrix_pow_np(m, -1)
+ Traceback (most recent call last):
+ ...
+ ValueError: power is negative
+ """
+ result = np.array([[1, 0], [0, 1]], dtype=int) # Identity Matrix
+ base = m
+ if power < 0: # Negative power is not allowed
+ raise ValueError("power is negative")
+ while power:
+ if power % 2 == 1:
+ result = np.dot(result, base)
+ base = np.dot(base, base)
+ power //= 2
+ return result
+
+
+def fib_matrix_np(n: int) -> int:
+ """
+ Calculates the n-th Fibonacci number using matrix exponentiation.
+ https://www.nayuki.io/page/fast-fibonacci-algorithms#:~:text=
+ Summary:%20The%20two%20fast%20Fibonacci%20algorithms%20are%20matrix
+
+ Args:
+ n: Fibonacci sequence index
+
+ Returns:
+ The n-th Fibonacci number.
+
+ Raises:
+ ValueError: If n is negative.
+
+ >>> fib_matrix_np(0)
+ 0
+ >>> fib_matrix_np(1)
+ 1
+ >>> fib_matrix_np(5)
+ 5
+ >>> fib_matrix_np(10)
+ 55
+ >>> fib_matrix_np(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: n is negative
+ """
+ if n < 0:
+ raise ValueError("n is negative")
+ if n == 0:
+ return 0
+
+ m = np.array([[1, 1], [1, 0]], dtype=int)
+ result = matrix_pow_np(m, n - 1)
+ return int(result[0, 0])
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
+ # Time on an M1 MacBook Pro -- Fastest to slowest
+ num = 30
+ time_func(fib_iterative_yield, num) # 0.0012 ms
+ time_func(fib_iterative, num) # 0.0031 ms
+ time_func(fib_binet, num) # 0.0062 ms
+ time_func(fib_memoization, num) # 0.0100 ms
+ time_func(fib_recursive_cached, num) # 0.0153 ms
+ time_func(fib_recursive, num) # 257.0910 ms
+ time_func(fib_matrix_np, num) # 0.0000 ms
diff --git a/maths/fibonacci_sequence_recursion.py b/maths/fibonacci_sequence_recursion.py
deleted file mode 100644
index 794b9fc0bd3a..000000000000
--- a/maths/fibonacci_sequence_recursion.py
+++ /dev/null
@@ -1,22 +0,0 @@
-# Fibonacci Sequence Using Recursion
-
-
-def recur_fibo(n: int) -> int:
- """
- >>> [recur_fibo(i) for i in range(12)]
- [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
- """
- return n if n <= 1 else recur_fibo(n - 1) + recur_fibo(n - 2)
-
-
-def main() -> None:
- limit = int(input("How many terms to include in fibonacci series: "))
- if limit > 0:
- print(f"The first {limit} terms of the fibonacci series are as follows:")
- print([recur_fibo(n) for n in range(limit)])
- else:
- print("Please enter a positive integer: ")
-
-
-if __name__ == "__main__":
- main()
diff --git a/maths/find_max.py b/maths/find_max.py
index 4d92e37eb2e1..4765d300634e 100644
--- a/maths/find_max.py
+++ b/maths/find_max.py
@@ -1,25 +1,84 @@
-# NguyenU
+from __future__ import annotations
-def find_max(nums):
+def find_max_iterative(nums: list[int | float]) -> int | float:
"""
>>> for nums in ([3, 2, 1], [-3, -2, -1], [3, -3, 0], [3.0, 3.1, 2.9]):
- ... find_max(nums) == max(nums)
+ ... find_max_iterative(nums) == max(nums)
True
True
True
True
+ >>> find_max_iterative([2, 4, 9, 7, 19, 94, 5])
+ 94
+ >>> find_max_iterative([])
+ Traceback (most recent call last):
+ ...
+ ValueError: find_max_iterative() arg is an empty sequence
"""
+ if len(nums) == 0:
+ raise ValueError("find_max_iterative() arg is an empty sequence")
max_num = nums[0]
for x in nums:
- if x > max_num:
+ if x > max_num: # noqa: PLR1730
max_num = x
return max_num
-def main():
- print(find_max([2, 4, 9, 7, 19, 94, 5])) # 94
+# Divide and Conquer algorithm
+def find_max_recursive(nums: list[int | float], left: int, right: int) -> int | float:
+ """
+ find max value in list
+ :param nums: contains elements
+ :param left: index of first element
+ :param right: index of last element
+ :return: max in nums
+
+ >>> for nums in ([3, 2, 1], [-3, -2, -1], [3, -3, 0], [3.0, 3.1, 2.9]):
+ ... find_max_recursive(nums, 0, len(nums) - 1) == max(nums)
+ True
+ True
+ True
+ True
+ >>> nums = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
+ >>> find_max_recursive(nums, 0, len(nums) - 1) == max(nums)
+ True
+ >>> find_max_recursive([], 0, 0)
+ Traceback (most recent call last):
+ ...
+ ValueError: find_max_recursive() arg is an empty sequence
+ >>> find_max_recursive(nums, 0, len(nums)) == max(nums)
+ Traceback (most recent call last):
+ ...
+ IndexError: list index out of range
+ >>> find_max_recursive(nums, -len(nums), -1) == max(nums)
+ True
+ >>> find_max_recursive(nums, -len(nums) - 1, -1) == max(nums)
+ Traceback (most recent call last):
+ ...
+ IndexError: list index out of range
+ """
+ if len(nums) == 0:
+ raise ValueError("find_max_recursive() arg is an empty sequence")
+ if (
+ left >= len(nums)
+ or left < -len(nums)
+ or right >= len(nums)
+ or right < -len(nums)
+ ):
+ raise IndexError("list index out of range")
+ if left == right:
+ return nums[left]
+ mid = (left + right) >> 1 # the middle
+ left_max = find_max_recursive(nums, left, mid) # find max in range[left, mid]
+ right_max = find_max_recursive(
+ nums, mid + 1, right
+ ) # find max in range[mid + 1, right]
+
+ return left_max if left_max >= right_max else right_max
if __name__ == "__main__":
- main()
+ import doctest
+
+ doctest.testmod(verbose=True)
diff --git a/maths/find_max_recursion.py b/maths/find_max_recursion.py
deleted file mode 100644
index 03fb81950dcb..000000000000
--- a/maths/find_max_recursion.py
+++ /dev/null
@@ -1,25 +0,0 @@
-# Divide and Conquer algorithm
-def find_max(nums, left, right):
- """
- find max value in list
- :param nums: contains elements
- :param left: index of first element
- :param right: index of last element
- :return: max in nums
-
- >>> nums = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
- >>> find_max(nums, 0, len(nums) - 1) == max(nums)
- True
- """
- if left == right:
- return nums[left]
- mid = (left + right) >> 1 # the middle
- left_max = find_max(nums, left, mid) # find max in range[left, mid]
- right_max = find_max(nums, mid + 1, right) # find max in range[mid + 1, right]
-
- return left_max if left_max >= right_max else right_max
-
-
-if __name__ == "__main__":
- nums = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
- assert find_max(nums, 0, len(nums) - 1) == 10
diff --git a/maths/find_min.py b/maths/find_min.py
index 2af2e44ba353..762562e36ef9 100644
--- a/maths/find_min.py
+++ b/maths/find_min.py
@@ -1,26 +1,87 @@
-def find_min(nums):
+from __future__ import annotations
+
+
+def find_min_iterative(nums: list[int | float]) -> int | float:
"""
Find Minimum Number in a List
:param nums: contains elements
:return: min number in list
>>> for nums in ([3, 2, 1], [-3, -2, -1], [3, -3, 0], [3.0, 3.1, 2.9]):
- ... find_min(nums) == min(nums)
+ ... find_min_iterative(nums) == min(nums)
True
True
True
True
+ >>> find_min_iterative([0, 1, 2, 3, 4, 5, -3, 24, -56])
+ -56
+ >>> find_min_iterative([])
+ Traceback (most recent call last):
+ ...
+ ValueError: find_min_iterative() arg is an empty sequence
"""
+ if len(nums) == 0:
+ raise ValueError("find_min_iterative() arg is an empty sequence")
min_num = nums[0]
for num in nums:
- if min_num > num:
- min_num = num
+ min_num = min(min_num, num)
return min_num
-def main():
- assert find_min([0, 1, 2, 3, 4, 5, -3, 24, -56]) == -56
+# Divide and Conquer algorithm
+def find_min_recursive(nums: list[int | float], left: int, right: int) -> int | float:
+ """
+ find min value in list
+ :param nums: contains elements
+ :param left: index of first element
+ :param right: index of last element
+ :return: min in nums
+
+ >>> for nums in ([3, 2, 1], [-3, -2, -1], [3, -3, 0], [3.0, 3.1, 2.9]):
+ ... find_min_recursive(nums, 0, len(nums) - 1) == min(nums)
+ True
+ True
+ True
+ True
+ >>> nums = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
+ >>> find_min_recursive(nums, 0, len(nums) - 1) == min(nums)
+ True
+ >>> find_min_recursive([], 0, 0)
+ Traceback (most recent call last):
+ ...
+ ValueError: find_min_recursive() arg is an empty sequence
+ >>> find_min_recursive(nums, 0, len(nums)) == min(nums)
+ Traceback (most recent call last):
+ ...
+ IndexError: list index out of range
+ >>> find_min_recursive(nums, -len(nums), -1) == min(nums)
+ True
+ >>> find_min_recursive(nums, -len(nums) - 1, -1) == min(nums)
+ Traceback (most recent call last):
+ ...
+ IndexError: list index out of range
+ """
+ if len(nums) == 0:
+ raise ValueError("find_min_recursive() arg is an empty sequence")
+ if (
+ left >= len(nums)
+ or left < -len(nums)
+ or right >= len(nums)
+ or right < -len(nums)
+ ):
+ raise IndexError("list index out of range")
+ if left == right:
+ return nums[left]
+ mid = (left + right) >> 1 # the middle
+ left_min = find_min_recursive(nums, left, mid) # find min in range[left, mid]
+ right_min = find_min_recursive(
+ nums, mid + 1, right
+ ) # find min in range[mid + 1, right]
+
+ return left_min if left_min <= right_min else right_min
if __name__ == "__main__":
- main()
+ import doctest
+
+ doctest.testmod(verbose=True)
diff --git a/maths/find_min_recursion.py b/maths/find_min_recursion.py
deleted file mode 100644
index 4488967cc57a..000000000000
--- a/maths/find_min_recursion.py
+++ /dev/null
@@ -1,25 +0,0 @@
-# Divide and Conquer algorithm
-def find_min(nums, left, right):
- """
- find min value in list
- :param nums: contains elements
- :param left: index of first element
- :param right: index of last element
- :return: min in nums
-
- >>> nums = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
- >>> find_min(nums, 0, len(nums) - 1) == min(nums)
- True
- """
- if left == right:
- return nums[left]
- mid = (left + right) >> 1 # the middle
- left_min = find_min(nums, left, mid) # find min in range[left, mid]
- right_min = find_min(nums, mid + 1, right) # find min in range[mid + 1, right]
-
- return left_min if left_min <= right_min else right_min
-
-
-if __name__ == "__main__":
- nums = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
- assert find_min(nums, 0, len(nums) - 1) == 1
diff --git a/maths/floor.py b/maths/floor.py
index 482250f5e59e..8bbcb21aa6e4 100644
--- a/maths/floor.py
+++ b/maths/floor.py
@@ -3,7 +3,7 @@
"""
-def floor(x) -> int:
+def floor(x: float) -> int:
"""
Return the floor of x as an Integral.
:param x: the number
diff --git a/maths/gamma.py b/maths/gamma.py
index 69cd819ef186..e328cd8b22b7 100644
--- a/maths/gamma.py
+++ b/maths/gamma.py
@@ -1,52 +1,46 @@
+"""
+Gamma function is a very useful tool in math and physics.
+It helps calculating complex integral in a convenient way.
+for more info: https://en.wikipedia.org/wiki/Gamma_function
+In mathematics, the gamma function is one commonly
+used extension of the factorial function to complex numbers.
+The gamma function is defined for all complex numbers except
+the non-positive integers
+Python's Standard Library math.gamma() function overflows around gamma(171.624).
+"""
+
import math
from numpy import inf
from scipy.integrate import quad
-def gamma(num: float) -> float:
+def gamma_iterative(num: float) -> float:
"""
- https://en.wikipedia.org/wiki/Gamma_function
- In mathematics, the gamma function is one commonly
- used extension of the factorial function to complex numbers.
- The gamma function is defined for all complex numbers except the non-positive
- integers
-
+ Calculates the value of Gamma function of num
+ where num is either an integer (1, 2, 3..) or a half-integer (0.5, 1.5, 2.5 ...).
- >>> gamma(-1)
+ >>> gamma_iterative(-1)
Traceback (most recent call last):
...
ValueError: math domain error
-
-
-
- >>> gamma(0)
+ >>> gamma_iterative(0)
Traceback (most recent call last):
...
ValueError: math domain error
-
-
- >>> gamma(9)
+ >>> gamma_iterative(9)
40320.0
-
>>> from math import gamma as math_gamma
- >>> all(.99999999 < gamma(i) / math_gamma(i) <= 1.000000001
+ >>> all(.99999999 < gamma_iterative(i) / math_gamma(i) <= 1.000000001
... for i in range(1, 50))
True
-
-
- >>> from math import gamma as math_gamma
- >>> gamma(-1)/math_gamma(-1) <= 1.000000001
+ >>> gamma_iterative(-1)/math_gamma(-1) <= 1.000000001
Traceback (most recent call last):
...
ValueError: math domain error
-
-
- >>> from math import gamma as math_gamma
- >>> gamma(3.3) - math_gamma(3.3) <= 0.00000001
+ >>> gamma_iterative(3.3) - math_gamma(3.3) <= 0.00000001
True
"""
-
if num <= 0:
raise ValueError("math domain error")
@@ -57,7 +51,66 @@ def integrand(x: float, z: float) -> float:
return math.pow(x, z - 1) * math.exp(-x)
+def gamma_recursive(num: float) -> float:
+ """
+ Calculates the value of Gamma function of num
+ where num is either an integer (1, 2, 3..) or a half-integer (0.5, 1.5, 2.5 ...).
+ Implemented using recursion
+ Examples:
+ >>> from math import isclose, gamma as math_gamma
+ >>> gamma_recursive(0.5)
+ 1.7724538509055159
+ >>> gamma_recursive(1)
+ 1.0
+ >>> gamma_recursive(2)
+ 1.0
+ >>> gamma_recursive(3.5)
+ 3.3233509704478426
+ >>> gamma_recursive(171.5)
+ 9.483367566824795e+307
+ >>> all(isclose(gamma_recursive(num), math_gamma(num))
+ ... for num in (0.5, 2, 3.5, 171.5))
+ True
+ >>> gamma_recursive(0)
+ Traceback (most recent call last):
+ ...
+ ValueError: math domain error
+ >>> gamma_recursive(-1.1)
+ Traceback (most recent call last):
+ ...
+ ValueError: math domain error
+ >>> gamma_recursive(-4)
+ Traceback (most recent call last):
+ ...
+ ValueError: math domain error
+ >>> gamma_recursive(172)
+ Traceback (most recent call last):
+ ...
+ OverflowError: math range error
+ >>> gamma_recursive(1.1)
+ Traceback (most recent call last):
+ ...
+ NotImplementedError: num must be an integer or a half-integer
+ """
+ if num <= 0:
+ raise ValueError("math domain error")
+ if num > 171.5:
+ raise OverflowError("math range error")
+ elif num - int(num) not in (0, 0.5):
+ raise NotImplementedError("num must be an integer or a half-integer")
+ elif num == 0.5:
+ return math.sqrt(math.pi)
+ else:
+ return 1.0 if num == 1 else (num - 1) * gamma_recursive(num - 1)
+
+
if __name__ == "__main__":
from doctest import testmod
testmod()
+ num = 1.0
+ while num:
+ num = float(input("Gamma of: "))
+ print(f"gamma_iterative({num}) = {gamma_iterative(num)}")
+ print(f"gamma_recursive({num}) = {gamma_recursive(num)}")
+ print("\nEnter 0 to exit...")
diff --git a/maths/gaussian.py b/maths/gaussian.py
index a5dba50a927d..b1e62ea77fe2 100644
--- a/maths/gaussian.py
+++ b/maths/gaussian.py
@@ -1,21 +1,22 @@
"""
Reference: https://en.wikipedia.org/wiki/Gaussian_function
"""
+
from numpy import exp, pi, sqrt
-def gaussian(x, mu: float = 0.0, sigma: float = 1.0) -> int:
+def gaussian(x, mu: float = 0.0, sigma: float = 1.0) -> float:
"""
- >>> gaussian(1)
+ >>> float(gaussian(1))
0.24197072451914337
- >>> gaussian(24)
+ >>> float(gaussian(24))
3.342714441794458e-126
- >>> gaussian(1, 4, 2)
+ >>> float(gaussian(1, 4, 2))
0.06475879783294587
- >>> gaussian(1, 5, 3)
+ >>> float(gaussian(1, 5, 3))
0.05467002489199788
Supports NumPy Arrays
@@ -28,7 +29,7 @@ def gaussian(x, mu: float = 0.0, sigma: float = 1.0) -> int:
5.05227108e-15, 1.02797736e-18, 7.69459863e-23, 2.11881925e-27,
2.14638374e-32, 7.99882776e-38, 1.09660656e-43])
- >>> gaussian(15)
+ >>> float(gaussian(15))
5.530709549844416e-50
>>> gaussian([1,2, 'string'])
@@ -46,13 +47,13 @@ def gaussian(x, mu: float = 0.0, sigma: float = 1.0) -> int:
...
OverflowError: (34, 'Result too large')
- >>> gaussian(10**-326)
+ >>> float(gaussian(10**-326))
0.3989422804014327
- >>> gaussian(2523, mu=234234, sigma=3425)
+ >>> float(gaussian(2523, mu=234234, sigma=3425))
0.0
"""
- return 1 / sqrt(2 * pi * sigma ** 2) * exp(-((x - mu) ** 2) / (2 * sigma ** 2))
+ return 1 / sqrt(2 * pi * sigma**2) * exp(-((x - mu) ** 2) / (2 * sigma**2))
if __name__ == "__main__":
diff --git a/maths/gcd_of_n_numbers.py b/maths/gcd_of_n_numbers.py
new file mode 100644
index 000000000000..63236c236ada
--- /dev/null
+++ b/maths/gcd_of_n_numbers.py
@@ -0,0 +1,109 @@
+"""
+Gcd of N Numbers
+Reference: https://en.wikipedia.org/wiki/Greatest_common_divisor
+"""
+
+from collections import Counter
+
+
+def get_factors(
+ number: int, factors: Counter | None = None, factor: int = 2
+) -> Counter:
+ """
+ this is a recursive function for get all factors of number
+ >>> get_factors(45)
+ Counter({3: 2, 5: 1})
+ >>> get_factors(2520)
+ Counter({2: 3, 3: 2, 5: 1, 7: 1})
+ >>> get_factors(23)
+ Counter({23: 1})
+ >>> get_factors(0)
+ Traceback (most recent call last):
+ ...
+ TypeError: number must be integer and greater than zero
+ >>> get_factors(-1)
+ Traceback (most recent call last):
+ ...
+ TypeError: number must be integer and greater than zero
+ >>> get_factors(1.5)
+ Traceback (most recent call last):
+ ...
+ TypeError: number must be integer and greater than zero
+
+ factor can be all numbers from 2 to number that we check if number % factor == 0
+ if it is equal to zero, we check again with number // factor
+ else we increase factor by one
+ """
+
+ match number:
+ case int(number) if number == 1:
+ return Counter({1: 1})
+ case int(num) if number > 0:
+ number = num
+ case _:
+ raise TypeError("number must be integer and greater than zero")
+
+ factors = factors or Counter()
+
+ if number == factor: # break condition
+ # all numbers are factors of itself
+ factors[factor] += 1
+ return factors
+
+ if number % factor > 0:
+ # if it is greater than zero
+ # so it is not a factor of number and we check next number
+ return get_factors(number, factors, factor + 1)
+
+ factors[factor] += 1
+ # else we update factors (that is Counter(dict-like) type) and check again
+ return get_factors(number // factor, factors, factor)
+
+
+def get_greatest_common_divisor(*numbers: int) -> int:
+ """
+ get gcd of n numbers:
+ >>> get_greatest_common_divisor(18, 45)
+ 9
+ >>> get_greatest_common_divisor(23, 37)
+ 1
+ >>> get_greatest_common_divisor(2520, 8350)
+ 10
+ >>> get_greatest_common_divisor(-10, 20)
+ Traceback (most recent call last):
+ ...
+ Exception: numbers must be integer and greater than zero
+ >>> get_greatest_common_divisor(1.5, 2)
+ Traceback (most recent call last):
+ ...
+ Exception: numbers must be integer and greater than zero
+ >>> get_greatest_common_divisor(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+ 1
+ >>> get_greatest_common_divisor("1", 2, 3, 4, 5, 6, 7, 8, 9, 10)
+ Traceback (most recent call last):
+ ...
+ Exception: numbers must be integer and greater than zero
+ """
+
+ # we just need factors, not numbers itself
+ try:
+ same_factors, *factors = map(get_factors, numbers)
+ except TypeError as e:
+ raise Exception("numbers must be integer and greater than zero") from e
+
+ for factor in factors:
+ same_factors &= factor
+ # get common factor between all
+ # `&` return common elements with smaller value (for Counter type)
+
+ # now, same_factors is something like {2: 2, 3: 4} that means 2 * 2 * 3 * 3 * 3 * 3
+ mult = 1
+ # power each factor and multiply
+ # for {2: 2, 3: 4}, it is [4, 81] and then 324
+ for m in [factor**power for factor, power in same_factors.items()]:
+ mult *= m
+ return mult
+
+
+if __name__ == "__main__":
+ print(get_greatest_common_divisor(18, 45)) # 9
diff --git a/maths/geometric_mean.py b/maths/geometric_mean.py
new file mode 100644
index 000000000000..240d519ad398
--- /dev/null
+++ b/maths/geometric_mean.py
@@ -0,0 +1,55 @@
+"""
+The Geometric Mean of n numbers is defined as the n-th root of the product
+of those numbers. It is used to measure the central tendency of the numbers.
+https://en.wikipedia.org/wiki/Geometric_mean
+"""
+
+
+def compute_geometric_mean(*args: int) -> float:
+ """
+ Return the geometric mean of the argument numbers.
+ >>> compute_geometric_mean(2,8)
+ 4.0
+ >>> compute_geometric_mean('a', 4)
+ Traceback (most recent call last):
+ ...
+ TypeError: Not a Number
+ >>> compute_geometric_mean(5, 125)
+ 25.0
+ >>> compute_geometric_mean(1, 0)
+ 0.0
+ >>> compute_geometric_mean(1, 5, 25, 5)
+ 5.0
+ >>> compute_geometric_mean(2, -2)
+ Traceback (most recent call last):
+ ...
+ ArithmeticError: Cannot Compute Geometric Mean for these numbers.
+ >>> compute_geometric_mean(-5, 25, 1)
+ -5.0
+ """
+ product = 1
+ for number in args:
+ if not isinstance(number, int) and not isinstance(number, float):
+ raise TypeError("Not a Number")
+ product *= number
+ # Cannot calculate the even root for negative product.
+ # Frequently they are restricted to being positive.
+ if product < 0 and len(args) % 2 == 0:
+ raise ArithmeticError("Cannot Compute Geometric Mean for these numbers.")
+ mean = abs(product) ** (1 / len(args))
+ # Since python calculates complex roots for negative products with odd roots.
+ if product < 0:
+ mean = -mean
+ # Since it does floating point arithmetic, it gives 64**(1/3) as 3.99999996
+ possible_mean = float(round(mean))
+ # To check if the rounded number is actually the mean.
+ if possible_mean ** len(args) == product:
+ mean = possible_mean
+ return mean
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod(name="compute_geometric_mean")
+ print(compute_geometric_mean(-3, -27))
diff --git a/maths/germain_primes.py b/maths/germain_primes.py
new file mode 100644
index 000000000000..078d1967f41a
--- /dev/null
+++ b/maths/germain_primes.py
@@ -0,0 +1,72 @@
+"""
+A Sophie Germain prime is any prime p, where 2p + 1 is also prime.
+The second number, 2p + 1 is called a safe prime.
+
+Examples of Germain primes include: 2, 3, 5, 11, 23
+
+Their corresponding safe primes: 5, 7, 11, 23, 47
+https://en.wikipedia.org/wiki/Safe_and_Sophie_Germain_primes
+"""
+
+from maths.prime_check import is_prime
+
+
+def is_germain_prime(number: int) -> bool:
+ """Checks if input number and 2*number + 1 are prime.
+
+ >>> is_germain_prime(3)
+ True
+ >>> is_germain_prime(11)
+ True
+ >>> is_germain_prime(4)
+ False
+ >>> is_germain_prime(23)
+ True
+ >>> is_germain_prime(13)
+ False
+ >>> is_germain_prime(20)
+ False
+ >>> is_germain_prime('abc')
+ Traceback (most recent call last):
+ ...
+ TypeError: Input value must be a positive integer. Input value: abc
+ """
+ if not isinstance(number, int) or number < 1:
+ msg = f"Input value must be a positive integer. Input value: {number}"
+ raise TypeError(msg)
+
+ return is_prime(number) and is_prime(2 * number + 1)
+
+
+def is_safe_prime(number: int) -> bool:
+ """Checks if input number and (number - 1)/2 are prime.
+ The smallest safe prime is 5, with the Germain prime is 2.
+
+ >>> is_safe_prime(5)
+ True
+ >>> is_safe_prime(11)
+ True
+ >>> is_safe_prime(1)
+ False
+ >>> is_safe_prime(2)
+ False
+ >>> is_safe_prime(3)
+ False
+ >>> is_safe_prime(47)
+ True
+ >>> is_safe_prime('abc')
+ Traceback (most recent call last):
+ ...
+ TypeError: Input value must be a positive integer. Input value: abc
+ """
+ if not isinstance(number, int) or number < 1:
+ msg = f"Input value must be a positive integer. Input value: {number}"
+ raise TypeError(msg)
+
+ return (number - 1) % 2 == 0 and is_prime(number) and is_prime((number - 1) // 2)
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
diff --git a/maths/hardy_ramanujanalgo.py b/maths/hardy_ramanujanalgo.py
index 90e4913c70a7..31ec76fbe10b 100644
--- a/maths/hardy_ramanujanalgo.py
+++ b/maths/hardy_ramanujanalgo.py
@@ -4,9 +4,9 @@
import math
-def exactPrimeFactorCount(n):
+def exact_prime_factor_count(n: int) -> int:
"""
- >>> exactPrimeFactorCount(51242183)
+ >>> exact_prime_factor_count(51242183)
3
"""
count = 0
@@ -36,8 +36,8 @@ def exactPrimeFactorCount(n):
if __name__ == "__main__":
n = 51242183
- print(f"The number of distinct prime factors is/are {exactPrimeFactorCount(n)}")
- print("The value of log(log(n)) is {:.4f}".format(math.log(math.log(n))))
+ print(f"The number of distinct prime factors is/are {exact_prime_factor_count(n)}")
+ print(f"The value of log(log(n)) is {math.log(math.log(n)):.4f}")
"""
The number of distinct prime factors is/are 3
diff --git a/maths/integer_square_root.py b/maths/integer_square_root.py
new file mode 100644
index 000000000000..27e874a43c79
--- /dev/null
+++ b/maths/integer_square_root.py
@@ -0,0 +1,73 @@
+"""
+Integer Square Root Algorithm -- An efficient method to calculate the square root of a
+non-negative integer 'num' rounded down to the nearest integer. It uses a binary search
+approach to find the integer square root without using any built-in exponent functions
+or operators.
+* https://en.wikipedia.org/wiki/Integer_square_root
+* https://docs.python.org/3/library/math.html#math.isqrt
+Note:
+ - This algorithm is designed for non-negative integers only.
+ - The result is rounded down to the nearest integer.
+ - The algorithm has a time complexity of O(log(x)).
+ - Original algorithm idea based on binary search.
+"""
+
+
+def integer_square_root(num: int) -> int:
+ """
+ Returns the integer square root of a non-negative integer num.
+ Args:
+ num: A non-negative integer.
+ Returns:
+ The integer square root of num.
+ Raises:
+ ValueError: If num is not an integer or is negative.
+ >>> [integer_square_root(i) for i in range(18)]
+ [0, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4]
+ >>> integer_square_root(625)
+ 25
+ >>> integer_square_root(2_147_483_647)
+ 46340
+ >>> from math import isqrt
+ >>> all(integer_square_root(i) == isqrt(i) for i in range(20))
+ True
+ >>> integer_square_root(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: num must be non-negative integer
+ >>> integer_square_root(1.5)
+ Traceback (most recent call last):
+ ...
+ ValueError: num must be non-negative integer
+ >>> integer_square_root("0")
+ Traceback (most recent call last):
+ ...
+ ValueError: num must be non-negative integer
+ """
+ if not isinstance(num, int) or num < 0:
+ raise ValueError("num must be non-negative integer")
+
+ if num < 2:
+ return num
+
+ left_bound = 0
+ right_bound = num // 2
+
+ while left_bound <= right_bound:
+ mid = left_bound + (right_bound - left_bound) // 2
+ mid_squared = mid * mid
+ if mid_squared == num:
+ return mid
+
+ if mid_squared < num:
+ left_bound = mid + 1
+ else:
+ right_bound = mid - 1
+
+ return right_bound
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/interquartile_range.py b/maths/interquartile_range.py
new file mode 100644
index 000000000000..e91a651647d4
--- /dev/null
+++ b/maths/interquartile_range.py
@@ -0,0 +1,67 @@
+"""
+An implementation of interquartile range (IQR) which is a measure of statistical
+dispersion, which is the spread of the data.
+
+The function takes the list of numeric values as input and returns the IQR.
+
+Script inspired by this Wikipedia article:
+https://en.wikipedia.org/wiki/Interquartile_range
+"""
+
+from __future__ import annotations
+
+
+def find_median(nums: list[int | float]) -> float:
+ """
+ This is the implementation of the median.
+ :param nums: The list of numeric nums
+ :return: Median of the list
+ >>> find_median(nums=([1, 2, 2, 3, 4]))
+ 2
+ >>> find_median(nums=([1, 2, 2, 3, 4, 4]))
+ 2.5
+ >>> find_median(nums=([-1, 2, 0, 3, 4, -4]))
+ 1.5
+ >>> find_median(nums=([1.1, 2.2, 2, 3.3, 4.4, 4]))
+ 2.65
+ """
+ div, mod = divmod(len(nums), 2)
+ if mod:
+ return nums[div]
+ return (nums[div] + nums[(div) - 1]) / 2
+
+
+def interquartile_range(nums: list[int | float]) -> float:
+ """
+ Return the interquartile range for a list of numeric values.
+ :param nums: The list of numeric values.
+ :return: interquartile range
+
+ >>> interquartile_range(nums=[4, 1, 2, 3, 2])
+ 2.0
+ >>> interquartile_range(nums = [-2, -7, -10, 9, 8, 4, -67, 45])
+ 17.0
+ >>> interquartile_range(nums = [-2.1, -7.1, -10.1, 9.1, 8.1, 4.1, -67.1, 45.1])
+ 17.2
+ >>> interquartile_range(nums = [0, 0, 0, 0, 0])
+ 0.0
+ >>> interquartile_range(nums=[])
+ Traceback (most recent call last):
+ ...
+ ValueError: The list is empty. Provide a non-empty list.
+ """
+ if not nums:
+ raise ValueError("The list is empty. Provide a non-empty list.")
+ nums.sort()
+ length = len(nums)
+ div, mod = divmod(length, 2)
+ q1 = find_median(nums[:div])
+ half_length = sum((div, mod))
+ q3 = find_median(nums[half_length:length])
+ return q3 - q1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/is_int_palindrome.py b/maths/is_int_palindrome.py
new file mode 100644
index 000000000000..63dc9e2138e8
--- /dev/null
+++ b/maths/is_int_palindrome.py
@@ -0,0 +1,34 @@
+def is_int_palindrome(num: int) -> bool:
+ """
+ Returns whether `num` is a palindrome or not
+ (see for reference https://en.wikipedia.org/wiki/Palindromic_number).
+
+ >>> is_int_palindrome(-121)
+ False
+ >>> is_int_palindrome(0)
+ True
+ >>> is_int_palindrome(10)
+ False
+ >>> is_int_palindrome(11)
+ True
+ >>> is_int_palindrome(101)
+ True
+ >>> is_int_palindrome(120)
+ False
+ """
+ if num < 0:
+ return False
+
+ num_copy: int = num
+ rev_num: int = 0
+ while num > 0:
+ rev_num = rev_num * 10 + (num % 10)
+ num //= 10
+
+ return num_copy == rev_num
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/is_ip_v4_address_valid.py b/maths/is_ip_v4_address_valid.py
new file mode 100644
index 000000000000..305afabffed3
--- /dev/null
+++ b/maths/is_ip_v4_address_valid.py
@@ -0,0 +1,75 @@
+"""
+wiki: https://en.wikipedia.org/wiki/IPv4
+
+Is IP v4 address valid?
+A valid IP address must be four octets in the form of A.B.C.D,
+where A, B, C and D are numbers from 0-255
+for example: 192.168.23.1, 172.255.255.255 are valid IP address
+ 192.168.256.0, 256.192.3.121 are invalid IP address
+"""
+
+
+def is_ip_v4_address_valid(ip: str) -> bool:
+ """
+ print "Valid IP address" If IP is valid.
+ or
+ print "Invalid IP address" If IP is invalid.
+
+ >>> is_ip_v4_address_valid("192.168.0.23")
+ True
+
+ >>> is_ip_v4_address_valid("192.256.15.8")
+ False
+
+ >>> is_ip_v4_address_valid("172.100.0.8")
+ True
+
+ >>> is_ip_v4_address_valid("255.256.0.256")
+ False
+
+ >>> is_ip_v4_address_valid("1.2.33333333.4")
+ False
+
+ >>> is_ip_v4_address_valid("1.2.-3.4")
+ False
+
+ >>> is_ip_v4_address_valid("1.2.3")
+ False
+
+ >>> is_ip_v4_address_valid("1.2.3.4.5")
+ False
+
+ >>> is_ip_v4_address_valid("1.2.A.4")
+ False
+
+ >>> is_ip_v4_address_valid("0.0.0.0")
+ True
+
+ >>> is_ip_v4_address_valid("1.2.3.")
+ False
+
+ >>> is_ip_v4_address_valid("1.2.3.05")
+ False
+ """
+ octets = ip.split(".")
+ if len(octets) != 4:
+ return False
+
+ for octet in octets:
+ if not octet.isdigit():
+ return False
+
+ number = int(octet)
+ if len(str(number)) != len(octet):
+ return False
+
+ if not 0 <= number <= 255:
+ return False
+
+ return True
+
+
+if __name__ == "__main__":
+ ip = input().strip()
+ valid_or_invalid = "valid" if is_ip_v4_address_valid(ip) else "invalid"
+ print(f"{ip} is a {valid_or_invalid} IPv4 address.")
diff --git a/maths/is_square_free.py b/maths/is_square_free.py
index 8d83d95ffb67..a336c37e8dbc 100644
--- a/maths/is_square_free.py
+++ b/maths/is_square_free.py
@@ -1,8 +1,9 @@
"""
References: wikipedia:square free number
-python/black : True
-flake8 : True
+psf/black : True
+ruff : True
"""
+
from __future__ import annotations
@@ -15,7 +16,7 @@ def is_square_free(factors: list[int]) -> bool:
False
These are wrong but should return some value
- it simply checks for repition in the numbers.
+ it simply checks for repetition in the numbers.
>>> is_square_free([1, 3, 4, 'sd', 0.0])
True
diff --git a/maths/jaccard_similarity.py b/maths/jaccard_similarity.py
index 4f24d308f340..6b6243458fa8 100644
--- a/maths/jaccard_similarity.py
+++ b/maths/jaccard_similarity.py
@@ -14,7 +14,11 @@
"""
-def jaccard_similariy(setA, setB, alternativeUnion=False):
+def jaccard_similarity(
+ set_a: set[str] | list[str] | tuple[str],
+ set_b: set[str] | list[str] | tuple[str],
+ alternative_union=False,
+):
"""
Finds the jaccard similarity between two sets.
Essentially, its intersection over union.
@@ -24,8 +28,8 @@ def jaccard_similariy(setA, setB, alternativeUnion=False):
of a set with itself be 1/2 instead of 1. [MMDS 2nd Edition, Page 77]
Parameters:
- :setA (set,list,tuple): A non-empty set/list
- :setB (set,list,tuple): A non-empty set/list
+ :set_a (set,list,tuple): A non-empty set/list
+ :set_b (set,list,tuple): A non-empty set/list
:alternativeUnion (boolean): If True, use sum of number of
items as union
@@ -33,48 +37,59 @@ def jaccard_similariy(setA, setB, alternativeUnion=False):
(float) The jaccard similarity between the two sets.
Examples:
- >>> setA = {'a', 'b', 'c', 'd', 'e'}
- >>> setB = {'c', 'd', 'e', 'f', 'h', 'i'}
- >>> jaccard_similariy(setA,setB)
+ >>> set_a = {'a', 'b', 'c', 'd', 'e'}
+ >>> set_b = {'c', 'd', 'e', 'f', 'h', 'i'}
+ >>> jaccard_similarity(set_a, set_b)
0.375
-
- >>> jaccard_similariy(setA,setA)
+ >>> jaccard_similarity(set_a, set_a)
1.0
-
- >>> jaccard_similariy(setA,setA,True)
+ >>> jaccard_similarity(set_a, set_a, True)
0.5
-
- >>> setA = ['a', 'b', 'c', 'd', 'e']
- >>> setB = ('c', 'd', 'e', 'f', 'h', 'i')
- >>> jaccard_similariy(setA,setB)
+ >>> set_a = ['a', 'b', 'c', 'd', 'e']
+ >>> set_b = ('c', 'd', 'e', 'f', 'h', 'i')
+ >>> jaccard_similarity(set_a, set_b)
+ 0.375
+ >>> set_a = ('c', 'd', 'e', 'f', 'h', 'i')
+ >>> set_b = ['a', 'b', 'c', 'd', 'e']
+ >>> jaccard_similarity(set_a, set_b)
0.375
+ >>> set_a = ('c', 'd', 'e', 'f', 'h', 'i')
+ >>> set_b = ['a', 'b', 'c', 'd']
+ >>> jaccard_similarity(set_a, set_b, True)
+ 0.2
+ >>> set_a = {'a', 'b'}
+ >>> set_b = ['c', 'd']
+ >>> jaccard_similarity(set_a, set_b)
+ Traceback (most recent call last):
+ ...
+ ValueError: Set a and b must either both be sets or be either a list or a tuple.
"""
- if isinstance(setA, set) and isinstance(setB, set):
+ if isinstance(set_a, set) and isinstance(set_b, set):
+ intersection_length = len(set_a.intersection(set_b))
- intersection = len(setA.intersection(setB))
-
- if alternativeUnion:
- union = len(setA) + len(setB)
+ if alternative_union:
+ union_length = len(set_a) + len(set_b)
else:
- union = len(setA.union(setB))
-
- return intersection / union
+ union_length = len(set_a.union(set_b))
- if isinstance(setA, (list, tuple)) and isinstance(setB, (list, tuple)):
+ return intersection_length / union_length
- intersection = [element for element in setA if element in setB]
+ elif isinstance(set_a, (list, tuple)) and isinstance(set_b, (list, tuple)):
+ intersection = [element for element in set_a if element in set_b]
- if alternativeUnion:
- union = len(setA) + len(setB)
+ if alternative_union:
+ return len(intersection) / (len(set_a) + len(set_b))
else:
- union = setA + [element for element in setB if element not in setA]
-
- return len(intersection) / len(union)
+ # Cast set_a to list because tuples cannot be mutated
+ union = list(set_a) + [element for element in set_b if element not in set_a]
+ return len(intersection) / len(union)
+ raise ValueError(
+ "Set a and b must either both be sets or be either a list or a tuple."
+ )
if __name__ == "__main__":
-
- setA = {"a", "b", "c", "d", "e"}
- setB = {"c", "d", "e", "f", "h", "i"}
- print(jaccard_similariy(setA, setB))
+ set_a = {"a", "b", "c", "d", "e"}
+ set_b = {"c", "d", "e", "f", "h", "i"}
+ print(jaccard_similarity(set_a, set_b))
diff --git a/maths/joint_probability_distribution.py b/maths/joint_probability_distribution.py
new file mode 100644
index 000000000000..6fbcea40c358
--- /dev/null
+++ b/maths/joint_probability_distribution.py
@@ -0,0 +1,124 @@
+"""
+Calculate joint probability distribution
+https://en.wikipedia.org/wiki/Joint_probability_distribution
+"""
+
+
+def joint_probability_distribution(
+ x_values: list[int],
+ y_values: list[int],
+ x_probabilities: list[float],
+ y_probabilities: list[float],
+) -> dict:
+ """
+ >>> joint_distribution = joint_probability_distribution(
+ ... [1, 2], [-2, 5, 8], [0.7, 0.3], [0.3, 0.5, 0.2]
+ ... )
+ >>> from math import isclose
+ >>> isclose(joint_distribution.pop((1, 8)), 0.14)
+ True
+ >>> joint_distribution
+ {(1, -2): 0.21, (1, 5): 0.35, (2, -2): 0.09, (2, 5): 0.15, (2, 8): 0.06}
+ """
+ return {
+ (x, y): x_prob * y_prob
+ for x, x_prob in zip(x_values, x_probabilities)
+ for y, y_prob in zip(y_values, y_probabilities)
+ }
+
+
+# Function to calculate the expectation (mean)
+def expectation(values: list, probabilities: list) -> float:
+ """
+ >>> from math import isclose
+ >>> isclose(expectation([1, 2], [0.7, 0.3]), 1.3)
+ True
+ """
+ return sum(x * p for x, p in zip(values, probabilities))
+
+
+# Function to calculate the variance
+def variance(values: list[int], probabilities: list[float]) -> float:
+ """
+ >>> from math import isclose
+ >>> isclose(variance([1,2],[0.7,0.3]), 0.21)
+ True
+ """
+ mean = expectation(values, probabilities)
+ return sum((x - mean) ** 2 * p for x, p in zip(values, probabilities))
+
+
+# Function to calculate the covariance
+def covariance(
+ x_values: list[int],
+ y_values: list[int],
+ x_probabilities: list[float],
+ y_probabilities: list[float],
+) -> float:
+ """
+ >>> covariance([1, 2], [-2, 5, 8], [0.7, 0.3], [0.3, 0.5, 0.2])
+ -2.7755575615628914e-17
+ """
+ mean_x = expectation(x_values, x_probabilities)
+ mean_y = expectation(y_values, y_probabilities)
+ return sum(
+ (x - mean_x) * (y - mean_y) * px * py
+ for x, px in zip(x_values, x_probabilities)
+ for y, py in zip(y_values, y_probabilities)
+ )
+
+
+# Function to calculate the standard deviation
+def standard_deviation(variance: float) -> float:
+ """
+ >>> standard_deviation(0.21)
+ 0.458257569495584
+ """
+ return variance**0.5
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
+ # Input values for X and Y
+ x_vals = input("Enter values of X separated by spaces: ").split()
+ y_vals = input("Enter values of Y separated by spaces: ").split()
+
+ # Convert input values to integers
+ x_values = [int(x) for x in x_vals]
+ y_values = [int(y) for y in y_vals]
+
+ # Input probabilities for X and Y
+ x_probs = input("Enter probabilities for X separated by spaces: ").split()
+ y_probs = input("Enter probabilities for Y separated by spaces: ").split()
+ assert len(x_values) == len(x_probs)
+ assert len(y_values) == len(y_probs)
+
+ # Convert input probabilities to floats
+ x_probabilities = [float(p) for p in x_probs]
+ y_probabilities = [float(p) for p in y_probs]
+
+ # Calculate the joint probability distribution
+ jpd = joint_probability_distribution(
+ x_values, y_values, x_probabilities, y_probabilities
+ )
+
+ # Print the joint probability distribution
+ print(
+ "\n".join(
+ f"P(X={x}, Y={y}) = {probability}" for (x, y), probability in jpd.items()
+ )
+ )
+ mean_xy = expectation(
+ [x * y for x in x_values for y in y_values],
+ [px * py for px in x_probabilities for py in y_probabilities],
+ )
+ print(f"x mean: {expectation(x_values, x_probabilities) = }")
+ print(f"y mean: {expectation(y_values, y_probabilities) = }")
+ print(f"xy mean: {mean_xy}")
+ print(f"x: {variance(x_values, x_probabilities) = }")
+ print(f"y: {variance(y_values, y_probabilities) = }")
+ print(f"{covariance(x_values, y_values, x_probabilities, y_probabilities) = }")
+ print(f"x: {standard_deviation(variance(x_values, x_probabilities)) = }")
+ print(f"y: {standard_deviation(variance(y_values, y_probabilities)) = }")
diff --git a/maths/josephus_problem.py b/maths/josephus_problem.py
new file mode 100644
index 000000000000..271292ba1d9f
--- /dev/null
+++ b/maths/josephus_problem.py
@@ -0,0 +1,130 @@
+"""
+The Josephus problem is a famous theoretical problem related to a certain
+counting-out game. This module provides functions to solve the Josephus problem
+for num_people and a step_size.
+
+The Josephus problem is defined as follows:
+- num_people are standing in a circle.
+- Starting with a specified person, you count around the circle,
+ skipping a fixed number of people (step_size).
+- The person at which you stop counting is eliminated from the circle.
+- The counting continues until only one person remains.
+
+For more information about the Josephus problem, refer to:
+https://en.wikipedia.org/wiki/Josephus_problem
+"""
+
+
+def josephus_recursive(num_people: int, step_size: int) -> int:
+ """
+ Solve the Josephus problem for num_people and a step_size recursively.
+
+ Args:
+ num_people: A positive integer representing the number of people.
+ step_size: A positive integer representing the step size for elimination.
+
+ Returns:
+ The position of the last person remaining.
+
+ Raises:
+ ValueError: If num_people or step_size is not a positive integer.
+
+ Examples:
+ >>> josephus_recursive(7, 3)
+ 3
+ >>> josephus_recursive(10, 2)
+ 4
+ >>> josephus_recursive(0, 2)
+ Traceback (most recent call last):
+ ...
+ ValueError: num_people or step_size is not a positive integer.
+ >>> josephus_recursive(1.9, 2)
+ Traceback (most recent call last):
+ ...
+ ValueError: num_people or step_size is not a positive integer.
+ >>> josephus_recursive(-2, 2)
+ Traceback (most recent call last):
+ ...
+ ValueError: num_people or step_size is not a positive integer.
+ >>> josephus_recursive(7, 0)
+ Traceback (most recent call last):
+ ...
+ ValueError: num_people or step_size is not a positive integer.
+ >>> josephus_recursive(7, -2)
+ Traceback (most recent call last):
+ ...
+ ValueError: num_people or step_size is not a positive integer.
+ >>> josephus_recursive(1_000, 0.01)
+ Traceback (most recent call last):
+ ...
+ ValueError: num_people or step_size is not a positive integer.
+ >>> josephus_recursive("cat", "dog")
+ Traceback (most recent call last):
+ ...
+ ValueError: num_people or step_size is not a positive integer.
+ """
+ if (
+ not isinstance(num_people, int)
+ or not isinstance(step_size, int)
+ or num_people <= 0
+ or step_size <= 0
+ ):
+ raise ValueError("num_people or step_size is not a positive integer.")
+
+ if num_people == 1:
+ return 0
+
+ return (josephus_recursive(num_people - 1, step_size) + step_size) % num_people
+
+
+def find_winner(num_people: int, step_size: int) -> int:
+ """
+ Find the winner of the Josephus problem for num_people and a step_size.
+
+ Args:
+ num_people (int): Number of people.
+ step_size (int): Step size for elimination.
+
+ Returns:
+ int: The position of the last person remaining (1-based index).
+
+ Examples:
+ >>> find_winner(7, 3)
+ 4
+ >>> find_winner(10, 2)
+ 5
+ """
+ return josephus_recursive(num_people, step_size) + 1
+
+
+def josephus_iterative(num_people: int, step_size: int) -> int:
+ """
+ Solve the Josephus problem for num_people and a step_size iteratively.
+
+ Args:
+ num_people (int): The number of people in the circle.
+ step_size (int): The number of steps to take before eliminating someone.
+
+ Returns:
+ int: The position of the last person standing.
+
+ Examples:
+ >>> josephus_iterative(5, 2)
+ 3
+ >>> josephus_iterative(7, 3)
+ 4
+ """
+ circle = list(range(1, num_people + 1))
+ current = 0
+
+ while len(circle) > 1:
+ current = (current + step_size - 1) % len(circle)
+ circle.pop(current)
+
+ return circle[0]
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/juggler_sequence.py b/maths/juggler_sequence.py
new file mode 100644
index 000000000000..7f65d1dff925
--- /dev/null
+++ b/maths/juggler_sequence.py
@@ -0,0 +1,63 @@
+"""
+== Juggler Sequence ==
+Juggler sequence start with any positive integer n. The next term is
+obtained as follows:
+ If n term is even, the next term is floor value of square root of n .
+ If n is odd, the next term is floor value of 3 time the square root of n.
+
+https://en.wikipedia.org/wiki/Juggler_sequence
+"""
+
+# Author : Akshay Dubey (https://github.com/itsAkshayDubey)
+import math
+
+
+def juggler_sequence(number: int) -> list[int]:
+ """
+ >>> juggler_sequence(0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input value of [number=0] must be a positive integer
+ >>> juggler_sequence(1)
+ [1]
+ >>> juggler_sequence(2)
+ [2, 1]
+ >>> juggler_sequence(3)
+ [3, 5, 11, 36, 6, 2, 1]
+ >>> juggler_sequence(5)
+ [5, 11, 36, 6, 2, 1]
+ >>> juggler_sequence(10)
+ [10, 3, 5, 11, 36, 6, 2, 1]
+ >>> juggler_sequence(25)
+ [25, 125, 1397, 52214, 228, 15, 58, 7, 18, 4, 2, 1]
+ >>> juggler_sequence(6.0)
+ Traceback (most recent call last):
+ ...
+ TypeError: Input value of [number=6.0] must be an integer
+ >>> juggler_sequence(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input value of [number=-1] must be a positive integer
+ """
+ if not isinstance(number, int):
+ msg = f"Input value of [number={number}] must be an integer"
+ raise TypeError(msg)
+ if number < 1:
+ msg = f"Input value of [number={number}] must be a positive integer"
+ raise ValueError(msg)
+ sequence = [number]
+ while number != 1:
+ if number % 2 == 0:
+ number = math.floor(math.sqrt(number))
+ else:
+ number = math.floor(
+ math.sqrt(number) * math.sqrt(number) * math.sqrt(number)
+ )
+ sequence.append(number)
+ return sequence
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/kadanes.py b/maths/kadanes.py
deleted file mode 100644
index d239d4a2589b..000000000000
--- a/maths/kadanes.py
+++ /dev/null
@@ -1,65 +0,0 @@
-"""
-Kadane's algorithm to get maximum subarray sum
-https://medium.com/@rsinghal757/kadanes-algorithm-dynamic-programming-how-and-why-does-it-work-3fd8849ed73d
-https://en.wikipedia.org/wiki/Maximum_subarray_problem
-"""
-test_data: tuple = ([-2, -8, -9], [2, 8, 9], [-1, 0, 1], [0, 0], [])
-
-
-def negative_exist(arr: list) -> int:
- """
- >>> negative_exist([-2,-8,-9])
- -2
- >>> [negative_exist(arr) for arr in test_data]
- [-2, 0, 0, 0, 0]
- """
- arr = arr or [0]
- max = arr[0]
- for i in arr:
- if i >= 0:
- return 0
- elif max <= i:
- max = i
- return max
-
-
-def kadanes(arr: list) -> int:
- """
- If negative_exist() returns 0 than this function will execute
- else it will return the value return by negative_exist function
-
- For example: arr = [2, 3, -9, 8, -2]
- Initially we set value of max_sum to 0 and max_till_element to 0 than when
- max_sum is less than max_till particular element it will assign that value to
- max_sum and when value of max_till_sum is less than 0 it will assign 0 to i
- and after that whole process, return the max_sum
- So the output for above arr is 8
-
- >>> kadanes([2, 3, -9, 8, -2])
- 8
- >>> [kadanes(arr) for arr in test_data]
- [-2, 19, 1, 0, 0]
- """
- max_sum = negative_exist(arr)
- if max_sum < 0:
- return max_sum
-
- max_sum = 0
- max_till_element = 0
-
- for i in arr:
- max_till_element += i
- if max_sum <= max_till_element:
- max_sum = max_till_element
- if max_till_element < 0:
- max_till_element = 0
- return max_sum
-
-
-if __name__ == "__main__":
- try:
- print("Enter integer values sepatated by spaces")
- arr = [int(x) for x in input().split()]
- print(f"Maximum subarray sum of {arr} is {kadanes(arr)}")
- except ValueError:
- print("Please enter integer values.")
diff --git a/maths/karatsuba.py b/maths/karatsuba.py
index df29c77a5cf2..0e063fb44b83 100644
--- a/maths/karatsuba.py
+++ b/maths/karatsuba.py
@@ -1,7 +1,7 @@
-""" Multiply two numbers using Karatsuba algorithm """
+"""Multiply two numbers using Karatsuba algorithm"""
-def karatsuba(a, b):
+def karatsuba(a: int, b: int) -> int:
"""
>>> karatsuba(15463, 23489) == 15463 * 23489
True
@@ -10,18 +10,18 @@ def karatsuba(a, b):
"""
if len(str(a)) == 1 or len(str(b)) == 1:
return a * b
- else:
- m1 = max(len(str(a)), len(str(b)))
- m2 = m1 // 2
- a1, a2 = divmod(a, 10 ** m2)
- b1, b2 = divmod(b, 10 ** m2)
+ m1 = max(len(str(a)), len(str(b)))
+ m2 = m1 // 2
- x = karatsuba(a2, b2)
- y = karatsuba((a1 + a2), (b1 + b2))
- z = karatsuba(a1, b1)
+ a1, a2 = divmod(a, 10**m2)
+ b1, b2 = divmod(b, 10**m2)
- return (z * 10 ** (2 * m2)) + ((y - z - x) * 10 ** (m2)) + (x)
+ x = karatsuba(a2, b2)
+ y = karatsuba((a1 + a2), (b1 + b2))
+ z = karatsuba(a1, b1)
+
+ return (z * 10 ** (2 * m2)) + ((y - z - x) * 10 ** (m2)) + (x)
def main():
diff --git a/maths/kth_lexicographic_permutation.py b/maths/kth_lexicographic_permutation.py
index 23eab626fbf8..b85558aca6d4 100644
--- a/maths/kth_lexicographic_permutation.py
+++ b/maths/kth_lexicographic_permutation.py
@@ -1,17 +1,17 @@
-def kthPermutation(k, n):
+def kth_permutation(k, n):
"""
Finds k'th lexicographic permutation (in increasing order) of
0,1,2,...n-1 in O(n^2) time.
Examples:
First permutation is always 0,1,2,...n
- >>> kthPermutation(0,5)
+ >>> kth_permutation(0,5)
[0, 1, 2, 3, 4]
The order of permutation of 0,1,2,3 is [0,1,2,3], [0,1,3,2], [0,2,1,3],
[0,2,3,1], [0,3,1,2], [0,3,2,1], [1,0,2,3], [1,0,3,2], [1,2,0,3],
[1,2,3,0], [1,3,0,2]
- >>> kthPermutation(10,4)
+ >>> kth_permutation(10,4)
[1, 3, 0, 2]
"""
# Factorails from 1! to (n-1)!
diff --git a/maths/largest_of_very_large_numbers.py b/maths/largest_of_very_large_numbers.py
index d2dc0af18126..edee50371e02 100644
--- a/maths/largest_of_very_large_numbers.py
+++ b/maths/largest_of_very_large_numbers.py
@@ -4,14 +4,27 @@
def res(x, y):
+ """
+ Reduces large number to a more manageable number
+ >>> res(5, 7)
+ 4.892790030352132
+ >>> res(0, 5)
+ 0
+ >>> res(3, 0)
+ 1
+ >>> res(-1, 5)
+ Traceback (most recent call last):
+ ...
+ ValueError: math domain error
+ """
if 0 not in (x, y):
# We use the relation x^y = y*log10(x), where 10 is the base.
return y * math.log10(x)
- else:
- if x == 0: # 0 raised to any number is 0
- return 0
- elif y == 0:
- return 1 # any number raised to 0 is 1
+ elif x == 0: # 0 raised to any number is 0
+ return 0
+ elif y == 0:
+ return 1 # any number raised to 0 is 1
+ raise AssertionError("This should never happen")
if __name__ == "__main__": # Main function
diff --git a/maths/least_common_multiple.py b/maths/least_common_multiple.py
index 0d087643e869..a5c4bf8e3625 100644
--- a/maths/least_common_multiple.py
+++ b/maths/least_common_multiple.py
@@ -1,6 +1,8 @@
import unittest
from timeit import timeit
+from maths.greatest_common_divisor import greatest_common_divisor
+
def least_common_multiple_slow(first_num: int, second_num: int) -> int:
"""
@@ -20,26 +22,6 @@ def least_common_multiple_slow(first_num: int, second_num: int) -> int:
return common_mult
-def greatest_common_divisor(a: int, b: int) -> int:
- """
- Calculate Greatest Common Divisor (GCD).
- see greatest_common_divisor.py
- >>> greatest_common_divisor(24, 40)
- 8
- >>> greatest_common_divisor(1, 1)
- 1
- >>> greatest_common_divisor(1, 800)
- 1
- >>> greatest_common_divisor(11, 37)
- 1
- >>> greatest_common_divisor(3, 5)
- 1
- >>> greatest_common_divisor(16, 4)
- 4
- """
- return b if a == 0 else greatest_common_divisor(b % a, a)
-
-
def least_common_multiple_fast(first_num: int, second_num: int) -> int:
"""
Find the least common multiple of two numbers.
@@ -67,8 +49,7 @@ def benchmark():
class TestLeastCommonMultiple(unittest.TestCase):
-
- test_inputs = [
+ test_inputs = (
(10, 20),
(13, 15),
(4, 31),
@@ -78,16 +59,16 @@ class TestLeastCommonMultiple(unittest.TestCase):
(12, 25),
(10, 25),
(6, 9),
- ]
- expected_results = [20, 195, 124, 210, 1462, 60, 300, 50, 18]
+ )
+ expected_results = (20, 195, 124, 210, 1462, 60, 300, 50, 18)
def test_lcm_function(self):
for i, (first_num, second_num) in enumerate(self.test_inputs):
slow_result = least_common_multiple_slow(first_num, second_num)
fast_result = least_common_multiple_fast(first_num, second_num)
with self.subTest(i=i):
- self.assertEqual(slow_result, self.expected_results[i])
- self.assertEqual(fast_result, self.expected_results[i])
+ assert slow_result == self.expected_results[i]
+ assert fast_result == self.expected_results[i]
if __name__ == "__main__":
diff --git a/maths/line_length.py b/maths/line_length.py
index 1d386b44b50d..ed2efc31e96e 100644
--- a/maths/line_length.py
+++ b/maths/line_length.py
@@ -1,14 +1,15 @@
+from __future__ import annotations
+
import math
-from typing import Callable, Union
+from collections.abc import Callable
def line_length(
- fnc: Callable[[Union[int, float]], Union[int, float]],
- x_start: Union[int, float],
- x_end: Union[int, float],
+ fnc: Callable[[float], float],
+ x_start: float,
+ x_end: float,
steps: int = 100,
) -> float:
-
"""
Approximates the arc length of a line segment by treating the curve as a
sequence of linear lines and summing their lengths
@@ -38,8 +39,7 @@ def line_length(
fx1 = fnc(x_start)
length = 0.0
- for i in range(steps):
-
+ for _ in range(steps):
# Approximates curve as a sequence of linear lines and sums their length
x2 = (x_end - x_start) / steps + x1
fx2 = fnc(x2)
diff --git a/maths/liouville_lambda.py b/maths/liouville_lambda.py
new file mode 100644
index 000000000000..1ed228dd5434
--- /dev/null
+++ b/maths/liouville_lambda.py
@@ -0,0 +1,46 @@
+"""
+== Liouville Lambda Function ==
+The Liouville Lambda function, denoted by λ(n)
+and λ(n) is 1 if n is the product of an even number of prime numbers,
+and -1 if it is the product of an odd number of primes.
+
+https://en.wikipedia.org/wiki/Liouville_function
+"""
+
+# Author : Akshay Dubey (https://github.com/itsAkshayDubey)
+from maths.prime_factors import prime_factors
+
+
+def liouville_lambda(number: int) -> int:
+ """
+ This functions takes an integer number as input.
+ returns 1 if n has even number of prime factors and -1 otherwise.
+ >>> liouville_lambda(10)
+ 1
+ >>> liouville_lambda(11)
+ -1
+ >>> liouville_lambda(0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input must be a positive integer
+ >>> liouville_lambda(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input must be a positive integer
+ >>> liouville_lambda(11.0)
+ Traceback (most recent call last):
+ ...
+ TypeError: Input value of [number=11.0] must be an integer
+ """
+ if not isinstance(number, int):
+ msg = f"Input value of [number={number}] must be an integer"
+ raise TypeError(msg)
+ if number < 1:
+ raise ValueError("Input must be a positive integer")
+ return -1 if len(prime_factors(number)) % 2 else 1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/lucas_lehmer_primality_test.py b/maths/lucas_lehmer_primality_test.py
index 15e25cbfe996..af5c81133044 100644
--- a/maths/lucas_lehmer_primality_test.py
+++ b/maths/lucas_lehmer_primality_test.py
@@ -1,13 +1,13 @@
"""
- In mathematics, the Lucas–Lehmer test (LLT) is a primality test for Mersenne
- numbers. https://en.wikipedia.org/wiki/Lucas%E2%80%93Lehmer_primality_test
+In mathematics, the Lucas-Lehmer test (LLT) is a primality test for Mersenne
+numbers. https://en.wikipedia.org/wiki/Lucas%E2%80%93Lehmer_primality_test
- A Mersenne number is a number that is one less than a power of two.
- That is M_p = 2^p - 1
- https://en.wikipedia.org/wiki/Mersenne_prime
+A Mersenne number is a number that is one less than a power of two.
+That is M_p = 2^p - 1
+https://en.wikipedia.org/wiki/Mersenne_prime
- The Lucas–Lehmer test is the primality test used by the
- Great Internet Mersenne Prime Search (GIMPS) to locate large primes.
+The Lucas-Lehmer test is the primality test used by the
+Great Internet Mersenne Prime Search (GIMPS) to locate large primes.
"""
@@ -30,9 +30,9 @@ def lucas_lehmer_test(p: int) -> bool:
return True
s = 4
- M = (1 << p) - 1
- for i in range(p - 2):
- s = ((s * s) - 2) % M
+ m = (1 << p) - 1
+ for _ in range(p - 2):
+ s = ((s * s) - 2) % m
return s == 0
diff --git a/maths/lucas_series.py b/maths/lucas_series.py
index 02eae8d8c658..cae6c2815aec 100644
--- a/maths/lucas_series.py
+++ b/maths/lucas_series.py
@@ -3,7 +3,7 @@
"""
-def recursive_lucas_number(n):
+def recursive_lucas_number(n_th_number: int) -> int:
"""
Returns the nth lucas number
>>> recursive_lucas_number(1)
@@ -19,17 +19,19 @@ def recursive_lucas_number(n):
...
TypeError: recursive_lucas_number accepts only integer arguments.
"""
- if n == 1:
- return n
- if n == 0:
- return 2
- if not isinstance(n, int):
+ if not isinstance(n_th_number, int):
raise TypeError("recursive_lucas_number accepts only integer arguments.")
+ if n_th_number == 0:
+ return 2
+ if n_th_number == 1:
+ return 1
- return recursive_lucas_number(n - 1) + recursive_lucas_number(n - 2)
+ return recursive_lucas_number(n_th_number - 1) + recursive_lucas_number(
+ n_th_number - 2
+ )
-def dynamic_lucas_number(n: int) -> int:
+def dynamic_lucas_number(n_th_number: int) -> int:
"""
Returns the nth lucas number
>>> dynamic_lucas_number(1)
@@ -45,14 +47,10 @@ def dynamic_lucas_number(n: int) -> int:
...
TypeError: dynamic_lucas_number accepts only integer arguments.
"""
- if not isinstance(n, int):
+ if not isinstance(n_th_number, int):
raise TypeError("dynamic_lucas_number accepts only integer arguments.")
- if n == 0:
- return 2
- if n == 1:
- return 1
a, b = 2, 1
- for i in range(n):
+ for _ in range(n_th_number):
a, b = b, a + b
return a
@@ -62,7 +60,6 @@ def dynamic_lucas_number(n: int) -> int:
testmod()
n = int(input("Enter the number of terms in lucas series:\n").strip())
- n = int(input("Enter the number of terms in lucas series:\n").strip())
print("Using recursive function to calculate lucas series:")
print(" ".join(str(recursive_lucas_number(i)) for i in range(n)))
print("\nUsing dynamic function to calculate lucas series:")
diff --git a/maths/maclaurin_series.py b/maths/maclaurin_series.py
new file mode 100644
index 000000000000..6ec5551a5e6e
--- /dev/null
+++ b/maths/maclaurin_series.py
@@ -0,0 +1,123 @@
+"""
+https://en.wikipedia.org/wiki/Taylor_series#Trigonometric_functions
+"""
+
+from math import factorial, pi
+
+
+def maclaurin_sin(theta: float, accuracy: int = 30) -> float:
+ """
+ Finds the maclaurin approximation of sin
+
+ :param theta: the angle to which sin is found
+ :param accuracy: the degree of accuracy wanted minimum
+ :return: the value of sine in radians
+
+
+ >>> from math import isclose, sin
+ >>> all(isclose(maclaurin_sin(x, 50), sin(x)) for x in range(-25, 25))
+ True
+ >>> maclaurin_sin(10)
+ -0.5440211108893691
+ >>> maclaurin_sin(-10)
+ 0.5440211108893704
+ >>> maclaurin_sin(10, 15)
+ -0.544021110889369
+ >>> maclaurin_sin(-10, 15)
+ 0.5440211108893704
+ >>> maclaurin_sin("10")
+ Traceback (most recent call last):
+ ...
+ ValueError: maclaurin_sin() requires either an int or float for theta
+ >>> maclaurin_sin(10, -30)
+ Traceback (most recent call last):
+ ...
+ ValueError: maclaurin_sin() requires a positive int for accuracy
+ >>> maclaurin_sin(10, 30.5)
+ Traceback (most recent call last):
+ ...
+ ValueError: maclaurin_sin() requires a positive int for accuracy
+ >>> maclaurin_sin(10, "30")
+ Traceback (most recent call last):
+ ...
+ ValueError: maclaurin_sin() requires a positive int for accuracy
+ """
+
+ if not isinstance(theta, (int, float)):
+ raise ValueError("maclaurin_sin() requires either an int or float for theta")
+
+ if not isinstance(accuracy, int) or accuracy <= 0:
+ raise ValueError("maclaurin_sin() requires a positive int for accuracy")
+
+ theta = float(theta)
+ div = theta // (2 * pi)
+ theta -= 2 * div * pi
+ return sum(
+ (-1) ** r * theta ** (2 * r + 1) / factorial(2 * r + 1) for r in range(accuracy)
+ )
+
+
+def maclaurin_cos(theta: float, accuracy: int = 30) -> float:
+ """
+ Finds the maclaurin approximation of cos
+
+ :param theta: the angle to which cos is found
+ :param accuracy: the degree of accuracy wanted
+ :return: the value of cosine in radians
+
+
+ >>> from math import isclose, cos
+ >>> all(isclose(maclaurin_cos(x, 50), cos(x)) for x in range(-25, 25))
+ True
+ >>> maclaurin_cos(5)
+ 0.2836621854632268
+ >>> maclaurin_cos(-5)
+ 0.2836621854632265
+ >>> maclaurin_cos(10, 15)
+ -0.8390715290764524
+ >>> maclaurin_cos(-10, 15)
+ -0.8390715290764521
+ >>> maclaurin_cos("10")
+ Traceback (most recent call last):
+ ...
+ ValueError: maclaurin_cos() requires either an int or float for theta
+ >>> maclaurin_cos(10, -30)
+ Traceback (most recent call last):
+ ...
+ ValueError: maclaurin_cos() requires a positive int for accuracy
+ >>> maclaurin_cos(10, 30.5)
+ Traceback (most recent call last):
+ ...
+ ValueError: maclaurin_cos() requires a positive int for accuracy
+ >>> maclaurin_cos(10, "30")
+ Traceback (most recent call last):
+ ...
+ ValueError: maclaurin_cos() requires a positive int for accuracy
+ """
+
+ if not isinstance(theta, (int, float)):
+ raise ValueError("maclaurin_cos() requires either an int or float for theta")
+
+ if not isinstance(accuracy, int) or accuracy <= 0:
+ raise ValueError("maclaurin_cos() requires a positive int for accuracy")
+
+ theta = float(theta)
+ div = theta // (2 * pi)
+ theta -= 2 * div * pi
+ return sum((-1) ** r * theta ** (2 * r) / factorial(2 * r) for r in range(accuracy))
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+
+ print(maclaurin_sin(10))
+ print(maclaurin_sin(-10))
+ print(maclaurin_sin(10, 15))
+ print(maclaurin_sin(-10, 15))
+
+ print(maclaurin_cos(5))
+ print(maclaurin_cos(-5))
+ print(maclaurin_cos(10, 15))
+ print(maclaurin_cos(-10, 15))
diff --git a/maths/manhattan_distance.py b/maths/manhattan_distance.py
new file mode 100644
index 000000000000..413991468a49
--- /dev/null
+++ b/maths/manhattan_distance.py
@@ -0,0 +1,126 @@
+def manhattan_distance(point_a: list, point_b: list) -> float:
+ """
+ Expectts two list of numbers representing two points in the same
+ n-dimensional space
+
+ https://en.wikipedia.org/wiki/Taxicab_geometry
+
+ >>> manhattan_distance([1,1], [2,2])
+ 2.0
+ >>> manhattan_distance([1.5,1.5], [2,2])
+ 1.0
+ >>> manhattan_distance([1.5,1.5], [2.5,2])
+ 1.5
+ >>> manhattan_distance([-3, -3, -3], [0, 0, 0])
+ 9.0
+ >>> manhattan_distance([1,1], None)
+ Traceback (most recent call last):
+ ...
+ ValueError: Missing an input
+ >>> manhattan_distance([1,1], [2, 2, 2])
+ Traceback (most recent call last):
+ ...
+ ValueError: Both points must be in the same n-dimensional space
+ >>> manhattan_distance([1,"one"], [2, 2, 2])
+ Traceback (most recent call last):
+ ...
+ TypeError: Expected a list of numbers as input, found str
+ >>> manhattan_distance(1, [2, 2, 2])
+ Traceback (most recent call last):
+ ...
+ TypeError: Expected a list of numbers as input, found int
+ >>> manhattan_distance([1,1], "not_a_list")
+ Traceback (most recent call last):
+ ...
+ TypeError: Expected a list of numbers as input, found str
+ """
+
+ _validate_point(point_a)
+ _validate_point(point_b)
+ if len(point_a) != len(point_b):
+ raise ValueError("Both points must be in the same n-dimensional space")
+
+ return float(sum(abs(a - b) for a, b in zip(point_a, point_b)))
+
+
+def _validate_point(point: list[float]) -> None:
+ """
+ >>> _validate_point(None)
+ Traceback (most recent call last):
+ ...
+ ValueError: Missing an input
+ >>> _validate_point([1,"one"])
+ Traceback (most recent call last):
+ ...
+ TypeError: Expected a list of numbers as input, found str
+ >>> _validate_point(1)
+ Traceback (most recent call last):
+ ...
+ TypeError: Expected a list of numbers as input, found int
+ >>> _validate_point("not_a_list")
+ Traceback (most recent call last):
+ ...
+ TypeError: Expected a list of numbers as input, found str
+ """
+ if point:
+ if isinstance(point, list):
+ for item in point:
+ if not isinstance(item, (int, float)):
+ msg = (
+ "Expected a list of numbers as input, found "
+ f"{type(item).__name__}"
+ )
+ raise TypeError(msg)
+ else:
+ msg = f"Expected a list of numbers as input, found {type(point).__name__}"
+ raise TypeError(msg)
+ else:
+ raise ValueError("Missing an input")
+
+
+def manhattan_distance_one_liner(point_a: list, point_b: list) -> float:
+ """
+ Version with one liner
+
+ >>> manhattan_distance_one_liner([1,1], [2,2])
+ 2.0
+ >>> manhattan_distance_one_liner([1.5,1.5], [2,2])
+ 1.0
+ >>> manhattan_distance_one_liner([1.5,1.5], [2.5,2])
+ 1.5
+ >>> manhattan_distance_one_liner([-3, -3, -3], [0, 0, 0])
+ 9.0
+ >>> manhattan_distance_one_liner([1,1], None)
+ Traceback (most recent call last):
+ ...
+ ValueError: Missing an input
+ >>> manhattan_distance_one_liner([1,1], [2, 2, 2])
+ Traceback (most recent call last):
+ ...
+ ValueError: Both points must be in the same n-dimensional space
+ >>> manhattan_distance_one_liner([1,"one"], [2, 2, 2])
+ Traceback (most recent call last):
+ ...
+ TypeError: Expected a list of numbers as input, found str
+ >>> manhattan_distance_one_liner(1, [2, 2, 2])
+ Traceback (most recent call last):
+ ...
+ TypeError: Expected a list of numbers as input, found int
+ >>> manhattan_distance_one_liner([1,1], "not_a_list")
+ Traceback (most recent call last):
+ ...
+ TypeError: Expected a list of numbers as input, found str
+ """
+
+ _validate_point(point_a)
+ _validate_point(point_b)
+ if len(point_a) != len(point_b):
+ raise ValueError("Both points must be in the same n-dimensional space")
+
+ return float(sum(abs(x - y) for x, y in zip(point_a, point_b)))
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/matrix_exponentiation.py b/maths/matrix_exponentiation.py
index 033ceb3f28a0..7cdac9d34674 100644
--- a/maths/matrix_exponentiation.py
+++ b/maths/matrix_exponentiation.py
@@ -5,7 +5,7 @@
"""
Matrix Exponentiation is a technique to solve linear recurrences in logarithmic time.
You read more about it here:
-http://zobayer.blogspot.com/2010/11/matrix-exponentiation.html
+https://zobayer.blogspot.com/2010/11/matrix-exponentiation.html
https://www.hackerearth.com/practice/notes/matrix-exponentiation-1/
"""
@@ -39,6 +39,21 @@ def modular_exponentiation(a, b):
def fibonacci_with_matrix_exponentiation(n, f1, f2):
+ """
+ Returns the nth number of the Fibonacci sequence that
+ starts with f1 and f2
+ Uses the matrix exponentiation
+ >>> fibonacci_with_matrix_exponentiation(1, 5, 6)
+ 5
+ >>> fibonacci_with_matrix_exponentiation(2, 10, 11)
+ 11
+ >>> fibonacci_with_matrix_exponentiation(13, 0, 1)
+ 144
+ >>> fibonacci_with_matrix_exponentiation(10, 5, 9)
+ 411
+ >>> fibonacci_with_matrix_exponentiation(9, 2, 3)
+ 89
+ """
# Trivial Cases
if n == 1:
return f1
@@ -50,21 +65,34 @@ def fibonacci_with_matrix_exponentiation(n, f1, f2):
def simple_fibonacci(n, f1, f2):
+ """
+ Returns the nth number of the Fibonacci sequence that
+ starts with f1 and f2
+ Uses the definition
+ >>> simple_fibonacci(1, 5, 6)
+ 5
+ >>> simple_fibonacci(2, 10, 11)
+ 11
+ >>> simple_fibonacci(13, 0, 1)
+ 144
+ >>> simple_fibonacci(10, 5, 9)
+ 411
+ >>> simple_fibonacci(9, 2, 3)
+ 89
+ """
# Trivial Cases
if n == 1:
return f1
elif n == 2:
return f2
- fn_1 = f1
- fn_2 = f2
n -= 2
while n > 0:
- fn_1, fn_2 = fn_1 + fn_2, fn_1
+ f2, f1 = f1 + f2, f2
n -= 1
- return fn_1
+ return f2
def matrix_exponentiation_time():
diff --git a/other/max_sum_sliding_window.py b/maths/max_sum_sliding_window.py
similarity index 85%
rename from other/max_sum_sliding_window.py
rename to maths/max_sum_sliding_window.py
index 4be7d786f215..c7492978a6c9 100644
--- a/other/max_sum_sliding_window.py
+++ b/maths/max_sum_sliding_window.py
@@ -1,45 +1,48 @@
-"""
-Given an array of integer elements and an integer 'k', we are required to find the
-maximum sum of 'k' consecutive elements in the array.
-
-Instead of using a nested for loop, in a Brute force approach we will use a technique
-called 'Window sliding technique' where the nested loops can be converted to a single
-loop to reduce time complexity.
-"""
-from typing import List
-
-
-def max_sum_in_array(array: List[int], k: int) -> int:
- """
- Returns the maximum sum of k consecutive elements
- >>> arr = [1, 4, 2, 10, 2, 3, 1, 0, 20]
- >>> k = 4
- >>> max_sum_in_array(arr, k)
- 24
- >>> k = 10
- >>> max_sum_in_array(arr,k)
- Traceback (most recent call last):
- ...
- ValueError: Invalid Input
- >>> arr = [1, 4, 2, 10, 2, 13, 1, 0, 2]
- >>> k = 4
- >>> max_sum_in_array(arr, k)
- 27
- """
- if len(array) < k or k < 0:
- raise ValueError("Invalid Input")
- max_sum = current_sum = sum(array[:k])
- for i in range(len(array) - k):
- current_sum = current_sum - array[i] + array[i + k]
- max_sum = max(max_sum, current_sum)
- return max_sum
-
-
-if __name__ == "__main__":
- from doctest import testmod
- from random import randint
-
- testmod()
- array = [randint(-1000, 1000) for i in range(100)]
- k = randint(0, 110)
- print(f"The maximum sum of {k} consecutive elements is {max_sum_in_array(array,k)}")
+"""
+Given an array of integer elements and an integer 'k', we are required to find the
+maximum sum of 'k' consecutive elements in the array.
+
+Instead of using a nested for loop, in a Brute force approach we will use a technique
+called 'Window sliding technique' where the nested loops can be converted to a single
+loop to reduce time complexity.
+"""
+
+from __future__ import annotations
+
+
+def max_sum_in_array(array: list[int], k: int) -> int:
+ """
+ Returns the maximum sum of k consecutive elements
+ >>> arr = [1, 4, 2, 10, 2, 3, 1, 0, 20]
+ >>> k = 4
+ >>> max_sum_in_array(arr, k)
+ 24
+ >>> k = 10
+ >>> max_sum_in_array(arr,k)
+ Traceback (most recent call last):
+ ...
+ ValueError: Invalid Input
+ >>> arr = [1, 4, 2, 10, 2, 13, 1, 0, 2]
+ >>> k = 4
+ >>> max_sum_in_array(arr, k)
+ 27
+ """
+ if len(array) < k or k < 0:
+ raise ValueError("Invalid Input")
+ max_sum = current_sum = sum(array[:k])
+ for i in range(len(array) - k):
+ current_sum = current_sum - array[i] + array[i + k]
+ max_sum = max(max_sum, current_sum)
+ return max_sum
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+ from random import randint
+
+ testmod()
+ array = [randint(-1000, 1000) for i in range(100)]
+ k = randint(0, 110)
+ print(
+ f"The maximum sum of {k} consecutive elements is {max_sum_in_array(array, k)}"
+ )
diff --git a/maths/miller_rabin.py b/maths/miller_rabin.py
deleted file mode 100644
index fe992027190b..000000000000
--- a/maths/miller_rabin.py
+++ /dev/null
@@ -1,50 +0,0 @@
-import random
-
-from .binary_exp_mod import bin_exp_mod
-
-
-# This is a probabilistic check to test primality, useful for big numbers!
-# if it's a prime, it will return true
-# if it's not a prime, the chance of it returning true is at most 1/4**prec
-def is_prime(n, prec=1000):
- """
- >>> from .prime_check import prime_check
- >>> all(is_prime(i) == prime_check(i) for i in range(1000))
- True
- """
- if n < 2:
- return False
-
- if n % 2 == 0:
- return n == 2
-
- # this means n is odd
- d = n - 1
- exp = 0
- while d % 2 == 0:
- d /= 2
- exp += 1
-
- # n - 1=d*(2**exp)
- count = 0
- while count < prec:
- a = random.randint(2, n - 1)
- b = bin_exp_mod(a, d, n)
- if b != 1:
- flag = True
- for i in range(exp):
- if b == n - 1:
- flag = False
- break
- b = b * b
- b %= n
- if flag:
- return False
- count += 1
- return True
-
-
-if __name__ == "__main__":
- n = abs(int(input("Enter bound : ").strip()))
- print("Here's the list of primes:")
- print(", ".join(str(i) for i in range(n + 1) if is_prime(i)))
diff --git a/maths/minkowski_distance.py b/maths/minkowski_distance.py
new file mode 100644
index 000000000000..99f02e31e417
--- /dev/null
+++ b/maths/minkowski_distance.py
@@ -0,0 +1,45 @@
+def minkowski_distance(
+ point_a: list[float],
+ point_b: list[float],
+ order: int,
+) -> float:
+ """
+ This function calculates the Minkowski distance for a given order between
+ two n-dimensional points represented as lists. For the case of order = 1,
+ the Minkowski distance degenerates to the Manhattan distance. For
+ order = 2, the usual Euclidean distance is obtained.
+
+ https://en.wikipedia.org/wiki/Minkowski_distance
+
+ Note: due to floating point calculation errors the output of this
+ function may be inaccurate.
+
+ >>> minkowski_distance([1.0, 1.0], [2.0, 2.0], 1)
+ 2.0
+ >>> minkowski_distance([1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0], 2)
+ 8.0
+ >>> import numpy as np
+ >>> bool(np.isclose(5.0, minkowski_distance([5.0], [0.0], 3)))
+ True
+ >>> minkowski_distance([1.0], [2.0], -1)
+ Traceback (most recent call last):
+ ...
+ ValueError: The order must be greater than or equal to 1.
+ >>> minkowski_distance([1.0], [1.0, 2.0], 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: Both points must have the same dimension.
+ """
+ if order < 1:
+ raise ValueError("The order must be greater than or equal to 1.")
+
+ if len(point_a) != len(point_b):
+ raise ValueError("Both points must have the same dimension.")
+
+ return sum(abs(a - b) ** order for a, b in zip(point_a, point_b)) ** (1 / order)
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/mobius_function.py b/maths/mobius_function.py
index 4fcf35f21813..8abdc4cafcb4 100644
--- a/maths/mobius_function.py
+++ b/maths/mobius_function.py
@@ -1,8 +1,8 @@
"""
References: https://en.wikipedia.org/wiki/M%C3%B6bius_function
References: wikipedia:square free number
-python/black : True
-flake8 : True
+psf/black : True
+ruff : True
"""
from maths.is_square_free import is_square_free
diff --git a/blockchain/modular_division.py b/maths/modular_division.py
similarity index 59%
rename from blockchain/modular_division.py
rename to maths/modular_division.py
index 8fcf6e37cbed..2f8f4479b27d 100644
--- a/blockchain/modular_division.py
+++ b/maths/modular_division.py
@@ -1,21 +1,23 @@
-# Modular Division :
-# An efficient algorithm for dividing b by a modulo n.
+from __future__ import annotations
-# GCD ( Greatest Common Divisor ) or HCF ( Highest Common Factor )
-# Given three integers a, b, and n, such that gcd(a,n)=1 and n>1, the algorithm should
-# return an integer x such that 0≤x≤n−1, and b/a=x(modn) (that is, b=ax(modn)).
+def modular_division(a: int, b: int, n: int) -> int:
+ """
+ Modular Division :
+ An efficient algorithm for dividing b by a modulo n.
-# Theorem:
-# a has a multiplicative inverse modulo n iff gcd(a,n) = 1
+ GCD ( Greatest Common Divisor ) or HCF ( Highest Common Factor )
+ Given three integers a, b, and n, such that gcd(a,n)=1 and n>1, the algorithm should
+ return an integer x such that 0≤x≤n-1, and b/a=x(modn) (that is, b=ax(modn)).
-# This find x = b*a^(-1) mod n
-# Uses ExtendedEuclid to find the inverse of a
+ Theorem:
+ a has a multiplicative inverse modulo n iff gcd(a,n) = 1
-def modular_division(a, b, n):
- """
+ This find x = b*a^(-1) mod n
+ Uses ExtendedEuclid to find the inverse of a
+
>>> modular_division(4,8,5)
2
@@ -26,15 +28,18 @@ def modular_division(a, b, n):
4
"""
- assert n > 1 and a > 0 and greatest_common_divisor(a, n) == 1
+ assert n > 1
+ assert a > 0
+ assert greatest_common_divisor(a, n) == 1
(d, t, s) = extended_gcd(n, a) # Implemented below
x = (b * s) % n
return x
-# This function find the inverses of a i.e., a^(-1)
-def invert_modulo(a, n):
+def invert_modulo(a: int, n: int) -> int:
"""
+ This function find the inverses of a i.e., a^(-1)
+
>>> invert_modulo(2, 5)
3
@@ -50,9 +55,11 @@ def invert_modulo(a, n):
# ------------------ Finding Modular division using invert_modulo -------------------
-# This function used the above inversion of a to find x = (b*a^(-1))mod n
-def modular_division2(a, b, n):
+
+def modular_division2(a: int, b: int, n: int) -> int:
"""
+ This function used the above inversion of a to find x = (b*a^(-1))mod n
+
>>> modular_division2(4,8,5)
2
@@ -68,22 +75,21 @@ def modular_division2(a, b, n):
return x
-# Extended Euclid's Algorithm : If d divides a and b and d = a*x + b*y for integers x
-# and y, then d = gcd(a,b)
-
-
-def extended_gcd(a, b):
+def extended_gcd(a: int, b: int) -> tuple[int, int, int]:
"""
- >>> extended_gcd(10, 6)
- (2, -1, 2)
+ Extended Euclid's Algorithm : If d divides a and b and d = a*x + b*y for integers x
+ and y, then d = gcd(a,b)
+ >>> extended_gcd(10, 6)
+ (2, -1, 2)
- >>> extended_gcd(7, 5)
- (1, -2, 3)
+ >>> extended_gcd(7, 5)
+ (1, -2, 3)
** extended_gcd function is used when d = gcd(a,b) is required in output
"""
- assert a >= 0 and b >= 0
+ assert a >= 0
+ assert b >= 0
if b == 0:
d, x, y = a, 1, 0
@@ -92,15 +98,16 @@ def extended_gcd(a, b):
x = q
y = p - q * (a // b)
- assert a % d == 0 and b % d == 0
+ assert a % d == 0
+ assert b % d == 0
assert d == a * x + b * y
return (d, x, y)
-# Extended Euclid
-def extended_euclid(a, b):
+def extended_euclid(a: int, b: int) -> tuple[int, int]:
"""
+ Extended Euclid
>>> extended_euclid(10, 6)
(-1, 2)
@@ -115,12 +122,11 @@ def extended_euclid(a, b):
return (y, x - k * y)
-# Euclid's Lemma : d divides a and b, if and only if d divides a-b and b
-# Euclid's Algorithm
-
-
-def greatest_common_divisor(a, b):
+def greatest_common_divisor(a: int, b: int) -> int:
"""
+ Euclid's Lemma : d divides a and b, if and only if d divides a-b and b
+ Euclid's Algorithm
+
>>> greatest_common_divisor(7,5)
1
diff --git a/maths/modular_exponential.py b/maths/modular_exponential.py
index 42987dbf3a24..a27e29ebc02a 100644
--- a/maths/modular_exponential.py
+++ b/maths/modular_exponential.py
@@ -1,8 +1,8 @@
"""
- Modular Exponential.
- Modular exponentiation is a type of exponentiation performed over a modulus.
- For more explanation, please check
- https://en.wikipedia.org/wiki/Modular_exponentiation
+Modular Exponential.
+Modular exponentiation is a type of exponentiation performed over a modulus.
+For more explanation, please check
+https://en.wikipedia.org/wiki/Modular_exponentiation
"""
"""Calculate Modular Exponential."""
diff --git a/maths/monte_carlo.py b/maths/monte_carlo.py
index 28027cbe4178..d174a0b188a2 100644
--- a/maths/monte_carlo.py
+++ b/maths/monte_carlo.py
@@ -1,10 +1,11 @@
"""
@author: MatteoRaso
"""
+
+from collections.abc import Callable
from math import pi, sqrt
from random import uniform
from statistics import mean
-from typing import Callable
def pi_estimator(iterations: int):
@@ -18,9 +19,10 @@ def pi_estimator(iterations: int):
5. Multiply this value by 4 to get your estimate of pi.
6. Print the estimated and numpy value of pi
"""
+
# A local function to see if a dot lands in the circle.
def is_in_circle(x: float, y: float) -> bool:
- distance_from_centre = sqrt((x ** 2) + (y ** 2))
+ distance_from_centre = sqrt((x**2) + (y**2))
# Our circle has a radius of 1, so a distance
# greater than 1 would land outside the circle.
return distance_from_centre <= 1
diff --git a/maths/monte_carlo_dice.py b/maths/monte_carlo_dice.py
index e8e3abe83a99..362f70b49828 100644
--- a/maths/monte_carlo_dice.py
+++ b/maths/monte_carlo_dice.py
@@ -7,15 +7,12 @@ class Dice:
NUM_SIDES = 6
def __init__(self):
- """ Initialize a six sided dice """
+ """Initialize a six sided dice"""
self.sides = list(range(1, Dice.NUM_SIDES + 1))
def roll(self):
return random.choice(self.sides)
- def _str_(self):
- return "Fair Dice"
-
def throw_dice(num_throws: int, num_dice: int = 2) -> list[float]:
"""
@@ -35,7 +32,7 @@ def throw_dice(num_throws: int, num_dice: int = 2) -> list[float]:
"""
dices = [Dice() for i in range(num_dice)]
count_of_sum = [0] * (len(dices) * Dice.NUM_SIDES + 1)
- for i in range(num_throws):
+ for _ in range(num_throws):
count_of_sum[sum(dice.roll() for dice in dices)] += 1
probability = [round((count * 100) / num_throws, 2) for count in count_of_sum]
return probability[num_dice:] # remove probability of sums that never appear
diff --git a/maths/newton_raphson.py b/maths/newton_raphson.py
deleted file mode 100644
index f2b7cb9766d2..000000000000
--- a/maths/newton_raphson.py
+++ /dev/null
@@ -1,54 +0,0 @@
-"""
- Author: P Shreyas Shetty
- Implementation of Newton-Raphson method for solving equations of kind
- f(x) = 0. It is an iterative method where solution is found by the expression
- x[n+1] = x[n] + f(x[n])/f'(x[n])
- If no solution exists, then either the solution will not be found when iteration
- limit is reached or the gradient f'(x[n]) approaches zero. In both cases, exception
- is raised. If iteration limit is reached, try increasing maxiter.
- """
-import math as m
-
-
-def calc_derivative(f, a, h=0.001):
- """
- Calculates derivative at point a for function f using finite difference
- method
- """
- return (f(a + h) - f(a - h)) / (2 * h)
-
-
-def newton_raphson(f, x0=0, maxiter=100, step=0.0001, maxerror=1e-6, logsteps=False):
-
- a = x0 # set the initial guess
- steps = [a]
- error = abs(f(a))
- f1 = lambda x: calc_derivative(f, x, h=step) # noqa: E731 Derivative of f(x)
- for _ in range(maxiter):
- if f1(a) == 0:
- raise ValueError("No converging solution found")
- a = a - f(a) / f1(a) # Calculate the next estimate
- if logsteps:
- steps.append(a)
- if error < maxerror:
- break
- else:
- raise ValueError("Iteration limit reached, no converging solution found")
- if logsteps:
- # If logstep is true, then log intermediate steps
- return a, error, steps
- return a, error
-
-
-if __name__ == "__main__":
- from matplotlib import pyplot as plt
-
- f = lambda x: m.tanh(x) ** 2 - m.exp(3 * x) # noqa: E731
- solution, error, steps = newton_raphson(
- f, x0=10, maxiter=1000, step=1e-6, logsteps=True
- )
- plt.plot([abs(f(x)) for x in steps])
- plt.xlabel("step")
- plt.ylabel("error")
- plt.show()
- print(f"solution = {{{solution:f}}}, error = {{{error:f}}}")
diff --git a/maths/number_of_digits.py b/maths/number_of_digits.py
index 3c0eb7b3863f..bb9c0d248fd1 100644
--- a/maths/number_of_digits.py
+++ b/maths/number_of_digits.py
@@ -16,7 +16,15 @@ def num_digits(n: int) -> int:
1
>>> num_digits(-123456)
6
+ >>> num_digits('123') # Raises a TypeError for non-integer input
+ Traceback (most recent call last):
+ ...
+ TypeError: Input must be an integer
"""
+
+ if not isinstance(n, int):
+ raise TypeError("Input must be an integer")
+
digits = 0
n = abs(n)
while True:
@@ -42,7 +50,15 @@ def num_digits_fast(n: int) -> int:
1
>>> num_digits_fast(-123456)
6
+ >>> num_digits('123') # Raises a TypeError for non-integer input
+ Traceback (most recent call last):
+ ...
+ TypeError: Input must be an integer
"""
+
+ if not isinstance(n, int):
+ raise TypeError("Input must be an integer")
+
return 1 if n == 0 else math.floor(math.log(abs(n), 10) + 1)
@@ -61,99 +77,37 @@ def num_digits_faster(n: int) -> int:
1
>>> num_digits_faster(-123456)
6
+ >>> num_digits('123') # Raises a TypeError for non-integer input
+ Traceback (most recent call last):
+ ...
+ TypeError: Input must be an integer
"""
+
+ if not isinstance(n, int):
+ raise TypeError("Input must be an integer")
+
return len(str(abs(n)))
def benchmark() -> None:
"""
- Benchmark code for comparing 3 functions,
- with 3 different length int values.
+ Benchmark multiple functions, with three different length int values.
"""
- print("\nFor small_num = ", small_num, ":")
- print(
- "> num_digits()",
- "\t\tans =",
- num_digits(small_num),
- "\ttime =",
- timeit("z.num_digits(z.small_num)", setup="import __main__ as z"),
- "seconds",
- )
- print(
- "> num_digits_fast()",
- "\tans =",
- num_digits_fast(small_num),
- "\ttime =",
- timeit("z.num_digits_fast(z.small_num)", setup="import __main__ as z"),
- "seconds",
- )
- print(
- "> num_digits_faster()",
- "\tans =",
- num_digits_faster(small_num),
- "\ttime =",
- timeit("z.num_digits_faster(z.small_num)", setup="import __main__ as z"),
- "seconds",
- )
-
- print("\nFor medium_num = ", medium_num, ":")
- print(
- "> num_digits()",
- "\t\tans =",
- num_digits(medium_num),
- "\ttime =",
- timeit("z.num_digits(z.medium_num)", setup="import __main__ as z"),
- "seconds",
- )
- print(
- "> num_digits_fast()",
- "\tans =",
- num_digits_fast(medium_num),
- "\ttime =",
- timeit("z.num_digits_fast(z.medium_num)", setup="import __main__ as z"),
- "seconds",
- )
- print(
- "> num_digits_faster()",
- "\tans =",
- num_digits_faster(medium_num),
- "\ttime =",
- timeit("z.num_digits_faster(z.medium_num)", setup="import __main__ as z"),
- "seconds",
- )
-
- print("\nFor large_num = ", large_num, ":")
- print(
- "> num_digits()",
- "\t\tans =",
- num_digits(large_num),
- "\ttime =",
- timeit("z.num_digits(z.large_num)", setup="import __main__ as z"),
- "seconds",
- )
- print(
- "> num_digits_fast()",
- "\tans =",
- num_digits_fast(large_num),
- "\ttime =",
- timeit("z.num_digits_fast(z.large_num)", setup="import __main__ as z"),
- "seconds",
- )
- print(
- "> num_digits_faster()",
- "\tans =",
- num_digits_faster(large_num),
- "\ttime =",
- timeit("z.num_digits_faster(z.large_num)", setup="import __main__ as z"),
- "seconds",
- )
+ from collections.abc import Callable
+
+ def benchmark_a_function(func: Callable, value: int) -> None:
+ call = f"{func.__name__}({value})"
+ timing = timeit(f"__main__.{call}", setup="import __main__")
+ print(f"{call}: {func(value)} -- {timing} seconds")
+
+ for value in (262144, 1125899906842624, 1267650600228229401496703205376):
+ for func in (num_digits, num_digits_fast, num_digits_faster):
+ benchmark_a_function(func, value)
+ print()
if __name__ == "__main__":
- small_num = 262144
- medium_num = 1125899906842624
- large_num = 1267650600228229401496703205376
- benchmark()
import doctest
doctest.testmod()
+ benchmark()
diff --git a/maths/numerical_analysis/__init__.py b/maths/numerical_analysis/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/maths/numerical_analysis/adams_bashforth.py b/maths/numerical_analysis/adams_bashforth.py
new file mode 100644
index 000000000000..26244a58552f
--- /dev/null
+++ b/maths/numerical_analysis/adams_bashforth.py
@@ -0,0 +1,231 @@
+"""
+Use the Adams-Bashforth methods to solve Ordinary Differential Equations.
+
+https://en.wikipedia.org/wiki/Linear_multistep_method
+Author : Ravi Kumar
+"""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+import numpy as np
+
+
+@dataclass
+class AdamsBashforth:
+ """
+ args:
+ func: An ordinary differential equation (ODE) as function of x and y.
+ x_initials: List containing initial required values of x.
+ y_initials: List containing initial required values of y.
+ step_size: The increment value of x.
+ x_final: The final value of x.
+
+ Returns: Solution of y at each nodal point
+
+ >>> def f(x, y):
+ ... return x + y
+ >>> AdamsBashforth(f, [0, 0.2, 0.4], [0, 0.2, 1], 0.2, 1) # doctest: +ELLIPSIS
+ AdamsBashforth(func=..., x_initials=[0, 0.2, 0.4], y_initials=[0, 0.2, 1], step...)
+ >>> AdamsBashforth(f, [0, 0.2, 1], [0, 0, 0.04], 0.2, 1).step_2()
+ Traceback (most recent call last):
+ ...
+ ValueError: The final value of x must be greater than the initial values of x.
+
+ >>> AdamsBashforth(f, [0, 0.2, 0.3], [0, 0, 0.04], 0.2, 1).step_3()
+ Traceback (most recent call last):
+ ...
+ ValueError: x-values must be equally spaced according to step size.
+
+ >>> AdamsBashforth(f,[0,0.2,0.4,0.6,0.8],[0,0,0.04,0.128,0.307],-0.2,1).step_5()
+ Traceback (most recent call last):
+ ...
+ ValueError: Step size must be positive.
+ """
+
+ func: Callable[[float, float], float]
+ x_initials: list[float]
+ y_initials: list[float]
+ step_size: float
+ x_final: float
+
+ def __post_init__(self) -> None:
+ if self.x_initials[-1] >= self.x_final:
+ raise ValueError(
+ "The final value of x must be greater than the initial values of x."
+ )
+
+ if self.step_size <= 0:
+ raise ValueError("Step size must be positive.")
+
+ if not all(
+ round(x1 - x0, 10) == self.step_size
+ for x0, x1 in zip(self.x_initials, self.x_initials[1:])
+ ):
+ raise ValueError("x-values must be equally spaced according to step size.")
+
+ def step_2(self) -> np.ndarray:
+ """
+ >>> def f(x, y):
+ ... return x
+ >>> AdamsBashforth(f, [0, 0.2], [0, 0], 0.2, 1).step_2()
+ array([0. , 0. , 0.06, 0.16, 0.3 , 0.48])
+
+ >>> AdamsBashforth(f, [0, 0.2, 0.4], [0, 0, 0.04], 0.2, 1).step_2()
+ Traceback (most recent call last):
+ ...
+ ValueError: Insufficient initial points information.
+ """
+
+ if len(self.x_initials) != 2 or len(self.y_initials) != 2:
+ raise ValueError("Insufficient initial points information.")
+
+ x_0, x_1 = self.x_initials[:2]
+ y_0, y_1 = self.y_initials[:2]
+
+ n = int((self.x_final - x_1) / self.step_size)
+ y = np.zeros(n + 2)
+ y[0] = y_0
+ y[1] = y_1
+
+ for i in range(n):
+ y[i + 2] = y[i + 1] + (self.step_size / 2) * (
+ 3 * self.func(x_1, y[i + 1]) - self.func(x_0, y[i])
+ )
+ x_0 = x_1
+ x_1 += self.step_size
+
+ return y
+
+ def step_3(self) -> np.ndarray:
+ """
+ >>> def f(x, y):
+ ... return x + y
+ >>> y = AdamsBashforth(f, [0, 0.2, 0.4], [0, 0, 0.04], 0.2, 1).step_3()
+ >>> float(y[3])
+ 0.15533333333333332
+
+ >>> AdamsBashforth(f, [0, 0.2], [0, 0], 0.2, 1).step_3()
+ Traceback (most recent call last):
+ ...
+ ValueError: Insufficient initial points information.
+ """
+ if len(self.x_initials) != 3 or len(self.y_initials) != 3:
+ raise ValueError("Insufficient initial points information.")
+
+ x_0, x_1, x_2 = self.x_initials[:3]
+ y_0, y_1, y_2 = self.y_initials[:3]
+
+ n = int((self.x_final - x_2) / self.step_size)
+ y = np.zeros(n + 4)
+ y[0] = y_0
+ y[1] = y_1
+ y[2] = y_2
+
+ for i in range(n + 1):
+ y[i + 3] = y[i + 2] + (self.step_size / 12) * (
+ 23 * self.func(x_2, y[i + 2])
+ - 16 * self.func(x_1, y[i + 1])
+ + 5 * self.func(x_0, y[i])
+ )
+ x_0 = x_1
+ x_1 = x_2
+ x_2 += self.step_size
+
+ return y
+
+ def step_4(self) -> np.ndarray:
+ """
+ >>> def f(x,y):
+ ... return x + y
+ >>> y = AdamsBashforth(
+ ... f, [0, 0.2, 0.4, 0.6], [0, 0, 0.04, 0.128], 0.2, 1).step_4()
+ >>> float(y[4])
+ 0.30699999999999994
+ >>> float(y[5])
+ 0.5771083333333333
+
+ >>> AdamsBashforth(f, [0, 0.2, 0.4], [0, 0, 0.04], 0.2, 1).step_4()
+ Traceback (most recent call last):
+ ...
+ ValueError: Insufficient initial points information.
+ """
+
+ if len(self.x_initials) != 4 or len(self.y_initials) != 4:
+ raise ValueError("Insufficient initial points information.")
+
+ x_0, x_1, x_2, x_3 = self.x_initials[:4]
+ y_0, y_1, y_2, y_3 = self.y_initials[:4]
+
+ n = int((self.x_final - x_3) / self.step_size)
+ y = np.zeros(n + 4)
+ y[0] = y_0
+ y[1] = y_1
+ y[2] = y_2
+ y[3] = y_3
+
+ for i in range(n):
+ y[i + 4] = y[i + 3] + (self.step_size / 24) * (
+ 55 * self.func(x_3, y[i + 3])
+ - 59 * self.func(x_2, y[i + 2])
+ + 37 * self.func(x_1, y[i + 1])
+ - 9 * self.func(x_0, y[i])
+ )
+ x_0 = x_1
+ x_1 = x_2
+ x_2 = x_3
+ x_3 += self.step_size
+
+ return y
+
+ def step_5(self) -> np.ndarray:
+ """
+ >>> def f(x,y):
+ ... return x + y
+ >>> y = AdamsBashforth(
+ ... f, [0, 0.2, 0.4, 0.6, 0.8], [0, 0.02140, 0.02140, 0.22211, 0.42536],
+ ... 0.2, 1).step_5()
+ >>> float(y[-1])
+ 0.05436839444444452
+
+ >>> AdamsBashforth(f, [0, 0.2, 0.4], [0, 0, 0.04], 0.2, 1).step_5()
+ Traceback (most recent call last):
+ ...
+ ValueError: Insufficient initial points information.
+ """
+
+ if len(self.x_initials) != 5 or len(self.y_initials) != 5:
+ raise ValueError("Insufficient initial points information.")
+
+ x_0, x_1, x_2, x_3, x_4 = self.x_initials[:5]
+ y_0, y_1, y_2, y_3, y_4 = self.y_initials[:5]
+
+ n = int((self.x_final - x_4) / self.step_size)
+ y = np.zeros(n + 6)
+ y[0] = y_0
+ y[1] = y_1
+ y[2] = y_2
+ y[3] = y_3
+ y[4] = y_4
+
+ for i in range(n + 1):
+ y[i + 5] = y[i + 4] + (self.step_size / 720) * (
+ 1901 * self.func(x_4, y[i + 4])
+ - 2774 * self.func(x_3, y[i + 3])
+ - 2616 * self.func(x_2, y[i + 2])
+ - 1274 * self.func(x_1, y[i + 1])
+ + 251 * self.func(x_0, y[i])
+ )
+ x_0 = x_1
+ x_1 = x_2
+ x_2 = x_3
+ x_3 = x_4
+ x_4 += self.step_size
+
+ return y
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/arithmetic_analysis/bisection.py b/maths/numerical_analysis/bisection.py
similarity index 90%
rename from arithmetic_analysis/bisection.py
rename to maths/numerical_analysis/bisection.py
index 0ef691678702..e359cc170072 100644
--- a/arithmetic_analysis/bisection.py
+++ b/maths/numerical_analysis/bisection.py
@@ -1,4 +1,4 @@
-from typing import Callable
+from collections.abc import Callable
def bisection(function: Callable[[float], float], a: float, b: float) -> float:
@@ -8,7 +8,7 @@ def bisection(function: Callable[[float], float], a: float, b: float) -> float:
1.0000000149011612
>>> bisection(lambda x: x ** 3 - 1, 2, 1000)
Traceback (most recent call last):
- ...
+ ...
ValueError: could not find root in given interval.
>>> bisection(lambda x: x ** 2 - 4 * x + 3, 0, 2)
1.0
@@ -16,7 +16,7 @@ def bisection(function: Callable[[float], float], a: float, b: float) -> float:
3.0
>>> bisection(lambda x: x ** 2 - 4 * x + 3, 4, 1000)
Traceback (most recent call last):
- ...
+ ...
ValueError: could not find root in given interval.
"""
start: float = a
@@ -32,7 +32,7 @@ def bisection(function: Callable[[float], float], a: float, b: float) -> float:
raise ValueError("could not find root in given interval.")
else:
mid: float = start + (end - start) / 2.0
- while abs(start - mid) > 10 ** -7: # until precisely equals to 10^-7
+ while abs(start - mid) > 10**-7: # until precisely equals to 10^-7
if function(mid) == 0:
return mid
elif function(mid) * function(start) < 0:
@@ -44,7 +44,7 @@ def bisection(function: Callable[[float], float], a: float, b: float) -> float:
def f(x: float) -> float:
- return x ** 3 - 2 * x - 5
+ return x**3 - 2 * x - 5
if __name__ == "__main__":
diff --git a/maths/bisection.py b/maths/numerical_analysis/bisection_2.py
similarity index 97%
rename from maths/bisection.py
rename to maths/numerical_analysis/bisection_2.py
index 93cc2247b64e..68ba6577ce29 100644
--- a/maths/bisection.py
+++ b/maths/numerical_analysis/bisection_2.py
@@ -1,5 +1,5 @@
"""
-Given a function on floating number f(x) and two floating numbers ‘a’ and ‘b’ such that
+Given a function on floating number f(x) and two floating numbers `a` and `b` such that
f(a) * f(b) < 0 and f(x) is continuous in [a, b].
Here f(x) represents algebraic or transcendental equation.
Find root of function in interval [a, b] (Or find a value of x such that f(x) is 0)
@@ -32,7 +32,7 @@ def bisection(a: float, b: float) -> float:
3.158203125
>>> bisection(2, 3)
Traceback (most recent call last):
- ...
+ ...
ValueError: Wrong space!
"""
# Bolzano theory in order to find if there is a root between a and b
diff --git a/other/integeration_by_simpson_approx.py b/maths/numerical_analysis/integration_by_simpson_approx.py
similarity index 82%
rename from other/integeration_by_simpson_approx.py
rename to maths/numerical_analysis/integration_by_simpson_approx.py
index da0e1cffde02..043f3a9a72af 100644
--- a/other/integeration_by_simpson_approx.py
+++ b/maths/numerical_analysis/integration_by_simpson_approx.py
@@ -4,7 +4,7 @@
Purpose : You have one function f(x) which takes float integer and returns
float you have to integrate the function in limits a to b.
-The approximation proposed by Thomas Simpsons in 1743 is one way to calculate
+The approximation proposed by Thomas Simpson in 1743 is one way to calculate
integration.
( read article : https://cp-algorithms.com/num_methods/simpson-integration.html )
@@ -35,12 +35,11 @@ def f(x: float) -> float:
def simpson_integration(function, a: float, b: float, precision: int = 4) -> float:
-
"""
Args:
function : the function which's integration is desired
a : the lower limit of integration
- b : upper limit of integraion
+ b : upper limit of integration
precision : precision of the result,error required default is 4
Returns:
@@ -89,24 +88,20 @@ def simpson_integration(function, a: float, b: float, precision: int = 4) -> flo
AssertionError: precision should be positive integer your input : -1
"""
- assert callable(
- function
- ), f"the function(object) passed should be callable your input : {function}"
- assert isinstance(a, float) or isinstance(
- a, int
- ), f"a should be float or integer your input : {a}"
- assert isinstance(function(a), float) or isinstance(function(a), int), (
+ assert callable(function), (
+ f"the function(object) passed should be callable your input : {function}"
+ )
+ assert isinstance(a, (float, int)), f"a should be float or integer your input : {a}"
+ assert isinstance(function(a), (float, int)), (
"the function should return integer or float return type of your function, "
f"{type(a)}"
)
- assert isinstance(b, float) or isinstance(
- b, int
- ), f"b should be float or integer your input : {b}"
- assert (
- isinstance(precision, int) and precision > 0
- ), f"precision should be positive integer your input : {precision}"
-
- # just applying the formula of simpson for approximate integraion written in
+ assert isinstance(b, (float, int)), f"b should be float or integer your input : {b}"
+ assert isinstance(precision, int) and precision > 0, (
+ f"precision should be positive integer your input : {precision}"
+ )
+
+ # just applying the formula of simpson for approximate integration written in
# mentioned article in first comment of this file and above this function
h = (b - a) / N_STEPS
diff --git a/arithmetic_analysis/intersection.py b/maths/numerical_analysis/intersection.py
similarity index 89%
rename from arithmetic_analysis/intersection.py
rename to maths/numerical_analysis/intersection.py
index 204dd5d8a935..325abeaca996 100644
--- a/arithmetic_analysis/intersection.py
+++ b/maths/numerical_analysis/intersection.py
@@ -1,5 +1,5 @@
import math
-from typing import Callable
+from collections.abc import Callable
def intersection(function: Callable[[float], float], x0: float, x1: float) -> float:
@@ -10,7 +10,7 @@ def intersection(function: Callable[[float], float], x0: float, x1: float) -> fl
0.9999999999954654
>>> intersection(lambda x: x ** 3 - 1, 5, 5)
Traceback (most recent call last):
- ...
+ ...
ZeroDivisionError: float division by zero, could not find root
>>> intersection(lambda x: x ** 3 - 1, 100, 200)
1.0000000000003888
@@ -24,7 +24,7 @@ def intersection(function: Callable[[float], float], x0: float, x1: float) -> fl
0.0
>>> intersection(math.cos, -math.pi, math.pi)
Traceback (most recent call last):
- ...
+ ...
ZeroDivisionError: float division by zero, could not find root
"""
x_n: float = x0
@@ -35,13 +35,18 @@ def intersection(function: Callable[[float], float], x0: float, x1: float) -> fl
x_n2: float = x_n1 - (
function(x_n1) / ((function(x_n1) - function(x_n)) / (x_n1 - x_n))
)
- if abs(x_n2 - x_n1) < 10 ** -5:
+ if abs(x_n2 - x_n1) < 10**-5:
return x_n2
x_n = x_n1
x_n1 = x_n2
def f(x: float) -> float:
+ """
+ function is f(x) = x^3 - 2x - 5
+ >>> f(2)
+ -1.0
+ """
return math.pow(x, 3) - (2 * x) - 5
diff --git a/maths/numerical_analysis/nevilles_method.py b/maths/numerical_analysis/nevilles_method.py
new file mode 100644
index 000000000000..25c93ac6c531
--- /dev/null
+++ b/maths/numerical_analysis/nevilles_method.py
@@ -0,0 +1,55 @@
+"""
+Python program to show how to interpolate and evaluate a polynomial
+using Neville's method.
+Neville's method evaluates a polynomial that passes through a
+given set of x and y points for a particular x value (x0) using the
+Newton polynomial form.
+Reference:
+ https://rpubs.com/aaronsc32/nevilles-method-polynomial-interpolation
+"""
+
+
+def neville_interpolate(x_points: list, y_points: list, x0: int) -> list:
+ """
+ Interpolate and evaluate a polynomial using Neville's method.
+ Arguments:
+ x_points, y_points: Iterables of x and corresponding y points through
+ which the polynomial passes.
+ x0: The value of x to evaluate the polynomial for.
+ Return Value: A list of the approximated value and the Neville iterations
+ table respectively.
+ >>> import pprint
+ >>> neville_interpolate((1,2,3,4,6), (6,7,8,9,11), 5)[0]
+ 10.0
+ >>> pprint.pprint(neville_interpolate((1,2,3,4,6), (6,7,8,9,11), 99)[1])
+ [[0, 6, 0, 0, 0],
+ [0, 7, 0, 0, 0],
+ [0, 8, 104.0, 0, 0],
+ [0, 9, 104.0, 104.0, 0],
+ [0, 11, 104.0, 104.0, 104.0]]
+ >>> neville_interpolate((1,2,3,4,6), (6,7,8,9,11), 99)[0]
+ 104.0
+ >>> neville_interpolate((1,2,3,4,6), (6,7,8,9,11), '')
+ Traceback (most recent call last):
+ ...
+ TypeError: unsupported operand type(s) for -: 'str' and 'int'
+ """
+ n = len(x_points)
+ q = [[0] * n for i in range(n)]
+ for i in range(n):
+ q[i][1] = y_points[i]
+
+ for i in range(2, n):
+ for j in range(i, n):
+ q[j][i] = (
+ (x0 - x_points[j - i + 1]) * q[j][i - 1]
+ - (x0 - x_points[j]) * q[j - 1][i - 1]
+ ) / (x_points[j] - x_points[j - i + 1])
+
+ return [q[n - 1][n - 1], q]
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/arithmetic_analysis/newton_forward_interpolation.py b/maths/numerical_analysis/newton_forward_interpolation.py
similarity index 88%
rename from arithmetic_analysis/newton_forward_interpolation.py
rename to maths/numerical_analysis/newton_forward_interpolation.py
index d32e3efbd1f2..466f6c18cf59 100644
--- a/arithmetic_analysis/newton_forward_interpolation.py
+++ b/maths/numerical_analysis/newton_forward_interpolation.py
@@ -1,10 +1,11 @@
# https://www.geeksforgeeks.org/newton-forward-backward-interpolation/
+from __future__ import annotations
import math
# for calculating u value
-def ucal(u, p):
+def ucal(u: float, p: int) -> float:
"""
>>> ucal(1, 2)
0
@@ -19,10 +20,10 @@ def ucal(u, p):
return temp
-def main():
+def main() -> None:
n = int(input("enter the numbers of values: "))
- y = []
- for i in range(n):
+ y: list[list[float]] = []
+ for _ in range(n):
y.append([])
for i in range(n):
for j in range(n):
diff --git a/maths/numerical_analysis/newton_raphson.py b/maths/numerical_analysis/newton_raphson.py
new file mode 100644
index 000000000000..10fb244bf426
--- /dev/null
+++ b/maths/numerical_analysis/newton_raphson.py
@@ -0,0 +1,114 @@
+"""
+The Newton-Raphson method (aka the Newton method) is a root-finding algorithm that
+approximates a root of a given real-valued function f(x). It is an iterative method
+given by the formula
+
+x_{n + 1} = x_n + f(x_n) / f'(x_n)
+
+with the precision of the approximation increasing as the number of iterations increase.
+
+Reference: https://en.wikipedia.org/wiki/Newton%27s_method
+"""
+
+from collections.abc import Callable
+
+RealFunc = Callable[[float], float]
+
+
+def calc_derivative(f: RealFunc, x: float, delta_x: float = 1e-3) -> float:
+ """
+ Approximate the derivative of a function f(x) at a point x using the finite
+ difference method
+
+ >>> import math
+ >>> tolerance = 1e-5
+ >>> derivative = calc_derivative(lambda x: x**2, 2)
+ >>> math.isclose(derivative, 4, abs_tol=tolerance)
+ True
+ >>> derivative = calc_derivative(math.sin, 0)
+ >>> math.isclose(derivative, 1, abs_tol=tolerance)
+ True
+ """
+ return (f(x + delta_x / 2) - f(x - delta_x / 2)) / delta_x
+
+
+def newton_raphson(
+ f: RealFunc,
+ x0: float = 0,
+ max_iter: int = 100,
+ step: float = 1e-6,
+ max_error: float = 1e-6,
+ log_steps: bool = False,
+) -> tuple[float, float, list[float]]:
+ """
+ Find a root of the given function f using the Newton-Raphson method.
+
+ :param f: A real-valued single-variable function
+ :param x0: Initial guess
+ :param max_iter: Maximum number of iterations
+ :param step: Step size of x, used to approximate f'(x)
+ :param max_error: Maximum approximation error
+ :param log_steps: bool denoting whether to log intermediate steps
+
+ :return: A tuple containing the approximation, the error, and the intermediate
+ steps. If log_steps is False, then an empty list is returned for the third
+ element of the tuple.
+
+ :raises ZeroDivisionError: The derivative approaches 0.
+ :raises ArithmeticError: No solution exists, or the solution isn't found before the
+ iteration limit is reached.
+
+ >>> import math
+ >>> tolerance = 1e-15
+ >>> root, *_ = newton_raphson(lambda x: x**2 - 5*x + 2, 0.4, max_error=tolerance)
+ >>> math.isclose(root, (5 - math.sqrt(17)) / 2, abs_tol=tolerance)
+ True
+ >>> root, *_ = newton_raphson(lambda x: math.log(x) - 1, 2, max_error=tolerance)
+ >>> math.isclose(root, math.e, abs_tol=tolerance)
+ True
+ >>> root, *_ = newton_raphson(math.sin, 1, max_error=tolerance)
+ >>> math.isclose(root, 0, abs_tol=tolerance)
+ True
+ >>> newton_raphson(math.cos, 0)
+ Traceback (most recent call last):
+ ...
+ ZeroDivisionError: No converging solution found, zero derivative
+ >>> newton_raphson(lambda x: x**2 + 1, 2)
+ Traceback (most recent call last):
+ ...
+ ArithmeticError: No converging solution found, iteration limit reached
+ """
+
+ def f_derivative(x: float) -> float:
+ return calc_derivative(f, x, step)
+
+ a = x0 # Set initial guess
+ steps = []
+ for _ in range(max_iter):
+ if log_steps: # Log intermediate steps
+ steps.append(a)
+
+ error = abs(f(a))
+ if error < max_error:
+ return a, error, steps
+
+ if f_derivative(a) == 0:
+ raise ZeroDivisionError("No converging solution found, zero derivative")
+ a -= f(a) / f_derivative(a) # Calculate next estimate
+ raise ArithmeticError("No converging solution found, iteration limit reached")
+
+
+if __name__ == "__main__":
+ import doctest
+ from math import exp, tanh
+
+ doctest.testmod()
+
+ def func(x: float) -> float:
+ return tanh(x) ** 2 - exp(3 * x)
+
+ solution, err, steps = newton_raphson(
+ func, x0=10, max_iter=100, step=1e-6, log_steps=True
+ )
+ print(f"{solution=}, {err=}")
+ print("\n".join(str(x) for x in steps))
diff --git a/maths/numerical_integration.py b/maths/numerical_analysis/numerical_integration.py
similarity index 87%
rename from maths/numerical_integration.py
rename to maths/numerical_analysis/numerical_integration.py
index 87184a76b740..f64436ec48c1 100644
--- a/maths/numerical_integration.py
+++ b/maths/numerical_analysis/numerical_integration.py
@@ -2,16 +2,17 @@
Approximates the area under the curve using the trapezoidal rule
"""
-from typing import Callable, Union
+from __future__ import annotations
+
+from collections.abc import Callable
def trapezoidal_area(
- fnc: Callable[[Union[int, float]], Union[int, float]],
- x_start: Union[int, float],
- x_end: Union[int, float],
+ fnc: Callable[[float], float],
+ x_start: float,
+ x_end: float,
steps: int = 100,
) -> float:
-
"""
Treats curve as a collection of linear lines and sums the area of the
trapezium shape they form
@@ -38,8 +39,7 @@ def trapezoidal_area(
fx1 = fnc(x_start)
area = 0.0
- for i in range(steps):
-
+ for _ in range(steps):
# Approximates small segments of curve as linear and solve
# for trapezoidal area
x2 = (x_end - x_start) / steps + x1
@@ -55,7 +55,7 @@ def trapezoidal_area(
if __name__ == "__main__":
def f(x):
- return x ** 3
+ return x**3
print("f(x) = x^3")
print("The area between the curve, x = -10, x = 10 and the x axis is:")
diff --git a/maths/numerical_analysis/proper_fractions.py b/maths/numerical_analysis/proper_fractions.py
new file mode 100644
index 000000000000..774ce9a24876
--- /dev/null
+++ b/maths/numerical_analysis/proper_fractions.py
@@ -0,0 +1,40 @@
+from math import gcd
+
+
+def proper_fractions(denominator: int) -> list[str]:
+ """
+ this algorithm returns a list of proper fractions, in the
+ range between 0 and 1, which can be formed with the given denominator
+ https://en.wikipedia.org/wiki/Fraction#Proper_and_improper_fractions
+
+ >>> proper_fractions(10)
+ ['1/10', '3/10', '7/10', '9/10']
+ >>> proper_fractions(5)
+ ['1/5', '2/5', '3/5', '4/5']
+ >>> proper_fractions(-15)
+ Traceback (most recent call last):
+ ...
+ ValueError: The Denominator Cannot be less than 0
+ >>> proper_fractions(0)
+ []
+ >>> proper_fractions(1.2)
+ Traceback (most recent call last):
+ ...
+ ValueError: The Denominator must be an integer
+ """
+
+ if denominator < 0:
+ raise ValueError("The Denominator Cannot be less than 0")
+ elif isinstance(denominator, float):
+ raise ValueError("The Denominator must be an integer")
+ return [
+ f"{numerator}/{denominator}"
+ for numerator in range(1, denominator)
+ if gcd(numerator, denominator) == 1
+ ]
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
diff --git a/maths/runge_kutta.py b/maths/numerical_analysis/runge_kutta.py
similarity index 89%
rename from maths/runge_kutta.py
rename to maths/numerical_analysis/runge_kutta.py
index 383797daa5ac..3a25b0fb0173 100644
--- a/maths/runge_kutta.py
+++ b/maths/numerical_analysis/runge_kutta.py
@@ -19,15 +19,15 @@ def runge_kutta(f, y0, x0, h, x_end):
... return y
>>> y0 = 1
>>> y = runge_kutta(f, y0, 0.0, 0.01, 5)
- >>> y[-1]
+ >>> float(y[-1])
148.41315904125113
"""
- N = int(np.ceil((x_end - x0) / h))
- y = np.zeros((N + 1,))
+ n = int(np.ceil((x_end - x0) / h))
+ y = np.zeros((n + 1,))
y[0] = y0
x = x0
- for k in range(N):
+ for k in range(n):
k1 = f(x, y[k])
k2 = f(x + 0.5 * h, y[k] + 0.5 * h * k1)
k3 = f(x + 0.5 * h, y[k] + 0.5 * h * k2)
diff --git a/maths/numerical_analysis/runge_kutta_fehlberg_45.py b/maths/numerical_analysis/runge_kutta_fehlberg_45.py
new file mode 100644
index 000000000000..0fbd60a35c1a
--- /dev/null
+++ b/maths/numerical_analysis/runge_kutta_fehlberg_45.py
@@ -0,0 +1,114 @@
+"""
+Use the Runge-Kutta-Fehlberg method to solve Ordinary Differential Equations.
+"""
+
+from collections.abc import Callable
+
+import numpy as np
+
+
+def runge_kutta_fehlberg_45(
+ func: Callable,
+ x_initial: float,
+ y_initial: float,
+ step_size: float,
+ x_final: float,
+) -> np.ndarray:
+ """
+ Solve an Ordinary Differential Equations using Runge-Kutta-Fehlberg Method (rkf45)
+ of order 5.
+
+ https://en.wikipedia.org/wiki/Runge%E2%80%93Kutta%E2%80%93Fehlberg_method
+
+ args:
+ func: An ordinary differential equation (ODE) as function of x and y.
+ x_initial: The initial value of x.
+ y_initial: The initial value of y.
+ step_size: The increment value of x.
+ x_final: The final value of x.
+
+ Returns:
+ Solution of y at each nodal point
+
+ # exact value of y[1] is tan(0.2) = 0.2027100937470787
+ >>> def f(x, y):
+ ... return 1 + y**2
+ >>> y = runge_kutta_fehlberg_45(f, 0, 0, 0.2, 1)
+ >>> float(y[1])
+ 0.2027100937470787
+ >>> def f(x,y):
+ ... return x
+ >>> y = runge_kutta_fehlberg_45(f, -1, 0, 0.2, 0)
+ >>> float(y[1])
+ -0.18000000000000002
+ >>> y = runge_kutta_fehlberg_45(5, 0, 0, 0.1, 1)
+ Traceback (most recent call last):
+ ...
+ TypeError: 'int' object is not callable
+ >>> def f(x, y):
+ ... return x + y
+ >>> y = runge_kutta_fehlberg_45(f, 0, 0, 0.2, -1)
+ Traceback (most recent call last):
+ ...
+ ValueError: The final value of x must be greater than initial value of x.
+ >>> def f(x, y):
+ ... return x
+ >>> y = runge_kutta_fehlberg_45(f, -1, 0, -0.2, 0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Step size must be positive.
+ """
+ if x_initial >= x_final:
+ raise ValueError(
+ "The final value of x must be greater than initial value of x."
+ )
+
+ if step_size <= 0:
+ raise ValueError("Step size must be positive.")
+
+ n = int((x_final - x_initial) / step_size)
+ y = np.zeros(
+ (n + 1),
+ )
+ x = np.zeros(n + 1)
+ y[0] = y_initial
+ x[0] = x_initial
+ for i in range(n):
+ k1 = step_size * func(x[i], y[i])
+ k2 = step_size * func(x[i] + step_size / 4, y[i] + k1 / 4)
+ k3 = step_size * func(
+ x[i] + (3 / 8) * step_size, y[i] + (3 / 32) * k1 + (9 / 32) * k2
+ )
+ k4 = step_size * func(
+ x[i] + (12 / 13) * step_size,
+ y[i] + (1932 / 2197) * k1 - (7200 / 2197) * k2 + (7296 / 2197) * k3,
+ )
+ k5 = step_size * func(
+ x[i] + step_size,
+ y[i] + (439 / 216) * k1 - 8 * k2 + (3680 / 513) * k3 - (845 / 4104) * k4,
+ )
+ k6 = step_size * func(
+ x[i] + step_size / 2,
+ y[i]
+ - (8 / 27) * k1
+ + 2 * k2
+ - (3544 / 2565) * k3
+ + (1859 / 4104) * k4
+ - (11 / 40) * k5,
+ )
+ y[i + 1] = (
+ y[i]
+ + (16 / 135) * k1
+ + (6656 / 12825) * k3
+ + (28561 / 56430) * k4
+ - (9 / 50) * k5
+ + (2 / 55) * k6
+ )
+ x[i + 1] = step_size + x[i]
+ return y
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/numerical_analysis/runge_kutta_gills.py b/maths/numerical_analysis/runge_kutta_gills.py
new file mode 100644
index 000000000000..5d9672679813
--- /dev/null
+++ b/maths/numerical_analysis/runge_kutta_gills.py
@@ -0,0 +1,90 @@
+"""
+Use the Runge-Kutta-Gill's method of order 4 to solve Ordinary Differential Equations.
+
+https://www.geeksforgeeks.org/gills-4th-order-method-to-solve-differential-equations/
+Author : Ravi Kumar
+"""
+
+from collections.abc import Callable
+from math import sqrt
+
+import numpy as np
+
+
+def runge_kutta_gills(
+ func: Callable[[float, float], float],
+ x_initial: float,
+ y_initial: float,
+ step_size: float,
+ x_final: float,
+) -> np.ndarray:
+ """
+ Solve an Ordinary Differential Equations using Runge-Kutta-Gills Method of order 4.
+
+ args:
+ func: An ordinary differential equation (ODE) as function of x and y.
+ x_initial: The initial value of x.
+ y_initial: The initial value of y.
+ step_size: The increment value of x.
+ x_final: The final value of x.
+
+ Returns:
+ Solution of y at each nodal point
+
+ >>> def f(x, y):
+ ... return (x-y)/2
+ >>> y = runge_kutta_gills(f, 0, 3, 0.2, 5)
+ >>> float(y[-1])
+ 3.4104259225717537
+
+ >>> def f(x,y):
+ ... return x
+ >>> y = runge_kutta_gills(f, -1, 0, 0.2, 0)
+ >>> y
+ array([ 0. , -0.18, -0.32, -0.42, -0.48, -0.5 ])
+
+ >>> def f(x, y):
+ ... return x + y
+ >>> y = runge_kutta_gills(f, 0, 0, 0.2, -1)
+ Traceback (most recent call last):
+ ...
+ ValueError: The final value of x must be greater than initial value of x.
+
+ >>> def f(x, y):
+ ... return x
+ >>> y = runge_kutta_gills(f, -1, 0, -0.2, 0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Step size must be positive.
+ """
+ if x_initial >= x_final:
+ raise ValueError(
+ "The final value of x must be greater than initial value of x."
+ )
+
+ if step_size <= 0:
+ raise ValueError("Step size must be positive.")
+
+ n = int((x_final - x_initial) / step_size)
+ y = np.zeros(n + 1)
+ y[0] = y_initial
+ for i in range(n):
+ k1 = step_size * func(x_initial, y[i])
+ k2 = step_size * func(x_initial + step_size / 2, y[i] + k1 / 2)
+ k3 = step_size * func(
+ x_initial + step_size / 2,
+ y[i] + (-0.5 + 1 / sqrt(2)) * k1 + (1 - 1 / sqrt(2)) * k2,
+ )
+ k4 = step_size * func(
+ x_initial + step_size, y[i] - (1 / sqrt(2)) * k2 + (1 + 1 / sqrt(2)) * k3
+ )
+
+ y[i + 1] = y[i] + (k1 + (2 - sqrt(2)) * k2 + (2 + sqrt(2)) * k3 + k4) / 6
+ x_initial += step_size
+ return y
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/numerical_analysis/secant_method.py b/maths/numerical_analysis/secant_method.py
new file mode 100644
index 000000000000..9fff8222cdde
--- /dev/null
+++ b/maths/numerical_analysis/secant_method.py
@@ -0,0 +1,30 @@
+"""
+Implementing Secant method in Python
+Author: dimgrichr
+"""
+
+from math import exp
+
+
+def f(x: float) -> float:
+ """
+ >>> f(5)
+ 39.98652410600183
+ """
+ return 8 * x - 2 * exp(-x)
+
+
+def secant_method(lower_bound: float, upper_bound: float, repeats: int) -> float:
+ """
+ >>> secant_method(1, 3, 2)
+ 0.2139409276214589
+ """
+ x0 = lower_bound
+ x1 = upper_bound
+ for _ in range(repeats):
+ x0, x1 = x1, x1 - (f(x1) * (x1 - x0)) / (f(x1) - f(x0))
+ return x1
+
+
+if __name__ == "__main__":
+ print(f"Example: {secant_method(1, 3, 2)}")
diff --git a/maths/numerical_analysis/simpson_rule.py b/maths/numerical_analysis/simpson_rule.py
new file mode 100644
index 000000000000..e75fb557a2f5
--- /dev/null
+++ b/maths/numerical_analysis/simpson_rule.py
@@ -0,0 +1,86 @@
+"""
+Numerical integration or quadrature for a smooth function f with known values at x_i
+
+This method is the classical approach of summing 'Equally Spaced Abscissas'
+
+method 2:
+"Simpson Rule"
+
+"""
+
+
+def method_2(boundary: list[int], steps: int) -> float:
+ # "Simpson Rule"
+ # int(f) = delta_x/2 * (b-a)/3*(f1 + 4f2 + 2f_3 + ... + fn)
+ """
+ Calculate the definite integral of a function using Simpson's Rule.
+ :param boundary: A list containing the lower and upper bounds of integration.
+ :param steps: The number of steps or resolution for the integration.
+ :return: The approximate integral value.
+
+ >>> round(method_2([0, 2, 4], 10), 10)
+ 2.6666666667
+ >>> round(method_2([2, 0], 10), 10)
+ -0.2666666667
+ >>> round(method_2([-2, -1], 10), 10)
+ 2.172
+ >>> round(method_2([0, 1], 10), 10)
+ 0.3333333333
+ >>> round(method_2([0, 2], 10), 10)
+ 2.6666666667
+ >>> round(method_2([0, 2], 100), 10)
+ 2.5621226667
+ >>> round(method_2([0, 1], 1000), 10)
+ 0.3320026653
+ >>> round(method_2([0, 2], 0), 10)
+ Traceback (most recent call last):
+ ...
+ ZeroDivisionError: Number of steps must be greater than zero
+ >>> round(method_2([0, 2], -10), 10)
+ Traceback (most recent call last):
+ ...
+ ZeroDivisionError: Number of steps must be greater than zero
+ """
+ if steps <= 0:
+ raise ZeroDivisionError("Number of steps must be greater than zero")
+
+ h = (boundary[1] - boundary[0]) / steps
+ a = boundary[0]
+ b = boundary[1]
+ x_i = make_points(a, b, h)
+ y = 0.0
+ y += (h / 3.0) * f(a)
+ cnt = 2
+ for i in x_i:
+ y += (h / 3) * (4 - 2 * (cnt % 2)) * f(i)
+ cnt += 1
+ y += (h / 3.0) * f(b)
+ return y
+
+
+def make_points(a, b, h):
+ x = a + h
+ while x < (b - h):
+ yield x
+ x = x + h
+
+
+def f(x): # enter your function here
+ y = (x - 0) * (x - 0)
+ return y
+
+
+def main():
+ a = 0.0 # Lower bound of integration
+ b = 1.0 # Upper bound of integration
+ steps = 10.0 # number of steps or resolution
+ boundary = [a, b] # boundary of integration
+ y = method_2(boundary, steps)
+ print(f"y = {y}")
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+ main()
diff --git a/maths/square_root.py b/maths/numerical_analysis/square_root.py
similarity index 79%
rename from maths/square_root.py
rename to maths/numerical_analysis/square_root.py
index b324c723037c..4462ccb75261 100644
--- a/maths/square_root.py
+++ b/maths/numerical_analysis/square_root.py
@@ -19,14 +19,13 @@ def get_initial_point(a: float) -> float:
def square_root_iterative(
- a: float, max_iter: int = 9999, tolerance: float = 0.00000000000001
+ a: float, max_iter: int = 9999, tolerance: float = 1e-14
) -> float:
"""
- Square root is aproximated using Newtons method.
+ Square root approximated using Newton's method.
https://en.wikipedia.org/wiki/Newton%27s_method
- >>> all(abs(square_root_iterative(i)-math.sqrt(i)) <= .00000000000001
- ... for i in range(500))
+ >>> all(abs(square_root_iterative(i) - math.sqrt(i)) <= 1e-14 for i in range(500))
True
>>> square_root_iterative(-1)
@@ -49,7 +48,7 @@ def square_root_iterative(
value = get_initial_point(a)
- for i in range(max_iter):
+ for _ in range(max_iter):
prev_value = value
value = value - fx(value, a) / fx_derivative(value)
if abs(prev_value - value) < tolerance:
diff --git a/maths/odd_sieve.py b/maths/odd_sieve.py
new file mode 100644
index 000000000000..06605ca54296
--- /dev/null
+++ b/maths/odd_sieve.py
@@ -0,0 +1,42 @@
+from itertools import compress, repeat
+from math import ceil, sqrt
+
+
+def odd_sieve(num: int) -> list[int]:
+ """
+ Returns the prime numbers < `num`. The prime numbers are calculated using an
+ odd sieve implementation of the Sieve of Eratosthenes algorithm
+ (see for reference https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes).
+
+ >>> odd_sieve(2)
+ []
+ >>> odd_sieve(3)
+ [2]
+ >>> odd_sieve(10)
+ [2, 3, 5, 7]
+ >>> odd_sieve(20)
+ [2, 3, 5, 7, 11, 13, 17, 19]
+ """
+
+ if num <= 2:
+ return []
+ if num == 3:
+ return [2]
+
+ # Odd sieve for numbers in range [3, num - 1]
+ sieve = bytearray(b"\x01") * ((num >> 1) - 1)
+
+ for i in range(3, int(sqrt(num)) + 1, 2):
+ if sieve[(i >> 1) - 1]:
+ i_squared = i**2
+ sieve[(i_squared >> 1) - 1 :: i] = repeat(
+ 0, ceil((num - i_squared) / (i << 1))
+ )
+
+ return [2, *list(compress(range(3, num, 2), sieve))]
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/perfect_cube.py b/maths/perfect_cube.py
index 9ad287e41e75..a732b7cce6c8 100644
--- a/maths/perfect_cube.py
+++ b/maths/perfect_cube.py
@@ -11,6 +11,45 @@ def perfect_cube(n: int) -> bool:
return (val * val * val) == n
+def perfect_cube_binary_search(n: int) -> bool:
+ """
+ Check if a number is a perfect cube or not using binary search.
+ Time complexity : O(Log(n))
+ Space complexity: O(1)
+
+ >>> perfect_cube_binary_search(27)
+ True
+ >>> perfect_cube_binary_search(64)
+ True
+ >>> perfect_cube_binary_search(4)
+ False
+ >>> perfect_cube_binary_search("a")
+ Traceback (most recent call last):
+ ...
+ TypeError: perfect_cube_binary_search() only accepts integers
+ >>> perfect_cube_binary_search(0.1)
+ Traceback (most recent call last):
+ ...
+ TypeError: perfect_cube_binary_search() only accepts integers
+ """
+ if not isinstance(n, int):
+ raise TypeError("perfect_cube_binary_search() only accepts integers")
+ if n < 0:
+ n = -n
+ left = 0
+ right = n
+ while left <= right:
+ mid = left + (right - left) // 2
+ if mid * mid * mid == n:
+ return True
+ elif mid * mid * mid < n:
+ left = mid + 1
+ else:
+ right = mid - 1
+ return False
+
+
if __name__ == "__main__":
- print(perfect_cube(27))
- print(perfect_cube(4))
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/perfect_number.py b/maths/perfect_number.py
index 148e988fb4c5..52c816cc7895 100644
--- a/maths/perfect_number.py
+++ b/maths/perfect_number.py
@@ -14,21 +14,73 @@
def perfect(number: int) -> bool:
"""
+ Check if a number is a perfect number.
+
+ A perfect number is a positive integer that is equal to the sum of its proper
+ divisors (excluding itself).
+
+ Args:
+ number: The number to be checked.
+
+ Returns:
+ True if the number is a perfect number otherwise, False.
+ Start from 1 because dividing by 0 will raise ZeroDivisionError.
+ A number at most can be divisible by the half of the number except the number
+ itself. For example, 6 is at most can be divisible by 3 except by 6 itself.
+ Examples:
>>> perfect(27)
False
>>> perfect(28)
True
>>> perfect(29)
False
-
- Start from 1 because dividing by 0 will raise ZeroDivisionError.
- A number at most can be divisible by the half of the number except the number
- itself. For example, 6 is at most can be divisible by 3 except by 6 itself.
+ >>> perfect(6)
+ True
+ >>> perfect(12)
+ False
+ >>> perfect(496)
+ True
+ >>> perfect(8128)
+ True
+ >>> perfect(0)
+ False
+ >>> perfect(-1)
+ False
+ >>> perfect(33550336) # Large perfect number
+ True
+ >>> perfect(33550337) # Just above a large perfect number
+ False
+ >>> perfect(1) # Edge case: 1 is not a perfect number
+ False
+ >>> perfect("123") # String representation of a number
+ Traceback (most recent call last):
+ ...
+ ValueError: number must be an integer
+ >>> perfect(12.34)
+ Traceback (most recent call last):
+ ...
+ ValueError: number must be an integer
+ >>> perfect("Hello")
+ Traceback (most recent call last):
+ ...
+ ValueError: number must be an integer
"""
+ if not isinstance(number, int):
+ raise ValueError("number must be an integer")
+ if number <= 0:
+ return False
return sum(i for i in range(1, number // 2 + 1) if number % i == 0) == number
if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
print("Program to check whether a number is a Perfect number or not...")
- number = int(input("Enter number: ").strip())
+ try:
+ number = int(input("Enter a positive integer: ").strip())
+ except ValueError:
+ msg = "number must be an integer"
+ raise ValueError(msg)
+
print(f"{number} is {'' if perfect(number) else 'not '}a Perfect Number.")
diff --git a/maths/perfect_square.py b/maths/perfect_square.py
index 4393dcfbc774..107e68528068 100644
--- a/maths/perfect_square.py
+++ b/maths/perfect_square.py
@@ -58,9 +58,9 @@ def perfect_square_binary_search(n: int) -> bool:
right = n
while left <= right:
mid = (left + right) // 2
- if mid ** 2 == n:
+ if mid**2 == n:
return True
- elif mid ** 2 > n:
+ elif mid**2 > n:
right = mid - 1
else:
left = mid + 1
diff --git a/maths/persistence.py b/maths/persistence.py
new file mode 100644
index 000000000000..c61a69a7c27d
--- /dev/null
+++ b/maths/persistence.py
@@ -0,0 +1,82 @@
+def multiplicative_persistence(num: int) -> int:
+ """
+ Return the persistence of a given number.
+
+ https://en.wikipedia.org/wiki/Persistence_of_a_number
+
+ >>> multiplicative_persistence(217)
+ 2
+ >>> multiplicative_persistence(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: multiplicative_persistence() does not accept negative values
+ >>> multiplicative_persistence("long number")
+ Traceback (most recent call last):
+ ...
+ ValueError: multiplicative_persistence() only accepts integral values
+ """
+
+ if not isinstance(num, int):
+ raise ValueError("multiplicative_persistence() only accepts integral values")
+ if num < 0:
+ raise ValueError("multiplicative_persistence() does not accept negative values")
+
+ steps = 0
+ num_string = str(num)
+
+ while len(num_string) != 1:
+ numbers = [int(i) for i in num_string]
+
+ total = 1
+ for i in range(len(numbers)):
+ total *= numbers[i]
+
+ num_string = str(total)
+
+ steps += 1
+ return steps
+
+
+def additive_persistence(num: int) -> int:
+ """
+ Return the persistence of a given number.
+
+ https://en.wikipedia.org/wiki/Persistence_of_a_number
+
+ >>> additive_persistence(199)
+ 3
+ >>> additive_persistence(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: additive_persistence() does not accept negative values
+ >>> additive_persistence("long number")
+ Traceback (most recent call last):
+ ...
+ ValueError: additive_persistence() only accepts integral values
+ """
+
+ if not isinstance(num, int):
+ raise ValueError("additive_persistence() only accepts integral values")
+ if num < 0:
+ raise ValueError("additive_persistence() does not accept negative values")
+
+ steps = 0
+ num_string = str(num)
+
+ while len(num_string) != 1:
+ numbers = [int(i) for i in num_string]
+
+ total = 0
+ for i in range(len(numbers)):
+ total += numbers[i]
+
+ num_string = str(total)
+
+ steps += 1
+ return steps
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/pi_generator.py b/maths/pi_generator.py
new file mode 100644
index 000000000000..97f2c540c1ce
--- /dev/null
+++ b/maths/pi_generator.py
@@ -0,0 +1,87 @@
+def calculate_pi(limit: int) -> str:
+ """
+ https://en.wikipedia.org/wiki/Leibniz_formula_for_%CF%80
+ Leibniz Formula for Pi
+
+ The Leibniz formula is the special case arctan(1) = pi / 4.
+ Leibniz's formula converges extremely slowly: it exhibits sublinear convergence.
+
+ Convergence (https://en.wikipedia.org/wiki/Leibniz_formula_for_%CF%80#Convergence)
+
+ We cannot try to prove against an interrupted, uncompleted generation.
+ https://en.wikipedia.org/wiki/Leibniz_formula_for_%CF%80#Unusual_behaviour
+ The errors can in fact be predicted, but those calculations also approach infinity
+ for accuracy.
+
+ Our output will be a string so that we can definitely store all digits.
+
+ >>> import math
+ >>> float(calculate_pi(15)) == math.pi
+ True
+
+ Since we cannot predict errors or interrupt any infinite alternating series
+ generation since they approach infinity, or interrupt any alternating series, we'll
+ need math.isclose()
+
+ >>> math.isclose(float(calculate_pi(50)), math.pi)
+ True
+ >>> math.isclose(float(calculate_pi(100)), math.pi)
+ True
+
+ Since math.pi contains only 16 digits, here are some tests with known values:
+
+ >>> calculate_pi(50)
+ '3.14159265358979323846264338327950288419716939937510'
+ >>> calculate_pi(80)
+ '3.14159265358979323846264338327950288419716939937510582097494459230781640628620899'
+ """
+ # Variables used for the iteration process
+ q = 1
+ r = 0
+ t = 1
+ k = 1
+ n = 3
+ m = 3
+
+ decimal = limit
+ counter = 0
+
+ result = ""
+
+ # We can't compare against anything if we make a generator,
+ # so we'll stick with plain return logic
+ while counter != decimal + 1:
+ if 4 * q + r - t < n * t:
+ result += str(n)
+ if counter == 0:
+ result += "."
+
+ if decimal == counter:
+ break
+
+ counter += 1
+ nr = 10 * (r - n * t)
+ n = ((10 * (3 * q + r)) // t) - 10 * n
+ q *= 10
+ r = nr
+ else:
+ nr = (2 * q + r) * m
+ nn = (q * (7 * k) + 2 + (r * m)) // (t * m)
+ q *= k
+ t *= m
+ m += 2
+ k += 1
+ n = nn
+ r = nr
+ return result
+
+
+def main() -> None:
+ print(f"{calculate_pi(50) = }")
+ import doctest
+
+ doctest.testmod()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/maths/pi_monte_carlo_estimation.py b/maths/pi_monte_carlo_estimation.py
index 20b46dddc6e5..29b679907239 100644
--- a/maths/pi_monte_carlo_estimation.py
+++ b/maths/pi_monte_carlo_estimation.py
@@ -11,7 +11,7 @@ def is_in_unit_circle(self) -> bool:
True, if the point lies in the unit circle
False, otherwise
"""
- return (self.x ** 2 + self.y ** 2) <= 1
+ return (self.x**2 + self.y**2) <= 1
@classmethod
def random_unit_square(cls):
@@ -47,7 +47,7 @@ def estimate_pi(number_of_simulations: int) -> float:
raise ValueError("At least one simulation is necessary to estimate PI.")
number_in_unit_circle = 0
- for simulation_index in range(number_of_simulations):
+ for _ in range(number_of_simulations):
random_point = Point.random_unit_square()
if random_point.is_in_unit_circle():
diff --git a/maths/points_are_collinear_3d.py b/maths/points_are_collinear_3d.py
new file mode 100644
index 000000000000..c7adddda9494
--- /dev/null
+++ b/maths/points_are_collinear_3d.py
@@ -0,0 +1,126 @@
+"""
+Check if three points are collinear in 3D.
+
+In short, the idea is that we are able to create a triangle using three points,
+and the area of that triangle can determine if the three points are collinear or not.
+
+
+First, we create two vectors with the same initial point from the three points,
+then we will calculate the cross-product of them.
+
+The length of the cross vector is numerically equal to the area of a parallelogram.
+
+Finally, the area of the triangle is equal to half of the area of the parallelogram.
+
+Since we are only differentiating between zero and anything else,
+we can get rid of the square root when calculating the length of the vector,
+and also the division by two at the end.
+
+From a second perspective, if the two vectors are parallel and overlapping,
+we can't get a nonzero perpendicular vector,
+since there will be an infinite number of orthogonal vectors.
+
+To simplify the solution we will not calculate the length,
+but we will decide directly from the vector whether it is equal to (0, 0, 0) or not.
+
+
+Read More:
+ https://math.stackexchange.com/a/1951650
+"""
+
+Vector3d = tuple[float, float, float]
+Point3d = tuple[float, float, float]
+
+
+def create_vector(end_point1: Point3d, end_point2: Point3d) -> Vector3d:
+ """
+ Pass two points to get the vector from them in the form (x, y, z).
+
+ >>> create_vector((0, 0, 0), (1, 1, 1))
+ (1, 1, 1)
+ >>> create_vector((45, 70, 24), (47, 32, 1))
+ (2, -38, -23)
+ >>> create_vector((-14, -1, -8), (-7, 6, 4))
+ (7, 7, 12)
+ """
+ x = end_point2[0] - end_point1[0]
+ y = end_point2[1] - end_point1[1]
+ z = end_point2[2] - end_point1[2]
+ return (x, y, z)
+
+
+def get_3d_vectors_cross(ab: Vector3d, ac: Vector3d) -> Vector3d:
+ """
+ Get the cross of the two vectors AB and AC.
+
+ I used determinant of 2x2 to get the determinant of the 3x3 matrix in the process.
+
+ Read More:
+ https://en.wikipedia.org/wiki/Cross_product
+ https://en.wikipedia.org/wiki/Determinant
+
+ >>> get_3d_vectors_cross((3, 4, 7), (4, 9, 2))
+ (-55, 22, 11)
+ >>> get_3d_vectors_cross((1, 1, 1), (1, 1, 1))
+ (0, 0, 0)
+ >>> get_3d_vectors_cross((-4, 3, 0), (3, -9, -12))
+ (-36, -48, 27)
+ >>> get_3d_vectors_cross((17.67, 4.7, 6.78), (-9.5, 4.78, -19.33))
+ (-123.2594, 277.15110000000004, 129.11260000000001)
+ """
+ x = ab[1] * ac[2] - ab[2] * ac[1] # *i
+ y = (ab[0] * ac[2] - ab[2] * ac[0]) * -1 # *j
+ z = ab[0] * ac[1] - ab[1] * ac[0] # *k
+ return (x, y, z)
+
+
+def is_zero_vector(vector: Vector3d, accuracy: int) -> bool:
+ """
+ Check if vector is equal to (0, 0, 0) or not.
+
+ Since the algorithm is very accurate, we will never get a zero vector,
+ so we need to round the vector axis,
+ because we want a result that is either True or False.
+ In other applications, we can return a float that represents the collinearity ratio.
+
+ >>> is_zero_vector((0, 0, 0), accuracy=10)
+ True
+ >>> is_zero_vector((15, 74, 32), accuracy=10)
+ False
+ >>> is_zero_vector((-15, -74, -32), accuracy=10)
+ False
+ """
+ return tuple(round(x, accuracy) for x in vector) == (0, 0, 0)
+
+
+def are_collinear(a: Point3d, b: Point3d, c: Point3d, accuracy: int = 10) -> bool:
+ """
+ Check if three points are collinear or not.
+
+ 1- Create two vectors AB and AC.
+ 2- Get the cross vector of the two vectors.
+ 3- Calculate the length of the cross vector.
+ 4- If the length is zero then the points are collinear, else they are not.
+
+ The use of the accuracy parameter is explained in is_zero_vector docstring.
+
+ >>> are_collinear((4.802293498137402, 3.536233125455244, 0),
+ ... (-2.186788107953106, -9.24561398001649, 7.141509524846482),
+ ... (1.530169574640268, -2.447927606600034, 3.343487096469054))
+ True
+ >>> are_collinear((-6, -2, 6),
+ ... (6.200213806439997, -4.930157614926678, -4.482371908289856),
+ ... (-4.085171149525941, -2.459889509029438, 4.354787180795383))
+ True
+ >>> are_collinear((2.399001826862445, -2.452009976680793, 4.464656666157666),
+ ... (-3.682816335934376, 5.753788986533145, 9.490993909044244),
+ ... (1.962903518985307, 3.741415730125627, 7))
+ False
+ >>> are_collinear((1.875375340689544, -7.268426006071538, 7.358196269835993),
+ ... (-3.546599383667157, -4.630005261513976, 3.208784032924246),
+ ... (-2.564606140206386, 3.937845170672183, 7))
+ False
+ """
+ ab = create_vector(a, b)
+ ac = create_vector(a, c)
+ return is_zero_vector(get_3d_vectors_cross(ab, ac), accuracy)
diff --git a/maths/pollard_rho.py b/maths/pollard_rho.py
new file mode 100644
index 000000000000..e8bc89cef6c5
--- /dev/null
+++ b/maths/pollard_rho.py
@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+from math import gcd
+
+
+def pollard_rho(
+ num: int,
+ seed: int = 2,
+ step: int = 1,
+ attempts: int = 3,
+) -> int | None:
+ """
+ Use Pollard's Rho algorithm to return a nontrivial factor of ``num``.
+ The returned factor may be composite and require further factorization.
+ If the algorithm will return None if it fails to find a factor within
+ the specified number of attempts or within the specified number of steps.
+ If ``num`` is prime, this algorithm is guaranteed to return None.
+ https://en.wikipedia.org/wiki/Pollard%27s_rho_algorithm
+
+ >>> pollard_rho(18446744073709551617)
+ 274177
+ >>> pollard_rho(97546105601219326301)
+ 9876543191
+ >>> pollard_rho(100)
+ 2
+ >>> pollard_rho(17)
+ >>> pollard_rho(17**3)
+ 17
+ >>> pollard_rho(17**3, attempts=1)
+ >>> pollard_rho(3*5*7)
+ 21
+ >>> pollard_rho(1)
+ Traceback (most recent call last):
+ ...
+ ValueError: The input value cannot be less than 2
+ """
+ # A value less than 2 can cause an infinite loop in the algorithm.
+ if num < 2:
+ raise ValueError("The input value cannot be less than 2")
+
+ # Because of the relationship between ``f(f(x))`` and ``f(x)``, this
+ # algorithm struggles to find factors that are divisible by two.
+ # As a workaround, we specifically check for two and even inputs.
+ # See: https://math.stackexchange.com/a/2856214/165820
+ if num > 2 and num % 2 == 0:
+ return 2
+
+ # Pollard's Rho algorithm requires a function that returns pseudorandom
+ # values between 0 <= X < ``num``. It doesn't need to be random in the
+ # sense that the output value is cryptographically secure or difficult
+ # to calculate, it only needs to be random in the sense that all output
+ # values should be equally likely to appear.
+ # For this reason, Pollard suggested using ``f(x) = (x**2 - 1) % num``
+ # However, the success of Pollard's algorithm isn't guaranteed and is
+ # determined in part by the initial seed and the chosen random function.
+ # To make retries easier, we will instead use ``f(x) = (x**2 + C) % num``
+ # where ``C`` is a value that we can modify between each attempt.
+ def rand_fn(value: int, step: int, modulus: int) -> int:
+ """
+ Returns a pseudorandom value modulo ``modulus`` based on the
+ input ``value`` and attempt-specific ``step`` size.
+
+ >>> rand_fn(0, 0, 0)
+ Traceback (most recent call last):
+ ...
+ ZeroDivisionError: integer division or modulo by zero
+ >>> rand_fn(1, 2, 3)
+ 0
+ >>> rand_fn(0, 10, 7)
+ 3
+ >>> rand_fn(1234, 1, 17)
+ 16
+ """
+ return (pow(value, 2) + step) % modulus
+
+ for _ in range(attempts):
+ # These track the position within the cycle detection logic.
+ tortoise = seed
+ hare = seed
+
+ while True:
+ # At each iteration, the tortoise moves one step and the hare moves two.
+ tortoise = rand_fn(tortoise, step, num)
+ hare = rand_fn(hare, step, num)
+ hare = rand_fn(hare, step, num)
+
+ # At some point both the tortoise and the hare will enter a cycle whose
+ # length ``p`` is a divisor of ``num``. Once in that cycle, at some point
+ # the tortoise and hare will end up on the same value modulo ``p``.
+ # We can detect when this happens because the position difference between
+ # the tortoise and the hare will share a common divisor with ``num``.
+ divisor = gcd(hare - tortoise, num)
+
+ if divisor == 1:
+ # No common divisor yet, just keep searching.
+ continue
+ # We found a common divisor!
+ elif divisor == num:
+ # Unfortunately, the divisor is ``num`` itself and is useless.
+ break
+ else:
+ # The divisor is a nontrivial factor of ``num``!
+ return divisor
+
+ # If we made it here, then this attempt failed.
+ # We need to pick a new starting seed for the tortoise and hare
+ # in addition to a new step value for the random function.
+ # To keep this example implementation deterministic, the
+ # new values will be generated based on currently available
+ # values instead of using something like ``random.randint``.
+
+ # We can use the hare's position as the new seed.
+ # This is actually what Richard Brent's the "optimized" variant does.
+ seed = hare
+
+ # The new step value for the random function can just be incremented.
+ # At first the results will be similar to what the old function would
+ # have produced, but the value will quickly diverge after a bit.
+ step += 1
+
+ # We haven't found a divisor within the requested number of attempts.
+ # We were unlucky or ``num`` itself is actually prime.
+ return None
+
+
+if __name__ == "__main__":
+ import argparse
+
+ parser = argparse.ArgumentParser()
+ parser.add_argument(
+ "num",
+ type=int,
+ help="The value to find a divisor of",
+ )
+ parser.add_argument(
+ "--attempts",
+ type=int,
+ default=3,
+ help="The number of attempts before giving up",
+ )
+ args = parser.parse_args()
+
+ divisor = pollard_rho(args.num, attempts=args.attempts)
+ if divisor is None:
+ print(f"{args.num} is probably prime")
+ else:
+ quotient = args.num // divisor
+ print(f"{args.num} = {divisor} * {quotient}")
diff --git a/maths/polynomial_evaluation.py b/maths/polynomial_evaluation.py
index e929a2d02972..90a51f521e01 100644
--- a/maths/polynomial_evaluation.py
+++ b/maths/polynomial_evaluation.py
@@ -1,18 +1,18 @@
-from typing import Sequence
+from collections.abc import Sequence
def evaluate_poly(poly: Sequence[float], x: float) -> float:
"""Evaluate a polynomial f(x) at specified point x and return the value.
Arguments:
- poly -- the coeffiecients of a polynomial as an iterable in order of
+ poly -- the coefficients of a polynomial as an iterable in order of
ascending degree
x -- the point at which to evaluate the polynomial
>>> evaluate_poly((0.0, 0.0, 5.0, 9.3, 7.0), 10.0)
79800.0
"""
- return sum(c * (x ** i) for i, c in enumerate(poly))
+ return sum(c * (x**i) for i, c in enumerate(poly))
def horner(poly: Sequence[float], x: float) -> float:
@@ -26,7 +26,7 @@ def horner(poly: Sequence[float], x: float) -> float:
https://en.wikipedia.org/wiki/Horner's_method
Arguments:
- poly -- the coeffiecients of a polynomial as an iterable in order of
+ poly -- the coefficients of a polynomial as an iterable in order of
ascending degree
x -- the point at which to evaluate the polynomial
@@ -45,7 +45,7 @@ def horner(poly: Sequence[float], x: float) -> float:
>>> poly = (0.0, 0.0, 5.0, 9.3, 7.0) # f(x) = 7.0x^4 + 9.3x^3 + 5.0x^2
>>> x = -13.0
>>> # f(-13) = 7.0(-13)^4 + 9.3(-13)^3 + 5.0(-13)^2 = 180339.9
- >>> print(evaluate_poly(poly, x))
+ >>> evaluate_poly(poly, x)
180339.9
"""
poly = (0.0, 0.0, 5.0, 9.3, 7.0)
diff --git a/maths/polynomials/__init__.py b/maths/polynomials/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/maths/polynomials/single_indeterminate_operations.py b/maths/polynomials/single_indeterminate_operations.py
new file mode 100644
index 000000000000..e31e6caa3988
--- /dev/null
+++ b/maths/polynomials/single_indeterminate_operations.py
@@ -0,0 +1,188 @@
+"""
+
+This module implements a single indeterminate polynomials class
+with some basic operations
+
+Reference: https://en.wikipedia.org/wiki/Polynomial
+
+"""
+
+from __future__ import annotations
+
+from collections.abc import MutableSequence
+
+
+class Polynomial:
+ def __init__(self, degree: int, coefficients: MutableSequence[float]) -> None:
+ """
+ The coefficients should be in order of degree, from smallest to largest.
+ >>> p = Polynomial(2, [1, 2, 3])
+ >>> p = Polynomial(2, [1, 2, 3, 4])
+ Traceback (most recent call last):
+ ...
+ ValueError: The number of coefficients should be equal to the degree + 1.
+
+ """
+ if len(coefficients) != degree + 1:
+ raise ValueError(
+ "The number of coefficients should be equal to the degree + 1."
+ )
+
+ self.coefficients: list[float] = list(coefficients)
+ self.degree = degree
+
+ def __add__(self, polynomial_2: Polynomial) -> Polynomial:
+ """
+ Polynomial addition
+ >>> p = Polynomial(2, [1, 2, 3])
+ >>> q = Polynomial(2, [1, 2, 3])
+ >>> p + q
+ 6x^2 + 4x + 2
+ """
+
+ if self.degree > polynomial_2.degree:
+ coefficients = self.coefficients[:]
+ for i in range(polynomial_2.degree + 1):
+ coefficients[i] += polynomial_2.coefficients[i]
+ return Polynomial(self.degree, coefficients)
+ else:
+ coefficients = polynomial_2.coefficients[:]
+ for i in range(self.degree + 1):
+ coefficients[i] += self.coefficients[i]
+ return Polynomial(polynomial_2.degree, coefficients)
+
+ def __sub__(self, polynomial_2: Polynomial) -> Polynomial:
+ """
+ Polynomial subtraction
+ >>> p = Polynomial(2, [1, 2, 4])
+ >>> q = Polynomial(2, [1, 2, 3])
+ >>> p - q
+ 1x^2
+ """
+ return self + polynomial_2 * Polynomial(0, [-1])
+
+ def __neg__(self) -> Polynomial:
+ """
+ Polynomial negation
+ >>> p = Polynomial(2, [1, 2, 3])
+ >>> -p
+ - 3x^2 - 2x - 1
+ """
+ return Polynomial(self.degree, [-c for c in self.coefficients])
+
+ def __mul__(self, polynomial_2: Polynomial) -> Polynomial:
+ """
+ Polynomial multiplication
+ >>> p = Polynomial(2, [1, 2, 3])
+ >>> q = Polynomial(2, [1, 2, 3])
+ >>> p * q
+ 9x^4 + 12x^3 + 10x^2 + 4x + 1
+ """
+ coefficients: list[float] = [0] * (self.degree + polynomial_2.degree + 1)
+ for i in range(self.degree + 1):
+ for j in range(polynomial_2.degree + 1):
+ coefficients[i + j] += (
+ self.coefficients[i] * polynomial_2.coefficients[j]
+ )
+
+ return Polynomial(self.degree + polynomial_2.degree, coefficients)
+
+ def evaluate(self, substitution: float) -> float:
+ """
+ Evaluates the polynomial at x.
+ >>> p = Polynomial(2, [1, 2, 3])
+ >>> p.evaluate(2)
+ 17
+ """
+ result: int | float = 0
+ for i in range(self.degree + 1):
+ result += self.coefficients[i] * (substitution**i)
+ return result
+
+ def __str__(self) -> str:
+ """
+ >>> p = Polynomial(2, [1, 2, 3])
+ >>> print(p)
+ 3x^2 + 2x + 1
+ """
+ polynomial = ""
+ for i in range(self.degree, -1, -1):
+ if self.coefficients[i] == 0:
+ continue
+ elif self.coefficients[i] > 0:
+ if polynomial:
+ polynomial += " + "
+ else:
+ polynomial += " - "
+
+ if i == 0:
+ polynomial += str(abs(self.coefficients[i]))
+ elif i == 1:
+ polynomial += str(abs(self.coefficients[i])) + "x"
+ else:
+ polynomial += str(abs(self.coefficients[i])) + "x^" + str(i)
+
+ return polynomial
+
+ def __repr__(self) -> str:
+ """
+ >>> p = Polynomial(2, [1, 2, 3])
+ >>> p
+ 3x^2 + 2x + 1
+ """
+ return self.__str__()
+
+ def derivative(self) -> Polynomial:
+ """
+ Returns the derivative of the polynomial.
+ >>> p = Polynomial(2, [1, 2, 3])
+ >>> p.derivative()
+ 6x + 2
+ """
+ coefficients: list[float] = [0] * self.degree
+ for i in range(self.degree):
+ coefficients[i] = self.coefficients[i + 1] * (i + 1)
+ return Polynomial(self.degree - 1, coefficients)
+
+ def integral(self, constant: float = 0) -> Polynomial:
+ """
+ Returns the integral of the polynomial.
+ >>> p = Polynomial(2, [1, 2, 3])
+ >>> p.integral()
+ 1.0x^3 + 1.0x^2 + 1.0x
+ """
+ coefficients: list[float] = [0] * (self.degree + 2)
+ coefficients[0] = constant
+ for i in range(self.degree + 1):
+ coefficients[i + 1] = self.coefficients[i] / (i + 1)
+ return Polynomial(self.degree + 1, coefficients)
+
+ def __eq__(self, polynomial_2: object) -> bool:
+ """
+ Checks if two polynomials are equal.
+ >>> p = Polynomial(2, [1, 2, 3])
+ >>> q = Polynomial(2, [1, 2, 3])
+ >>> p == q
+ True
+ """
+ if not isinstance(polynomial_2, Polynomial):
+ return False
+
+ if self.degree != polynomial_2.degree:
+ return False
+
+ for i in range(self.degree + 1):
+ if self.coefficients[i] != polynomial_2.coefficients[i]:
+ return False
+
+ return True
+
+ def __ne__(self, polynomial_2: object) -> bool:
+ """
+ Checks if two polynomials are not equal.
+ >>> p = Polynomial(2, [1, 2, 3])
+ >>> q = Polynomial(2, [1, 2, 3])
+ >>> p != q
+ False
+ """
+ return not self.__eq__(polynomial_2)
diff --git a/maths/power_using_recursion.py b/maths/power_using_recursion.py
index f82097f6d8ec..eb775b161ae8 100644
--- a/maths/power_using_recursion.py
+++ b/maths/power_using_recursion.py
@@ -15,18 +15,45 @@
def power(base: int, exponent: int) -> float:
"""
- power(3, 4)
+ Calculate the power of a base raised to an exponent.
+
+ >>> power(3, 4)
81
>>> power(2, 0)
1
>>> all(power(base, exponent) == pow(base, exponent)
... for base in range(-10, 10) for exponent in range(10))
True
+ >>> power('a', 1)
+ 'a'
+ >>> power('a', 2)
+ Traceback (most recent call last):
+ ...
+ TypeError: can't multiply sequence by non-int of type 'str'
+ >>> power('a', 'b')
+ Traceback (most recent call last):
+ ...
+ TypeError: unsupported operand type(s) for -: 'str' and 'int'
+ >>> power(2, -1)
+ Traceback (most recent call last):
+ ...
+ RecursionError: maximum recursion depth exceeded
+ >>> power(0, 0)
+ 1
+ >>> power(0, 1)
+ 0
+ >>> power(5,6)
+ 15625
+ >>> power(23, 12)
+ 21914624432020321
"""
return base * power(base, (exponent - 1)) if exponent else 1
if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
print("Raise base to the power of exponent using recursion...")
base = int(input("Enter the base: ").strip())
exponent = int(input("Enter the exponent: ").strip())
diff --git a/maths/prime_check.py b/maths/prime_check.py
index e2bcb7b8f151..a757c4108f24 100644
--- a/maths/prime_check.py
+++ b/maths/prime_check.py
@@ -3,55 +3,87 @@
import math
import unittest
+import pytest
-def prime_check(number: int) -> bool:
- """Checks to see if a number is a prime.
+
+def is_prime(number: int) -> bool:
+ """Checks to see if a number is a prime in O(sqrt(n)).
A number is prime if it has exactly two factors: 1 and itself.
+
+ >>> is_prime(0)
+ False
+ >>> is_prime(1)
+ False
+ >>> is_prime(2)
+ True
+ >>> is_prime(3)
+ True
+ >>> is_prime(27)
+ False
+ >>> is_prime(87)
+ False
+ >>> is_prime(563)
+ True
+ >>> is_prime(2999)
+ True
+ >>> is_prime(67483)
+ False
+ >>> is_prime(16.1)
+ Traceback (most recent call last):
+ ...
+ ValueError: is_prime() only accepts positive integers
+ >>> is_prime(-4)
+ Traceback (most recent call last):
+ ...
+ ValueError: is_prime() only accepts positive integers
"""
+ # precondition
+ if not isinstance(number, int) or not number >= 0:
+ raise ValueError("is_prime() only accepts positive integers")
+
if 1 < number < 4:
# 2 and 3 are primes
return True
- elif number < 2 or not number % 2:
- # Negatives, 0, 1 and all even numbers are not primes
+ elif number < 2 or number % 2 == 0 or number % 3 == 0:
+ # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
return False
- odd_numbers = range(3, int(math.sqrt(number) + 1), 2)
- return not any(not number % i for i in odd_numbers)
+ # All primes number are in format of 6k +/- 1
+ for i in range(5, int(math.sqrt(number) + 1), 6):
+ if number % i == 0 or number % (i + 2) == 0:
+ return False
+ return True
class Test(unittest.TestCase):
def test_primes(self):
- self.assertTrue(prime_check(2))
- self.assertTrue(prime_check(3))
- self.assertTrue(prime_check(5))
- self.assertTrue(prime_check(7))
- self.assertTrue(prime_check(11))
- self.assertTrue(prime_check(13))
- self.assertTrue(prime_check(17))
- self.assertTrue(prime_check(19))
- self.assertTrue(prime_check(23))
- self.assertTrue(prime_check(29))
+ assert is_prime(2)
+ assert is_prime(3)
+ assert is_prime(5)
+ assert is_prime(7)
+ assert is_prime(11)
+ assert is_prime(13)
+ assert is_prime(17)
+ assert is_prime(19)
+ assert is_prime(23)
+ assert is_prime(29)
def test_not_primes(self):
- self.assertFalse(
- prime_check(-19),
- "Negative numbers are excluded by definition of prime numbers.",
- )
- self.assertFalse(
- prime_check(0),
- "Zero doesn't have any positive factors, primes must have exactly two.",
+ with pytest.raises(ValueError):
+ is_prime(-19)
+ assert not is_prime(0), (
+ "Zero doesn't have any positive factors, primes must have exactly two."
)
- self.assertFalse(
- prime_check(1),
- "One only has 1 positive factor, primes must have exactly two.",
+ assert not is_prime(1), (
+ "One only has 1 positive factor, primes must have exactly two."
)
- self.assertFalse(prime_check(2 * 2))
- self.assertFalse(prime_check(2 * 3))
- self.assertFalse(prime_check(3 * 3))
- self.assertFalse(prime_check(3 * 5))
- self.assertFalse(prime_check(3 * 5 * 7))
+ assert not is_prime(2 * 2)
+ assert not is_prime(2 * 3)
+ assert not is_prime(3 * 3)
+ assert not is_prime(3 * 5)
+ assert not is_prime(3 * 5 * 7)
if __name__ == "__main__":
diff --git a/maths/prime_factors.py b/maths/prime_factors.py
index e520ae3a6d04..47abcf10e618 100644
--- a/maths/prime_factors.py
+++ b/maths/prime_factors.py
@@ -1,6 +1,7 @@
"""
python/black : True
"""
+
from __future__ import annotations
diff --git a/maths/prime_numbers.py b/maths/prime_numbers.py
index 38bebddeee41..5ad12baf3dc3 100644
--- a/maths/prime_numbers.py
+++ b/maths/prime_numbers.py
@@ -1,8 +1,8 @@
import math
-from typing import Generator
+from collections.abc import Generator
-def slow_primes(max: int) -> Generator[int, None, None]:
+def slow_primes(max_n: int) -> Generator[int]:
"""
Return a list of all primes numbers up to max.
>>> list(slow_primes(0))
@@ -17,10 +17,10 @@ def slow_primes(max: int) -> Generator[int, None, None]:
[2, 3, 5, 7, 11]
>>> list(slow_primes(33))
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
- >>> list(slow_primes(10000))[-1]
- 9973
+ >>> list(slow_primes(1000))[-1]
+ 997
"""
- numbers: Generator = (i for i in range(1, (max + 1)))
+ numbers: Generator = (i for i in range(1, (max_n + 1)))
for i in (n for n in numbers if n > 1):
for j in range(2, i):
if (i % j) == 0:
@@ -29,7 +29,7 @@ def slow_primes(max: int) -> Generator[int, None, None]:
yield i
-def primes(max: int) -> Generator[int, None, None]:
+def primes(max_n: int) -> Generator[int]:
"""
Return a list of all primes numbers up to max.
>>> list(primes(0))
@@ -44,10 +44,10 @@ def primes(max: int) -> Generator[int, None, None]:
[2, 3, 5, 7, 11]
>>> list(primes(33))
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
- >>> list(primes(10000))[-1]
- 9973
+ >>> list(primes(1000))[-1]
+ 997
"""
- numbers: Generator = (i for i in range(1, (max + 1)))
+ numbers: Generator = (i for i in range(1, (max_n + 1)))
for i in (n for n in numbers if n > 1):
# only need to check for factors up to sqrt(i)
bound = int(math.sqrt(i)) + 1
@@ -58,13 +58,52 @@ def primes(max: int) -> Generator[int, None, None]:
yield i
+def fast_primes(max_n: int) -> Generator[int]:
+ """
+ Return a list of all primes numbers up to max.
+ >>> list(fast_primes(0))
+ []
+ >>> list(fast_primes(-1))
+ []
+ >>> list(fast_primes(-10))
+ []
+ >>> list(fast_primes(25))
+ [2, 3, 5, 7, 11, 13, 17, 19, 23]
+ >>> list(fast_primes(11))
+ [2, 3, 5, 7, 11]
+ >>> list(fast_primes(33))
+ [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
+ >>> list(fast_primes(1000))[-1]
+ 997
+ """
+ numbers: Generator = (i for i in range(1, (max_n + 1), 2))
+ # It's useless to test even numbers as they will not be prime
+ if max_n > 2:
+ yield 2 # Because 2 will not be tested, it's necessary to yield it now
+ for i in (n for n in numbers if n > 1):
+ bound = int(math.sqrt(i)) + 1
+ for j in range(3, bound, 2):
+ # As we removed the even numbers, we don't need them now
+ if (i % j) == 0:
+ break
+ else:
+ yield i
+
+
+def benchmark():
+ """
+ Let's benchmark our functions side-by-side...
+ """
+ from timeit import timeit
+
+ setup = "from __main__ import slow_primes, primes, fast_primes"
+ print(timeit("slow_primes(1_000_000_000_000)", setup=setup, number=1_000_000))
+ print(timeit("primes(1_000_000_000_000)", setup=setup, number=1_000_000))
+ print(timeit("fast_primes(1_000_000_000_000)", setup=setup, number=1_000_000))
+
+
if __name__ == "__main__":
number = int(input("Calculate primes up to:\n>> ").strip())
for ret in primes(number):
print(ret)
-
- # Let's benchmark them side-by-side...
- from timeit import timeit
-
- print(timeit("slow_primes(1_000_000)", setup="from __main__ import slow_primes"))
- print(timeit("primes(1_000_000)", setup="from __main__ import primes"))
+ benchmark()
diff --git a/maths/prime_sieve_eratosthenes.py b/maths/prime_sieve_eratosthenes.py
index 8d60e48c2140..32eef9165bba 100644
--- a/maths/prime_sieve_eratosthenes.py
+++ b/maths/prime_sieve_eratosthenes.py
@@ -1,12 +1,10 @@
-# flake8: noqa
-
"""
Sieve of Eratosthenes
-Input : n =10
+Input: n = 10
Output: 2 3 5 7
-Input : n = 20
+Input: n = 20
Output: 2 3 5 7 11 13 17 19
you can read in detail about this at
@@ -14,34 +12,43 @@
"""
-def prime_sieve_eratosthenes(num):
+def prime_sieve_eratosthenes(num: int) -> list[int]:
"""
- print the prime numbers up to n
+ Print the prime numbers up to n
>>> prime_sieve_eratosthenes(10)
- 2,3,5,7,
+ [2, 3, 5, 7]
>>> prime_sieve_eratosthenes(20)
- 2,3,5,7,11,13,17,19,
+ [2, 3, 5, 7, 11, 13, 17, 19]
+ >>> prime_sieve_eratosthenes(2)
+ [2]
+ >>> prime_sieve_eratosthenes(1)
+ []
+ >>> prime_sieve_eratosthenes(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input must be a positive integer
"""
- primes = [True for i in range(num + 1)]
- p = 2
+ if num <= 0:
+ raise ValueError("Input must be a positive integer")
+ primes = [True] * (num + 1)
+
+ p = 2
while p * p <= num:
if primes[p]:
for i in range(p * p, num + 1, p):
primes[i] = False
p += 1
- for prime in range(2, num + 1):
- if primes[prime]:
- print(prime, end=",")
+ return [prime for prime in range(2, num + 1) if primes[prime]]
if __name__ == "__main__":
import doctest
doctest.testmod()
- num = int(input())
- prime_sieve_eratosthenes(num)
+ user_num = int(input("Enter a positive integer: ").strip())
+ print(prime_sieve_eratosthenes(user_num))
diff --git a/maths/primelib.py b/maths/primelib.py
new file mode 100644
index 000000000000..9f031efc50a9
--- /dev/null
+++ b/maths/primelib.py
@@ -0,0 +1,841 @@
+"""
+Created on Thu Oct 5 16:44:23 2017
+
+@author: Christian Bender
+
+This Python library contains some useful functions to deal with
+prime numbers and whole numbers.
+
+Overview:
+
+is_prime(number)
+sieve_er(N)
+get_prime_numbers(N)
+prime_factorization(number)
+greatest_prime_factor(number)
+smallest_prime_factor(number)
+get_prime(n)
+get_primes_between(pNumber1, pNumber2)
+
+----
+
+is_even(number)
+is_odd(number)
+kg_v(number1, number2) // least common multiple
+get_divisors(number) // all divisors of 'number' inclusive 1, number
+is_perfect_number(number)
+
+NEW-FUNCTIONS
+
+simplify_fraction(numerator, denominator)
+factorial (n) // n!
+fib (n) // calculate the n-th fibonacci term.
+
+-----
+
+goldbach(number) // Goldbach's assumption
+
+"""
+
+from math import sqrt
+
+from maths.greatest_common_divisor import gcd_by_iterative
+
+
+def is_prime(number: int) -> bool:
+ """
+ input: positive integer 'number'
+ returns true if 'number' is prime otherwise false.
+
+ >>> is_prime(3)
+ True
+ >>> is_prime(10)
+ False
+ >>> is_prime(97)
+ True
+ >>> is_prime(9991)
+ False
+ >>> is_prime(-1)
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been an int and positive
+ >>> is_prime("test")
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been an int and positive
+ """
+
+ # precondition
+ assert isinstance(number, int) and (number >= 0), (
+ "'number' must been an int and positive"
+ )
+
+ status = True
+
+ # 0 and 1 are none primes.
+ if number <= 1:
+ status = False
+
+ for divisor in range(2, round(sqrt(number)) + 1):
+ # if 'number' divisible by 'divisor' then sets 'status'
+ # of false and break up the loop.
+ if number % divisor == 0:
+ status = False
+ break
+
+ # precondition
+ assert isinstance(status, bool), "'status' must been from type bool"
+
+ return status
+
+
+# ------------------------------------------
+
+
+def sieve_er(n):
+ """
+ input: positive integer 'N' > 2
+ returns a list of prime numbers from 2 up to N.
+
+ This function implements the algorithm called
+ sieve of erathostenes.
+
+ >>> sieve_er(8)
+ [2, 3, 5, 7]
+ >>> sieve_er(-1)
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'N' must been an int and > 2
+ >>> sieve_er("test")
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'N' must been an int and > 2
+ """
+
+ # precondition
+ assert isinstance(n, int) and (n > 2), "'N' must been an int and > 2"
+
+ # beginList: contains all natural numbers from 2 up to N
+ begin_list = list(range(2, n + 1))
+
+ ans = [] # this list will be returns.
+
+ # actual sieve of erathostenes
+ for i in range(len(begin_list)):
+ for j in range(i + 1, len(begin_list)):
+ if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0):
+ begin_list[j] = 0
+
+ # filters actual prime numbers.
+ ans = [x for x in begin_list if x != 0]
+
+ # precondition
+ assert isinstance(ans, list), "'ans' must been from type list"
+
+ return ans
+
+
+# --------------------------------
+
+
+def get_prime_numbers(n):
+ """
+ input: positive integer 'N' > 2
+ returns a list of prime numbers from 2 up to N (inclusive)
+ This function is more efficient as function 'sieveEr(...)'
+
+ >>> get_prime_numbers(8)
+ [2, 3, 5, 7]
+ >>> get_prime_numbers(-1)
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'N' must been an int and > 2
+ >>> get_prime_numbers("test")
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'N' must been an int and > 2
+ """
+
+ # precondition
+ assert isinstance(n, int) and (n > 2), "'N' must been an int and > 2"
+
+ ans = []
+
+ # iterates over all numbers between 2 up to N+1
+ # if a number is prime then appends to list 'ans'
+ for number in range(2, n + 1):
+ if is_prime(number):
+ ans.append(number)
+
+ # precondition
+ assert isinstance(ans, list), "'ans' must been from type list"
+
+ return ans
+
+
+# -----------------------------------------
+
+
+def prime_factorization(number):
+ """
+ input: positive integer 'number'
+ returns a list of the prime number factors of 'number'
+
+ >>> prime_factorization(0)
+ [0]
+ >>> prime_factorization(8)
+ [2, 2, 2]
+ >>> prime_factorization(287)
+ [7, 41]
+ >>> prime_factorization(-1)
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been an int and >= 0
+ >>> prime_factorization("test")
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been an int and >= 0
+ """
+
+ # precondition
+ assert isinstance(number, int) and number >= 0, "'number' must been an int and >= 0"
+
+ ans = [] # this list will be returns of the function.
+
+ # potential prime number factors.
+
+ factor = 2
+
+ quotient = number
+
+ if number in {0, 1}:
+ ans.append(number)
+
+ # if 'number' not prime then builds the prime factorization of 'number'
+ elif not is_prime(number):
+ while quotient != 1:
+ if is_prime(factor) and (quotient % factor == 0):
+ ans.append(factor)
+ quotient /= factor
+ else:
+ factor += 1
+
+ else:
+ ans.append(number)
+
+ # precondition
+ assert isinstance(ans, list), "'ans' must been from type list"
+
+ return ans
+
+
+# -----------------------------------------
+
+
+def greatest_prime_factor(number):
+ """
+ input: positive integer 'number' >= 0
+ returns the greatest prime number factor of 'number'
+
+ >>> greatest_prime_factor(0)
+ 0
+ >>> greatest_prime_factor(8)
+ 2
+ >>> greatest_prime_factor(287)
+ 41
+ >>> greatest_prime_factor(-1)
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been an int and >= 0
+ >>> greatest_prime_factor("test")
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been an int and >= 0
+ """
+
+ # precondition
+ assert isinstance(number, int) and (number >= 0), (
+ "'number' must been an int and >= 0"
+ )
+
+ ans = 0
+
+ # prime factorization of 'number'
+ prime_factors = prime_factorization(number)
+
+ ans = max(prime_factors)
+
+ # precondition
+ assert isinstance(ans, int), "'ans' must been from type int"
+
+ return ans
+
+
+# ----------------------------------------------
+
+
+def smallest_prime_factor(number):
+ """
+ input: integer 'number' >= 0
+ returns the smallest prime number factor of 'number'
+
+ >>> smallest_prime_factor(0)
+ 0
+ >>> smallest_prime_factor(8)
+ 2
+ >>> smallest_prime_factor(287)
+ 7
+ >>> smallest_prime_factor(-1)
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been an int and >= 0
+ >>> smallest_prime_factor("test")
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been an int and >= 0
+ """
+
+ # precondition
+ assert isinstance(number, int) and (number >= 0), (
+ "'number' must been an int and >= 0"
+ )
+
+ ans = 0
+
+ # prime factorization of 'number'
+ prime_factors = prime_factorization(number)
+
+ ans = min(prime_factors)
+
+ # precondition
+ assert isinstance(ans, int), "'ans' must been from type int"
+
+ return ans
+
+
+# ----------------------
+
+
+def is_even(number):
+ """
+ input: integer 'number'
+ returns true if 'number' is even, otherwise false.
+
+ >>> is_even(0)
+ True
+ >>> is_even(8)
+ True
+ >>> is_even(287)
+ False
+ >>> is_even(-1)
+ False
+ >>> is_even("test")
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been an int
+ """
+
+ # precondition
+ assert isinstance(number, int), "'number' must been an int"
+ assert isinstance(number % 2 == 0, bool), "compare must been from type bool"
+
+ return number % 2 == 0
+
+
+# ------------------------
+
+
+def is_odd(number):
+ """
+ input: integer 'number'
+ returns true if 'number' is odd, otherwise false.
+
+ >>> is_odd(0)
+ False
+ >>> is_odd(8)
+ False
+ >>> is_odd(287)
+ True
+ >>> is_odd(-1)
+ True
+ >>> is_odd("test")
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been an int
+ """
+
+ # precondition
+ assert isinstance(number, int), "'number' must been an int"
+ assert isinstance(number % 2 != 0, bool), "compare must been from type bool"
+
+ return number % 2 != 0
+
+
+# ------------------------
+
+
+def goldbach(number):
+ """
+ Goldbach's assumption
+ input: a even positive integer 'number' > 2
+ returns a list of two prime numbers whose sum is equal to 'number'
+
+ >>> goldbach(8)
+ [3, 5]
+ >>> goldbach(824)
+ [3, 821]
+ >>> goldbach(0)
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been an int, even and > 2
+ >>> goldbach(-1)
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been an int, even and > 2
+ >>> goldbach("test")
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been an int, even and > 2
+ """
+
+ # precondition
+ assert isinstance(number, int) and (number > 2) and is_even(number), (
+ "'number' must been an int, even and > 2"
+ )
+
+ ans = [] # this list will returned
+
+ # creates a list of prime numbers between 2 up to 'number'
+ prime_numbers = get_prime_numbers(number)
+ len_pn = len(prime_numbers)
+
+ # run variable for while-loops.
+ i = 0
+ j = None
+
+ # exit variable. for break up the loops
+ loop = True
+
+ while i < len_pn and loop:
+ j = i + 1
+
+ while j < len_pn and loop:
+ if prime_numbers[i] + prime_numbers[j] == number:
+ loop = False
+ ans.append(prime_numbers[i])
+ ans.append(prime_numbers[j])
+
+ j += 1
+
+ i += 1
+
+ # precondition
+ assert (
+ isinstance(ans, list)
+ and (len(ans) == 2)
+ and (ans[0] + ans[1] == number)
+ and is_prime(ans[0])
+ and is_prime(ans[1])
+ ), "'ans' must contains two primes. And sum of elements must been eq 'number'"
+
+ return ans
+
+
+# ----------------------------------------------
+
+
+def kg_v(number1, number2):
+ """
+ Least common multiple
+ input: two positive integer 'number1' and 'number2'
+ returns the least common multiple of 'number1' and 'number2'
+
+ >>> kg_v(8,10)
+ 40
+ >>> kg_v(824,67)
+ 55208
+ >>> kg_v(1, 10)
+ 10
+ >>> kg_v(0)
+ Traceback (most recent call last):
+ ...
+ TypeError: kg_v() missing 1 required positional argument: 'number2'
+ >>> kg_v(10,-1)
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number1' and 'number2' must been positive integer.
+ >>> kg_v("test","test2")
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number1' and 'number2' must been positive integer.
+ """
+
+ # precondition
+ assert (
+ isinstance(number1, int)
+ and isinstance(number2, int)
+ and (number1 >= 1)
+ and (number2 >= 1)
+ ), "'number1' and 'number2' must been positive integer."
+
+ ans = 1 # actual answer that will be return.
+
+ # for kgV (x,1)
+ if number1 > 1 and number2 > 1:
+ # builds the prime factorization of 'number1' and 'number2'
+ prime_fac_1 = prime_factorization(number1)
+ prime_fac_2 = prime_factorization(number2)
+
+ elif number1 == 1 or number2 == 1:
+ prime_fac_1 = []
+ prime_fac_2 = []
+ ans = max(number1, number2)
+
+ count1 = 0
+ count2 = 0
+
+ done = [] # captured numbers int both 'primeFac1' and 'primeFac2'
+
+ # iterates through primeFac1
+ for n in prime_fac_1:
+ if n not in done:
+ if n in prime_fac_2:
+ count1 = prime_fac_1.count(n)
+ count2 = prime_fac_2.count(n)
+
+ for _ in range(max(count1, count2)):
+ ans *= n
+
+ else:
+ count1 = prime_fac_1.count(n)
+
+ for _ in range(count1):
+ ans *= n
+
+ done.append(n)
+
+ # iterates through primeFac2
+ for n in prime_fac_2:
+ if n not in done:
+ count2 = prime_fac_2.count(n)
+
+ for _ in range(count2):
+ ans *= n
+
+ done.append(n)
+
+ # precondition
+ assert isinstance(ans, int) and (ans >= 0), (
+ "'ans' must been from type int and positive"
+ )
+
+ return ans
+
+
+# ----------------------------------
+
+
+def get_prime(n):
+ """
+ Gets the n-th prime number.
+ input: positive integer 'n' >= 0
+ returns the n-th prime number, beginning at index 0
+
+ >>> get_prime(0)
+ 2
+ >>> get_prime(8)
+ 23
+ >>> get_prime(824)
+ 6337
+ >>> get_prime(-1)
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been a positive int
+ >>> get_prime("test")
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been a positive int
+ """
+
+ # precondition
+ assert isinstance(n, int) and (n >= 0), "'number' must been a positive int"
+
+ index = 0
+ ans = 2 # this variable holds the answer
+
+ while index < n:
+ index += 1
+
+ ans += 1 # counts to the next number
+
+ # if ans not prime then
+ # runs to the next prime number.
+ while not is_prime(ans):
+ ans += 1
+
+ # precondition
+ assert isinstance(ans, int) and is_prime(ans), (
+ "'ans' must been a prime number and from type int"
+ )
+
+ return ans
+
+
+# ---------------------------------------------------
+
+
+def get_primes_between(p_number_1, p_number_2):
+ """
+ input: prime numbers 'pNumber1' and 'pNumber2'
+ pNumber1 < pNumber2
+ returns a list of all prime numbers between 'pNumber1' (exclusive)
+ and 'pNumber2' (exclusive)
+
+ >>> get_primes_between(3, 67)
+ [5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61]
+ >>> get_primes_between(0)
+ Traceback (most recent call last):
+ ...
+ TypeError: get_primes_between() missing 1 required positional argument: 'p_number_2'
+ >>> get_primes_between(0, 1)
+ Traceback (most recent call last):
+ ...
+ AssertionError: The arguments must been prime numbers and 'pNumber1' < 'pNumber2'
+ >>> get_primes_between(-1, 3)
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been an int and positive
+ >>> get_primes_between("test","test")
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been an int and positive
+ """
+
+ # precondition
+ assert (
+ is_prime(p_number_1) and is_prime(p_number_2) and (p_number_1 < p_number_2)
+ ), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"
+
+ number = p_number_1 + 1 # jump to the next number
+
+ ans = [] # this list will be returns.
+
+ # if number is not prime then
+ # fetch the next prime number.
+ while not is_prime(number):
+ number += 1
+
+ while number < p_number_2:
+ ans.append(number)
+
+ number += 1
+
+ # fetch the next prime number.
+ while not is_prime(number):
+ number += 1
+
+ # precondition
+ assert (
+ isinstance(ans, list)
+ and ans[0] != p_number_1
+ and ans[len(ans) - 1] != p_number_2
+ ), "'ans' must been a list without the arguments"
+
+ # 'ans' contains not 'pNumber1' and 'pNumber2' !
+ return ans
+
+
+# ----------------------------------------------------
+
+
+def get_divisors(n):
+ """
+ input: positive integer 'n' >= 1
+ returns all divisors of n (inclusive 1 and 'n')
+
+ >>> get_divisors(8)
+ [1, 2, 4, 8]
+ >>> get_divisors(824)
+ [1, 2, 4, 8, 103, 206, 412, 824]
+ >>> get_divisors(-1)
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'n' must been int and >= 1
+ >>> get_divisors("test")
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'n' must been int and >= 1
+ """
+
+ # precondition
+ assert isinstance(n, int) and (n >= 1), "'n' must been int and >= 1"
+
+ ans = [] # will be returned.
+
+ for divisor in range(1, n + 1):
+ if n % divisor == 0:
+ ans.append(divisor)
+
+ # precondition
+ assert ans[0] == 1 and ans[len(ans) - 1] == n, "Error in function getDivisiors(...)"
+
+ return ans
+
+
+# ----------------------------------------------------
+
+
+def is_perfect_number(number):
+ """
+ input: positive integer 'number' > 1
+ returns true if 'number' is a perfect number otherwise false.
+
+ >>> is_perfect_number(28)
+ True
+ >>> is_perfect_number(824)
+ False
+ >>> is_perfect_number(-1)
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been an int and >= 1
+ >>> is_perfect_number("test")
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'number' must been an int and >= 1
+ """
+
+ # precondition
+ assert isinstance(number, int) and (number > 1), (
+ "'number' must been an int and >= 1"
+ )
+
+ divisors = get_divisors(number)
+
+ # precondition
+ assert (
+ isinstance(divisors, list)
+ and (divisors[0] == 1)
+ and (divisors[len(divisors) - 1] == number)
+ ), "Error in help-function getDivisiors(...)"
+
+ # summed all divisors up to 'number' (exclusive), hence [:-1]
+ return sum(divisors[:-1]) == number
+
+
+# ------------------------------------------------------------
+
+
+def simplify_fraction(numerator, denominator):
+ """
+ input: two integer 'numerator' and 'denominator'
+ assumes: 'denominator' != 0
+ returns: a tuple with simplify numerator and denominator.
+
+ >>> simplify_fraction(10, 20)
+ (1, 2)
+ >>> simplify_fraction(10, -1)
+ (10, -1)
+ >>> simplify_fraction("test","test")
+ Traceback (most recent call last):
+ ...
+ AssertionError: The arguments must been from type int and 'denominator' != 0
+ """
+
+ # precondition
+ assert (
+ isinstance(numerator, int)
+ and isinstance(denominator, int)
+ and (denominator != 0)
+ ), "The arguments must been from type int and 'denominator' != 0"
+
+ # build the greatest common divisor of numerator and denominator.
+ gcd_of_fraction = gcd_by_iterative(abs(numerator), abs(denominator))
+
+ # precondition
+ assert (
+ isinstance(gcd_of_fraction, int)
+ and (numerator % gcd_of_fraction == 0)
+ and (denominator % gcd_of_fraction == 0)
+ ), "Error in function gcd_by_iterative(...,...)"
+
+ return (numerator // gcd_of_fraction, denominator // gcd_of_fraction)
+
+
+# -----------------------------------------------------------------
+
+
+def factorial(n):
+ """
+ input: positive integer 'n'
+ returns the factorial of 'n' (n!)
+
+ >>> factorial(0)
+ 1
+ >>> factorial(20)
+ 2432902008176640000
+ >>> factorial(-1)
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'n' must been a int and >= 0
+ >>> factorial("test")
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'n' must been a int and >= 0
+ """
+
+ # precondition
+ assert isinstance(n, int) and (n >= 0), "'n' must been a int and >= 0"
+
+ ans = 1 # this will be return.
+
+ for factor in range(1, n + 1):
+ ans *= factor
+
+ return ans
+
+
+# -------------------------------------------------------------------
+
+
+def fib(n: int) -> int:
+ """
+ input: positive integer 'n'
+ returns the n-th fibonacci term , indexing by 0
+
+ >>> fib(0)
+ 1
+ >>> fib(5)
+ 8
+ >>> fib(20)
+ 10946
+ >>> fib(99)
+ 354224848179261915075
+ >>> fib(-1)
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'n' must been an int and >= 0
+ >>> fib("test")
+ Traceback (most recent call last):
+ ...
+ AssertionError: 'n' must been an int and >= 0
+ """
+
+ # precondition
+ assert isinstance(n, int) and (n >= 0), "'n' must been an int and >= 0"
+
+ tmp = 0
+ fib1 = 1
+ ans = 1 # this will be return
+
+ for _ in range(n - 1):
+ tmp = ans
+ ans += fib1
+ fib1 = tmp
+
+ return ans
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/print_multiplication_table.py b/maths/print_multiplication_table.py
new file mode 100644
index 000000000000..dbe4a4be0ee8
--- /dev/null
+++ b/maths/print_multiplication_table.py
@@ -0,0 +1,26 @@
+def multiplication_table(number: int, number_of_terms: int) -> str:
+ """
+ Prints the multiplication table of a given number till the given number of terms
+
+ >>> print(multiplication_table(3, 5))
+ 3 * 1 = 3
+ 3 * 2 = 6
+ 3 * 3 = 9
+ 3 * 4 = 12
+ 3 * 5 = 15
+
+ >>> print(multiplication_table(-4, 6))
+ -4 * 1 = -4
+ -4 * 2 = -8
+ -4 * 3 = -12
+ -4 * 4 = -16
+ -4 * 5 = -20
+ -4 * 6 = -24
+ """
+ return "\n".join(
+ f"{number} * {i} = {number * i}" for i in range(1, number_of_terms + 1)
+ )
+
+
+if __name__ == "__main__":
+ print(multiplication_table(number=5, number_of_terms=10))
diff --git a/maths/pythagoras.py b/maths/pythagoras.py
index 69a17731a0fd..7770e981d44d 100644
--- a/maths/pythagoras.py
+++ b/maths/pythagoras.py
@@ -14,17 +14,13 @@ def __repr__(self) -> str:
def distance(a: Point, b: Point) -> float:
- return math.sqrt(abs((b.x - a.x) ** 2 + (b.y - a.y) ** 2 + (b.z - a.z) ** 2))
-
-
-def test_distance() -> None:
"""
>>> point1 = Point(2, -1, 7)
>>> point2 = Point(1, -3, 5)
>>> print(f"Distance from {point1} to {point2} is {distance(point1, point2)}")
Distance from Point(2, -1, 7) to Point(1, -3, 5) is 3.0
"""
- pass
+ return math.sqrt(abs((b.x - a.x) ** 2 + (b.y - a.y) ** 2 + (b.z - a.z) ** 2))
if __name__ == "__main__":
diff --git a/maths/qr_decomposition.py b/maths/qr_decomposition.py
index 5e15fede4f2a..670b49206aa7 100644
--- a/maths/qr_decomposition.py
+++ b/maths/qr_decomposition.py
@@ -1,7 +1,7 @@
import numpy as np
-def qr_householder(A):
+def qr_householder(a: np.ndarray):
"""Return a QR-decomposition of the matrix A using Householder reflection.
The QR-decomposition decomposes the matrix A of shape (m, n) into an
@@ -37,14 +37,14 @@ def qr_householder(A):
>>> np.allclose(np.triu(R), R)
True
"""
- m, n = A.shape
+ m, n = a.shape
t = min(m, n)
- Q = np.eye(m)
- R = A.copy()
+ q = np.eye(m)
+ r = a.copy()
for k in range(t - 1):
# select a column of modified matrix A':
- x = R[k:, [k]]
+ x = r[k:, [k]]
# construct first basis vector
e1 = np.zeros_like(x)
e1[0] = 1.0
@@ -55,14 +55,14 @@ def qr_householder(A):
v /= np.linalg.norm(v)
# construct the Householder matrix
- Q_k = np.eye(m - k) - 2.0 * v @ v.T
+ q_k = np.eye(m - k) - 2.0 * v @ v.T
# pad with ones and zeros as necessary
- Q_k = np.block([[np.eye(k), np.zeros((k, m - k))], [np.zeros((m - k, k)), Q_k]])
+ q_k = np.block([[np.eye(k), np.zeros((k, m - k))], [np.zeros((m - k, k)), q_k]])
- Q = Q @ Q_k.T
- R = Q_k @ R
+ q = q @ q_k.T
+ r = q_k @ r
- return Q, R
+ return q, r
if __name__ == "__main__":
diff --git a/maths/quadratic_equations_complex_numbers.py b/maths/quadratic_equations_complex_numbers.py
index 01a411bc560d..1035171e4ec3 100644
--- a/maths/quadratic_equations_complex_numbers.py
+++ b/maths/quadratic_equations_complex_numbers.py
@@ -30,8 +30,8 @@ def quadratic_roots(a: int, b: int, c: int) -> tuple[complex, complex]:
def main():
- solutions = quadratic_roots(a=5, b=6, c=1)
- print("The solutions are: {} and {}".format(*solutions))
+ solution1, solution2 = quadratic_roots(a=5, b=6, c=1)
+ print(f"The solutions are: {solution1} and {solution2}")
if __name__ == "__main__":
diff --git a/maths/radians.py b/maths/radians.py
index 465467a3ba08..b8ac61cb135c 100644
--- a/maths/radians.py
+++ b/maths/radians.py
@@ -3,7 +3,7 @@
def radians(degree: float) -> float:
"""
- Coverts the given angle from degrees to radians
+ Converts the given angle from degrees to radians
https://en.wikipedia.org/wiki/Radian
>>> radians(180)
@@ -16,7 +16,7 @@ def radians(degree: float) -> float:
1.9167205845401725
>>> from math import radians as math_radians
- >>> all(abs(radians(i)-math_radians(i)) <= 0.00000001 for i in range(-2, 361))
+ >>> all(abs(radians(i) - math_radians(i)) <= 1e-8 for i in range(-2, 361))
True
"""
diff --git a/maths/radix2_fft.py b/maths/radix2_fft.py
index de87071e5440..d41dc82d5588 100644
--- a/maths/radix2_fft.py
+++ b/maths/radix2_fft.py
@@ -39,7 +39,7 @@ class FFT:
>>> x = FFT(A, B)
Print product
- >>> print(x.product) # 2x + 3x^2 + 8x^3 + 4x^4 + 6x^5
+ >>> x.product # 2x + 3x^2 + 8x^3 + 4x^4 + 6x^5
[(-0+0j), (2+0j), (3+0j), (8+0j), (6+0j), (8+0j)]
__str__ test
@@ -49,10 +49,10 @@ class FFT:
A*B = 0*x^(-0+0j) + 1*x^(2+0j) + 2*x^(3+0j) + 3*x^(8+0j) + 4*x^(6+0j) + 5*x^(8+0j)
"""
- def __init__(self, polyA=[0], polyB=[0]):
+ def __init__(self, poly_a=None, poly_b=None):
# Input as list
- self.polyA = list(polyA)[:]
- self.polyB = list(polyB)[:]
+ self.polyA = list(poly_a or [0])[:]
+ self.polyB = list(poly_b or [0])[:]
# Remove leading zero coefficients
while self.polyA[-1] == 0:
@@ -64,44 +64,40 @@ def __init__(self, polyA=[0], polyB=[0]):
self.len_B = len(self.polyB)
# Add 0 to make lengths equal a power of 2
- self.C_max_length = int(
+ self.c_max_length = int(
2 ** np.ceil(np.log2(len(self.polyA) + len(self.polyB) - 1))
)
- while len(self.polyA) < self.C_max_length:
+ while len(self.polyA) < self.c_max_length:
self.polyA.append(0)
- while len(self.polyB) < self.C_max_length:
+ while len(self.polyB) < self.c_max_length:
self.polyB.append(0)
# A complex root used for the fourier transform
- self.root = complex(mpmath.root(x=1, n=self.C_max_length, k=1))
+ self.root = complex(mpmath.root(x=1, n=self.c_max_length, k=1))
# The product
self.product = self.__multiply()
# Discrete fourier transform of A and B
- def __DFT(self, which):
- if which == "A":
- dft = [[x] for x in self.polyA]
- else:
- dft = [[x] for x in self.polyB]
+ def __dft(self, which):
+ dft = [[x] for x in self.polyA] if which == "A" else [[x] for x in self.polyB]
# Corner case
if len(dft) <= 1:
return dft[0]
- #
- next_ncol = self.C_max_length // 2
+ next_ncol = self.c_max_length // 2
while next_ncol > 0:
new_dft = [[] for i in range(next_ncol)]
- root = self.root ** next_ncol
+ root = self.root**next_ncol
# First half of next step
current_root = 1
- for j in range(self.C_max_length // (next_ncol * 2)):
+ for j in range(self.c_max_length // (next_ncol * 2)):
for i in range(next_ncol):
new_dft[i].append(dft[i][j] + current_root * dft[i + next_ncol][j])
current_root *= root
# Second half of next step
current_root = 1
- for j in range(self.C_max_length // (next_ncol * 2)):
+ for j in range(self.c_max_length // (next_ncol * 2)):
for i in range(next_ncol):
new_dft[i].append(dft[i][j] - current_root * dft[i + next_ncol][j])
current_root *= root
@@ -112,65 +108,65 @@ def __DFT(self, which):
# multiply the DFTs of A and B and find A*B
def __multiply(self):
- dftA = self.__DFT("A")
- dftB = self.__DFT("B")
- inverseC = [[dftA[i] * dftB[i] for i in range(self.C_max_length)]]
- del dftA
- del dftB
+ dft_a = self.__dft("A")
+ dft_b = self.__dft("B")
+ inverce_c = [[dft_a[i] * dft_b[i] for i in range(self.c_max_length)]]
+ del dft_a
+ del dft_b
# Corner Case
- if len(inverseC[0]) <= 1:
- return inverseC[0]
+ if len(inverce_c[0]) <= 1:
+ return inverce_c[0]
# Inverse DFT
next_ncol = 2
- while next_ncol <= self.C_max_length:
- new_inverseC = [[] for i in range(next_ncol)]
+ while next_ncol <= self.c_max_length:
+ new_inverse_c = [[] for i in range(next_ncol)]
root = self.root ** (next_ncol // 2)
current_root = 1
# First half of next step
- for j in range(self.C_max_length // next_ncol):
+ for j in range(self.c_max_length // next_ncol):
for i in range(next_ncol // 2):
# Even positions
- new_inverseC[i].append(
+ new_inverse_c[i].append(
(
- inverseC[i][j]
- + inverseC[i][j + self.C_max_length // next_ncol]
+ inverce_c[i][j]
+ + inverce_c[i][j + self.c_max_length // next_ncol]
)
/ 2
)
# Odd positions
- new_inverseC[i + next_ncol // 2].append(
+ new_inverse_c[i + next_ncol // 2].append(
(
- inverseC[i][j]
- - inverseC[i][j + self.C_max_length // next_ncol]
+ inverce_c[i][j]
+ - inverce_c[i][j + self.c_max_length // next_ncol]
)
/ (2 * current_root)
)
current_root *= root
# Update
- inverseC = new_inverseC
+ inverce_c = new_inverse_c
next_ncol *= 2
# Unpack
- inverseC = [round(x[0].real, 8) + round(x[0].imag, 8) * 1j for x in inverseC]
+ inverce_c = [round(x[0].real, 8) + round(x[0].imag, 8) * 1j for x in inverce_c]
# Remove leading 0's
- while inverseC[-1] == 0:
- inverseC.pop()
- return inverseC
+ while inverce_c[-1] == 0:
+ inverce_c.pop()
+ return inverce_c
# Overwrite __str__ for print(); Shows A, B and A*B
def __str__(self):
- A = "A = " + " + ".join(
+ a = "A = " + " + ".join(
f"{coef}*x^{i}" for coef, i in enumerate(self.polyA[: self.len_A])
)
- B = "B = " + " + ".join(
+ b = "B = " + " + ".join(
f"{coef}*x^{i}" for coef, i in enumerate(self.polyB[: self.len_B])
)
- C = "A*B = " + " + ".join(
+ c = "A*B = " + " + ".join(
f"{coef}*x^{i}" for coef, i in enumerate(self.product)
)
- return "\n".join((A, B, C))
+ return f"{a}\n{b}\n{c}"
# Unit tests
diff --git a/maths/remove_digit.py b/maths/remove_digit.py
new file mode 100644
index 000000000000..db14ac902a6f
--- /dev/null
+++ b/maths/remove_digit.py
@@ -0,0 +1,37 @@
+def remove_digit(num: int) -> int:
+ """
+
+ returns the biggest possible result
+ that can be achieved by removing
+ one digit from the given number
+
+ >>> remove_digit(152)
+ 52
+ >>> remove_digit(6385)
+ 685
+ >>> remove_digit(-11)
+ 1
+ >>> remove_digit(2222222)
+ 222222
+ >>> remove_digit("2222222")
+ Traceback (most recent call last):
+ TypeError: only integers accepted as input
+ >>> remove_digit("string input")
+ Traceback (most recent call last):
+ TypeError: only integers accepted as input
+ """
+
+ if not isinstance(num, int):
+ raise TypeError("only integers accepted as input")
+ else:
+ num_str = str(abs(num))
+ num_transpositions = [list(num_str) for char in range(len(num_str))]
+ for index in range(len(num_str)):
+ num_transpositions[index].pop(index)
+ return max(
+ int("".join(list(transposition))) for transposition in num_transpositions
+ )
+
+
+if __name__ == "__main__":
+ __import__("doctest").testmod()
diff --git a/maths/segmented_sieve.py b/maths/segmented_sieve.py
index c1cc497ad33e..125390edc588 100644
--- a/maths/segmented_sieve.py
+++ b/maths/segmented_sieve.py
@@ -3,8 +3,37 @@
import math
-def sieve(n):
- """Segmented Sieve."""
+def sieve(n: int) -> list[int]:
+ """
+ Segmented Sieve.
+
+ Examples:
+ >>> sieve(8)
+ [2, 3, 5, 7]
+
+ >>> sieve(27)
+ [2, 3, 5, 7, 11, 13, 17, 19, 23]
+
+ >>> sieve(0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Number 0 must instead be a positive integer
+
+ >>> sieve(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: Number -1 must instead be a positive integer
+
+ >>> sieve(22.2)
+ Traceback (most recent call last):
+ ...
+ ValueError: Number 22.2 must instead be a positive integer
+ """
+
+ if n <= 0 or isinstance(n, float):
+ msg = f"Number {n} must instead be a positive integer"
+ raise ValueError(msg)
+
in_prime = []
start = 2
end = int(math.sqrt(n)) # Size of every segment
@@ -15,20 +44,16 @@ def sieve(n):
if temp[start] is True:
in_prime.append(start)
for i in range(start * start, end + 1, start):
- if temp[i] is True:
- temp[i] = False
+ temp[i] = False
start += 1
prime += in_prime
low = end + 1
- high = low + end - 1
- if high > n:
- high = n
+ high = min(2 * end, n)
while low <= n:
temp = [True] * (high - low + 1)
for each in in_prime:
-
t = math.floor(low / each) * each
if t < low:
t += each
@@ -41,11 +66,14 @@ def sieve(n):
prime.append(j + low)
low = high + 1
- high = low + end - 1
- if high > n:
- high = n
+ high = min(high + end, n)
return prime
-print(sieve(10 ** 6))
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+
+ print(f"{sieve(10**6) = }")
diff --git a/maths/series/arithmetic.py b/maths/series/arithmetic.py
new file mode 100644
index 000000000000..dc28c5c7bc5f
--- /dev/null
+++ b/maths/series/arithmetic.py
@@ -0,0 +1,77 @@
+"""
+Arithmetic mean
+Reference: https://en.wikipedia.org/wiki/Arithmetic_mean
+
+Arithmetic series
+Reference: https://en.wikipedia.org/wiki/Arithmetic_series
+(The URL above will redirect you to arithmetic progression)
+"""
+
+
+def is_arithmetic_series(series: list) -> bool:
+ """
+ checking whether the input series is arithmetic series or not
+ >>> is_arithmetic_series([2, 4, 6])
+ True
+ >>> is_arithmetic_series([3, 6, 12, 24])
+ False
+ >>> is_arithmetic_series([1, 2, 3])
+ True
+ >>> is_arithmetic_series(4)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input series is not valid, valid series - [2, 4, 6]
+ >>> is_arithmetic_series([])
+ Traceback (most recent call last):
+ ...
+ ValueError: Input list must be a non empty list
+ """
+ if not isinstance(series, list):
+ raise ValueError("Input series is not valid, valid series - [2, 4, 6]")
+ if len(series) == 0:
+ raise ValueError("Input list must be a non empty list")
+ if len(series) == 1:
+ return True
+ common_diff = series[1] - series[0]
+ for index in range(len(series) - 1):
+ if series[index + 1] - series[index] != common_diff:
+ return False
+ return True
+
+
+def arithmetic_mean(series: list) -> float:
+ """
+ return the arithmetic mean of series
+
+ >>> arithmetic_mean([2, 4, 6])
+ 4.0
+ >>> arithmetic_mean([3, 6, 9, 12])
+ 7.5
+ >>> arithmetic_mean(4)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input series is not valid, valid series - [2, 4, 6]
+ >>> arithmetic_mean([4, 8, 1])
+ 4.333333333333333
+ >>> arithmetic_mean([1, 2, 3])
+ 2.0
+ >>> arithmetic_mean([])
+ Traceback (most recent call last):
+ ...
+ ValueError: Input list must be a non empty list
+
+ """
+ if not isinstance(series, list):
+ raise ValueError("Input series is not valid, valid series - [2, 4, 6]")
+ if len(series) == 0:
+ raise ValueError("Input list must be a non empty list")
+ answer = 0
+ for val in series:
+ answer += val
+ return answer / len(series)
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/series/geometric.py b/maths/series/geometric.py
new file mode 100644
index 000000000000..7b6239b1585d
--- /dev/null
+++ b/maths/series/geometric.py
@@ -0,0 +1,83 @@
+"""
+Geometric Mean
+Reference : https://en.wikipedia.org/wiki/Geometric_mean
+
+Geometric series
+Reference: https://en.wikipedia.org/wiki/Geometric_series
+"""
+
+
+def is_geometric_series(series: list) -> bool:
+ """
+ checking whether the input series is geometric series or not
+ >>> is_geometric_series([2, 4, 8])
+ True
+ >>> is_geometric_series([3, 6, 12, 24])
+ True
+ >>> is_geometric_series([1, 2, 3])
+ False
+ >>> is_geometric_series([0, 0, 3])
+ False
+ >>> is_geometric_series([])
+ Traceback (most recent call last):
+ ...
+ ValueError: Input list must be a non empty list
+ >>> is_geometric_series(4)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input series is not valid, valid series - [2, 4, 8]
+ """
+ if not isinstance(series, list):
+ raise ValueError("Input series is not valid, valid series - [2, 4, 8]")
+ if len(series) == 0:
+ raise ValueError("Input list must be a non empty list")
+ if len(series) == 1:
+ return True
+ try:
+ common_ratio = series[1] / series[0]
+ for index in range(len(series) - 1):
+ if series[index + 1] / series[index] != common_ratio:
+ return False
+ except ZeroDivisionError:
+ return False
+ return True
+
+
+def geometric_mean(series: list) -> float:
+ """
+ return the geometric mean of series
+
+ >>> geometric_mean([2, 4, 8])
+ 3.9999999999999996
+ >>> geometric_mean([3, 6, 12, 24])
+ 8.48528137423857
+ >>> geometric_mean([4, 8, 16])
+ 7.999999999999999
+ >>> geometric_mean(4)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input series is not valid, valid series - [2, 4, 8]
+ >>> geometric_mean([1, 2, 3])
+ 1.8171205928321397
+ >>> geometric_mean([0, 2, 3])
+ 0.0
+ >>> geometric_mean([])
+ Traceback (most recent call last):
+ ...
+ ValueError: Input list must be a non empty list
+
+ """
+ if not isinstance(series, list):
+ raise ValueError("Input series is not valid, valid series - [2, 4, 8]")
+ if len(series) == 0:
+ raise ValueError("Input list must be a non empty list")
+ answer = 1
+ for value in series:
+ answer *= value
+ return pow(answer, 1 / len(series))
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/series/geometric_series.py b/maths/series/geometric_series.py
index d12382e6d8c4..55c42fd90e99 100644
--- a/maths/series/geometric_series.py
+++ b/maths/series/geometric_series.py
@@ -1,7 +1,6 @@
"""
This is a pure Python implementation of the Geometric Series algorithm
https://en.wikipedia.org/wiki/Geometric_series
-
Run the doctests with the following command:
python3 -m doctest -v geometric_series.py
or
@@ -10,9 +9,17 @@
python3 geometric_series.py
"""
+from __future__ import annotations
+
+
+def geometric_series(
+ nth_term: float,
+ start_term_a: float,
+ common_ratio_r: float,
+) -> list[float]:
+ """
+ Pure Python implementation of Geometric Series algorithm
-def geometric_series(nth_term: int, start_term_a: int, common_ratio_r: int) -> list:
- """Pure Python implementation of Geometric Series algorithm
:param nth_term: The last term (nth term of Geometric Series)
:param start_term_a : The first term of Geometric Series
:param common_ratio_r : The common ratio between all the terms
@@ -20,15 +27,15 @@ def geometric_series(nth_term: int, start_term_a: int, common_ratio_r: int) -> l
ration with first term with increase in power till last term (nth term)
Examples:
>>> geometric_series(4, 2, 2)
- [2, '4.0', '8.0', '16.0']
+ [2, 4.0, 8.0, 16.0]
>>> geometric_series(4.0, 2.0, 2.0)
- [2.0, '4.0', '8.0', '16.0']
+ [2.0, 4.0, 8.0, 16.0]
>>> geometric_series(4.1, 2.1, 2.1)
- [2.1, '4.41', '9.261000000000001', '19.448100000000004']
+ [2.1, 4.41, 9.261000000000001, 19.448100000000004]
>>> geometric_series(4, 2, -2)
- [2, '-4.0', '8.0', '-16.0']
+ [2, -4.0, 8.0, -16.0]
>>> geometric_series(4, -2, 2)
- [-2, '-4.0', '-8.0', '-16.0']
+ [-2, -4.0, -8.0, -16.0]
>>> geometric_series(-4, 2, 2)
[]
>>> geometric_series(0, 100, 500)
@@ -38,26 +45,30 @@ def geometric_series(nth_term: int, start_term_a: int, common_ratio_r: int) -> l
>>> geometric_series(0, 0, 0)
[]
"""
- if "" in (nth_term, start_term_a, common_ratio_r):
- return ""
- series = []
+ if not all((nth_term, start_term_a, common_ratio_r)):
+ return []
+ series: list[float] = []
power = 1
multiple = common_ratio_r
for _ in range(int(nth_term)):
- if series == []:
+ if not series:
series.append(start_term_a)
else:
power += 1
- series.append(str(float(start_term_a) * float(multiple)))
+ series.append(float(start_term_a * multiple))
multiple = pow(float(common_ratio_r), power)
return series
if __name__ == "__main__":
- nth_term = input("Enter the last number (n term) of the Geometric Series")
- start_term_a = input("Enter the starting term (a) of the Geometric Series")
- common_ratio_r = input(
- "Enter the common ratio between two terms (r) of the Geometric Series"
+ import doctest
+
+ doctest.testmod()
+
+ nth_term = float(input("Enter the last number (n term) of the Geometric Series"))
+ start_term_a = float(input("Enter the starting term (a) of the Geometric Series"))
+ common_ratio_r = float(
+ input("Enter the common ratio between two terms (r) of the Geometric Series")
)
print("Formula of Geometric Series => a + ar + ar^2 ... +ar^n")
print(geometric_series(nth_term, start_term_a, common_ratio_r))
diff --git a/maths/series/harmonic.py b/maths/series/harmonic.py
new file mode 100644
index 000000000000..35792d38af9b
--- /dev/null
+++ b/maths/series/harmonic.py
@@ -0,0 +1,92 @@
+"""
+Harmonic mean
+Reference: https://en.wikipedia.org/wiki/Harmonic_mean
+
+Harmonic series
+Reference: https://en.wikipedia.org/wiki/Harmonic_series(mathematics)
+"""
+
+
+def is_harmonic_series(series: list) -> bool:
+ """
+ checking whether the input series is arithmetic series or not
+ >>> is_harmonic_series([ 1, 2/3, 1/2, 2/5, 1/3])
+ True
+ >>> is_harmonic_series([ 1, 2/3, 2/5, 1/3])
+ False
+ >>> is_harmonic_series([1, 2, 3])
+ False
+ >>> is_harmonic_series([1/2, 1/3, 1/4])
+ True
+ >>> is_harmonic_series([2/5, 2/10, 2/15, 2/20, 2/25])
+ True
+ >>> is_harmonic_series(4)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input series is not valid, valid series - [1, 2/3, 2]
+ >>> is_harmonic_series([])
+ Traceback (most recent call last):
+ ...
+ ValueError: Input list must be a non empty list
+ >>> is_harmonic_series([0])
+ Traceback (most recent call last):
+ ...
+ ValueError: Input series cannot have 0 as an element
+ >>> is_harmonic_series([1,2,0,6])
+ Traceback (most recent call last):
+ ...
+ ValueError: Input series cannot have 0 as an element
+ """
+ if not isinstance(series, list):
+ raise ValueError("Input series is not valid, valid series - [1, 2/3, 2]")
+ if len(series) == 0:
+ raise ValueError("Input list must be a non empty list")
+ if len(series) == 1 and series[0] != 0:
+ return True
+ rec_series = []
+ series_len = len(series)
+ for i in range(series_len):
+ if series[i] == 0:
+ raise ValueError("Input series cannot have 0 as an element")
+ rec_series.append(1 / series[i])
+ common_diff = rec_series[1] - rec_series[0]
+ for index in range(2, series_len):
+ if rec_series[index] - rec_series[index - 1] != common_diff:
+ return False
+ return True
+
+
+def harmonic_mean(series: list) -> float:
+ """
+ return the harmonic mean of series
+
+ >>> harmonic_mean([1, 4, 4])
+ 2.0
+ >>> harmonic_mean([3, 6, 9, 12])
+ 5.759999999999999
+ >>> harmonic_mean(4)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input series is not valid, valid series - [2, 4, 6]
+ >>> harmonic_mean([1, 2, 3])
+ 1.6363636363636365
+ >>> harmonic_mean([])
+ Traceback (most recent call last):
+ ...
+ ValueError: Input list must be a non empty list
+
+ """
+ if not isinstance(series, list):
+ raise ValueError("Input series is not valid, valid series - [2, 4, 6]")
+ if len(series) == 0:
+ raise ValueError("Input list must be a non empty list")
+ answer = 0
+ for val in series:
+ answer += 1 / val
+ return len(series) / answer
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/series/harmonic_series.py b/maths/series/harmonic_series.py
index 91b5944583e4..d42d13d912f1 100644
--- a/maths/series/harmonic_series.py
+++ b/maths/series/harmonic_series.py
@@ -33,8 +33,8 @@ def harmonic_series(n_term: str) -> list:
['1']
"""
if n_term == "":
- return n_term
- series = []
+ return []
+ series: list = []
for temp in range(int(n_term)):
series.append(f"1/{temp + 1}" if series else "1")
return series
diff --git a/maths/series/hexagonal_numbers.py b/maths/series/hexagonal_numbers.py
new file mode 100644
index 000000000000..582b1989b7c6
--- /dev/null
+++ b/maths/series/hexagonal_numbers.py
@@ -0,0 +1,42 @@
+"""
+A hexagonal number sequence is a sequence of figurate numbers
+where the nth hexagonal number hₙ is the number of distinct dots
+in a pattern of dots consisting of the outlines of regular
+hexagons with sides up to n dots, when the hexagons are overlaid
+so that they share one vertex.
+
+ Calculates the hexagonal numbers sequence with a formula
+ hₙ = n(2n-1)
+ where:
+ hₙ --> is nth element of the sequence
+ n --> is the number of element in the sequence
+ reference-->"Hexagonal number" Wikipedia
+
+"""
+
+
+def hexagonal_numbers(length: int) -> list[int]:
+ """
+ :param len: max number of elements
+ :type len: int
+ :return: Hexagonal numbers as a list
+
+ Tests:
+ >>> hexagonal_numbers(10)
+ [0, 1, 6, 15, 28, 45, 66, 91, 120, 153]
+ >>> hexagonal_numbers(5)
+ [0, 1, 6, 15, 28]
+ >>> hexagonal_numbers(0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Length must be a positive integer.
+ """
+
+ if length <= 0 or not isinstance(length, int):
+ raise ValueError("Length must be a positive integer.")
+ return [n * (2 * n - 1) for n in range(length)]
+
+
+if __name__ == "__main__":
+ print(hexagonal_numbers(length=5))
+ print(hexagonal_numbers(length=10))
diff --git a/maths/series/p_series.py b/maths/series/p_series.py
index 04019aed5a85..93812f443857 100644
--- a/maths/series/p_series.py
+++ b/maths/series/p_series.py
@@ -1,48 +1,51 @@
"""
This is a pure Python implementation of the P-Series algorithm
https://en.wikipedia.org/wiki/Harmonic_series_(mathematics)#P-series
-
For doctests run following command:
python -m doctest -v p_series.py
or
python3 -m doctest -v p_series.py
-
For manual testing run:
python3 p_series.py
"""
+from __future__ import annotations
-def p_series(nth_term: int, power: int) -> list:
- """Pure Python implementation of P-Series algorithm
+def p_series(nth_term: float | str, power: float | str) -> list[str]:
+ """
+ Pure Python implementation of P-Series algorithm
:return: The P-Series starting from 1 to last (nth) term
-
Examples:
>>> p_series(5, 2)
- [1, '1/4', '1/9', '1/16', '1/25']
+ ['1', '1 / 4', '1 / 9', '1 / 16', '1 / 25']
>>> p_series(-5, 2)
[]
>>> p_series(5, -2)
- [1, '1/0.25', '1/0.1111111111111111', '1/0.0625', '1/0.04']
+ ['1', '1 / 0.25', '1 / 0.1111111111111111', '1 / 0.0625', '1 / 0.04']
>>> p_series("", 1000)
- ''
+ ['']
>>> p_series(0, 0)
[]
>>> p_series(1, 1)
- [1]
+ ['1']
"""
if nth_term == "":
- return nth_term
+ return [""]
nth_term = int(nth_term)
power = int(power)
- series = []
+ series: list[str] = []
for temp in range(int(nth_term)):
- series.append(f"1/{pow(temp + 1, int(power))}" if series else 1)
+ series.append(f"1 / {pow(temp + 1, int(power))}" if series else "1")
return series
if __name__ == "__main__":
- nth_term = input("Enter the last number (nth term) of the P-Series")
- power = input("Enter the power for P-Series")
+ import doctest
+
+ doctest.testmod()
+
+ nth_term = int(input("Enter the last number (nth term) of the P-Series"))
+ power = int(input("Enter the power for P-Series"))
print("Formula of P-Series => 1+1/2^p+1/3^p ..... 1/n^p")
print(p_series(nth_term, power))
diff --git a/maths/sieve_of_eratosthenes.py b/maths/sieve_of_eratosthenes.py
index faf6fc0f9a98..3923dc3e1612 100644
--- a/maths/sieve_of_eratosthenes.py
+++ b/maths/sieve_of_eratosthenes.py
@@ -8,54 +8,59 @@
Reference: https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
doctest provider: Bruno Simas Hadlich (https://github.com/brunohadlich)
-Also thanks Dmitry (https://github.com/LizardWizzard) for finding the problem
+Also thanks to Dmitry (https://github.com/LizardWizzard) for finding the problem
"""
+from __future__ import annotations
import math
-def sieve(n):
+def prime_sieve(num: int) -> list[int]:
"""
Returns a list with all prime numbers up to n.
- >>> sieve(50)
+ >>> prime_sieve(50)
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
- >>> sieve(25)
+ >>> prime_sieve(25)
[2, 3, 5, 7, 11, 13, 17, 19, 23]
- >>> sieve(10)
+ >>> prime_sieve(10)
[2, 3, 5, 7]
- >>> sieve(9)
+ >>> prime_sieve(9)
[2, 3, 5, 7]
- >>> sieve(2)
+ >>> prime_sieve(2)
[2]
- >>> sieve(1)
+ >>> prime_sieve(1)
[]
"""
- l = [True] * (n + 1) # noqa: E741
+ if num <= 0:
+ msg = f"{num}: Invalid input, please enter a positive integer."
+ raise ValueError(msg)
+
+ sieve = [True] * (num + 1)
prime = []
start = 2
- end = int(math.sqrt(n))
+ end = int(math.sqrt(num))
while start <= end:
# If start is a prime
- if l[start] is True:
+ if sieve[start] is True:
prime.append(start)
# Set multiples of start be False
- for i in range(start * start, n + 1, start):
- if l[i] is True:
- l[i] = False
+ for i in range(start * start, num + 1, start):
+ if sieve[i] is True:
+ sieve[i] = False
start += 1
- for j in range(end + 1, n + 1):
- if l[j] is True:
+ for j in range(end + 1, num + 1):
+ if sieve[j] is True:
prime.append(j)
return prime
if __name__ == "__main__":
- print(sieve(int(input("Enter n: ").strip())))
+ print(prime_sieve(int(input("Enter a positive integer: ").strip())))
diff --git a/maths/sigmoid.py b/maths/sigmoid.py
index 147588e8871f..cb45bde2702c 100644
--- a/maths/sigmoid.py
+++ b/maths/sigmoid.py
@@ -11,7 +11,7 @@
import numpy as np
-def sigmoid(vector: np.array) -> np.array:
+def sigmoid(vector: np.ndarray) -> np.ndarray:
"""
Implements the sigmoid function
diff --git a/maths/signum.py b/maths/signum.py
new file mode 100644
index 000000000000..c89753e76637
--- /dev/null
+++ b/maths/signum.py
@@ -0,0 +1,58 @@
+"""
+Signum function -- https://en.wikipedia.org/wiki/Sign_function
+"""
+
+
+def signum(num: float) -> int:
+ """
+ Applies signum function on the number
+
+ Custom test cases:
+ >>> signum(-10)
+ -1
+ >>> signum(10)
+ 1
+ >>> signum(0)
+ 0
+ >>> signum(-20.5)
+ -1
+ >>> signum(20.5)
+ 1
+ >>> signum(-1e-6)
+ -1
+ >>> signum(1e-6)
+ 1
+ >>> signum("Hello")
+ Traceback (most recent call last):
+ ...
+ TypeError: '<' not supported between instances of 'str' and 'int'
+ >>> signum([])
+ Traceback (most recent call last):
+ ...
+ TypeError: '<' not supported between instances of 'list' and 'int'
+ """
+ if num < 0:
+ return -1
+ return 1 if num else 0
+
+
+def test_signum() -> None:
+ """
+ Tests the signum function
+ >>> test_signum()
+ """
+ assert signum(5) == 1
+ assert signum(-5) == -1
+ assert signum(0) == 0
+ assert signum(10.5) == 1
+ assert signum(-10.5) == -1
+ assert signum(1e-6) == 1
+ assert signum(-1e-6) == -1
+ assert signum(123456789) == 1
+ assert signum(-123456789) == -1
+
+
+if __name__ == "__main__":
+ print(signum(12))
+ print(signum(-12))
+ print(signum(0))
diff --git a/maths/simpson_rule.py b/maths/simpson_rule.py
deleted file mode 100644
index d66dc39a7171..000000000000
--- a/maths/simpson_rule.py
+++ /dev/null
@@ -1,51 +0,0 @@
-"""
-Numerical integration or quadrature for a smooth function f with known values at x_i
-
-This method is the classical approach of suming 'Equally Spaced Abscissas'
-
-method 2:
-"Simpson Rule"
-
-"""
-
-
-def method_2(boundary, steps):
- # "Simpson Rule"
- # int(f) = delta_x/2 * (b-a)/3*(f1 + 4f2 + 2f_3 + ... + fn)
- h = (boundary[1] - boundary[0]) / steps
- a = boundary[0]
- b = boundary[1]
- x_i = make_points(a, b, h)
- y = 0.0
- y += (h / 3.0) * f(a)
- cnt = 2
- for i in x_i:
- y += (h / 3) * (4 - 2 * (cnt % 2)) * f(i)
- cnt += 1
- y += (h / 3.0) * f(b)
- return y
-
-
-def make_points(a, b, h):
- x = a + h
- while x < (b - h):
- yield x
- x = x + h
-
-
-def f(x): # enter your function here
- y = (x - 0) * (x - 0)
- return y
-
-
-def main():
- a = 0.0 # Lower bound of integration
- b = 1.0 # Upper bound of integration
- steps = 10.0 # define number of steps or resolution
- boundary = [a, b] # define boundary of integration
- y = method_2(boundary, steps)
- print(f"y = {y}")
-
-
-if __name__ == "__main__":
- main()
diff --git a/maths/simultaneous_linear_equation_solver.py b/maths/simultaneous_linear_equation_solver.py
new file mode 100644
index 000000000000..9685a33e82fe
--- /dev/null
+++ b/maths/simultaneous_linear_equation_solver.py
@@ -0,0 +1,142 @@
+"""
+https://en.wikipedia.org/wiki/Augmented_matrix
+
+This algorithm solves simultaneous linear equations of the form
+λa + λb + λc + λd + ... = y as [λ, λ, λ, λ, ..., y]
+Where λ & y are individual coefficients, the no. of equations = no. of coefficients - 1
+
+Note in order to work there must exist 1 equation where all instances of λ and y != 0
+"""
+
+
+def simplify(current_set: list[list]) -> list[list]:
+ """
+ >>> simplify([[1, 2, 3], [4, 5, 6]])
+ [[1.0, 2.0, 3.0], [0.0, 0.75, 1.5]]
+ >>> simplify([[5, 2, 5], [5, 1, 10]])
+ [[1.0, 0.4, 1.0], [0.0, 0.2, -1.0]]
+ """
+ # Divide each row by magnitude of first term --> creates 'unit' matrix
+ duplicate_set = current_set.copy()
+ for row_index, row in enumerate(duplicate_set):
+ magnitude = row[0]
+ for column_index, column in enumerate(row):
+ if magnitude == 0:
+ current_set[row_index][column_index] = column
+ continue
+ current_set[row_index][column_index] = column / magnitude
+ # Subtract to cancel term
+ first_row = current_set[0]
+ final_set = [first_row]
+ current_set = current_set[1::]
+ for row in current_set:
+ temp_row = []
+ # If first term is 0, it is already in form we want, so we preserve it
+ if row[0] == 0:
+ final_set.append(row)
+ continue
+ for column_index in range(len(row)):
+ temp_row.append(first_row[column_index] - row[column_index])
+ final_set.append(temp_row)
+ # Create next recursion iteration set
+ if len(final_set[0]) != 3:
+ current_first_row = final_set[0]
+ current_first_column = []
+ next_iteration = []
+ for row in final_set[1::]:
+ current_first_column.append(row[0])
+ next_iteration.append(row[1::])
+ resultant = simplify(next_iteration)
+ for i in range(len(resultant)):
+ resultant[i].insert(0, current_first_column[i])
+ resultant.insert(0, current_first_row)
+ final_set = resultant
+ return final_set
+
+
+def solve_simultaneous(equations: list[list]) -> list:
+ """
+ >>> solve_simultaneous([[1, 2, 3],[4, 5, 6]])
+ [-1.0, 2.0]
+ >>> solve_simultaneous([[0, -3, 1, 7],[3, 2, -1, 11],[5, 1, -2, 12]])
+ [6.4, 1.2, 10.6]
+ >>> solve_simultaneous([])
+ Traceback (most recent call last):
+ ...
+ IndexError: solve_simultaneous() requires n lists of length n+1
+ >>> solve_simultaneous([[1, 2, 3],[1, 2]])
+ Traceback (most recent call last):
+ ...
+ IndexError: solve_simultaneous() requires n lists of length n+1
+ >>> solve_simultaneous([[1, 2, 3],["a", 7, 8]])
+ Traceback (most recent call last):
+ ...
+ ValueError: solve_simultaneous() requires lists of integers
+ >>> solve_simultaneous([[0, 2, 3],[4, 0, 6]])
+ Traceback (most recent call last):
+ ...
+ ValueError: solve_simultaneous() requires at least 1 full equation
+ """
+ if len(equations) == 0:
+ raise IndexError("solve_simultaneous() requires n lists of length n+1")
+ _length = len(equations) + 1
+ if any(len(item) != _length for item in equations):
+ raise IndexError("solve_simultaneous() requires n lists of length n+1")
+ for row in equations:
+ if any(not isinstance(column, (int, float)) for column in row):
+ raise ValueError("solve_simultaneous() requires lists of integers")
+ if len(equations) == 1:
+ return [equations[0][-1] / equations[0][0]]
+ data_set = equations.copy()
+ if any(0 in row for row in data_set):
+ temp_data = data_set.copy()
+ full_row = []
+ for row_index, row in enumerate(temp_data):
+ if 0 not in row:
+ full_row = data_set.pop(row_index)
+ break
+ if not full_row:
+ raise ValueError("solve_simultaneous() requires at least 1 full equation")
+ data_set.insert(0, full_row)
+ useable_form = data_set.copy()
+ simplified = simplify(useable_form)
+ simplified = simplified[::-1]
+ solutions: list = []
+ for row in simplified:
+ current_solution = row[-1]
+ if not solutions:
+ if row[-2] == 0:
+ solutions.append(0)
+ continue
+ solutions.append(current_solution / row[-2])
+ continue
+ temp_row = row.copy()[: len(row) - 1 :]
+ while temp_row[0] == 0:
+ temp_row.pop(0)
+ if len(temp_row) == 0:
+ solutions.append(0)
+ continue
+ temp_row = temp_row[1::]
+ temp_row = temp_row[::-1]
+ for column_index, column in enumerate(temp_row):
+ current_solution -= column * solutions[column_index]
+ solutions.append(current_solution)
+ final = []
+ for item in solutions:
+ final.append(float(round(item, 5)))
+ return final[::-1]
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+ eq = [
+ [2, 1, 1, 1, 1, 4],
+ [1, 2, 1, 1, 1, 5],
+ [1, 1, 2, 1, 1, 6],
+ [1, 1, 1, 2, 1, 7],
+ [1, 1, 1, 1, 2, 8],
+ ]
+ print(solve_simultaneous(eq))
+ print(solve_simultaneous([[4, 2]]))
diff --git a/maths/sin.py b/maths/sin.py
new file mode 100644
index 000000000000..b06e6c9f1e5d
--- /dev/null
+++ b/maths/sin.py
@@ -0,0 +1,64 @@
+"""
+Calculate sin function.
+
+It's not a perfect function so I am rounding the result to 10 decimal places by default.
+
+Formula: sin(x) = x - x^3/3! + x^5/5! - x^7/7! + ...
+Where: x = angle in randians.
+
+Source:
+ https://www.homeschoolmath.net/teaching/sine_calculator.php
+
+"""
+
+from math import factorial, radians
+
+
+def sin(
+ angle_in_degrees: float, accuracy: int = 18, rounded_values_count: int = 10
+) -> float:
+ """
+ Implement sin function.
+
+ >>> sin(0.0)
+ 0.0
+ >>> sin(90.0)
+ 1.0
+ >>> sin(180.0)
+ 0.0
+ >>> sin(270.0)
+ -1.0
+ >>> sin(0.68)
+ 0.0118679603
+ >>> sin(1.97)
+ 0.0343762121
+ >>> sin(64.0)
+ 0.8987940463
+ >>> sin(9999.0)
+ -0.9876883406
+ >>> sin(-689.0)
+ 0.5150380749
+ >>> sin(89.7)
+ 0.9999862922
+ """
+ # Simplify the angle to be between 360 and -360 degrees.
+ angle_in_degrees = angle_in_degrees - ((angle_in_degrees // 360.0) * 360.0)
+
+ # Converting from degrees to radians
+ angle_in_radians = radians(angle_in_degrees)
+
+ result = angle_in_radians
+ a = 3
+ b = -1
+
+ for _ in range(accuracy):
+ result += (b * (angle_in_radians**a)) / factorial(a)
+
+ b = -b # One positive term and the next will be negative and so on...
+ a += 2 # Increased by 2 for every term.
+
+ return round(result, rounded_values_count)
+
+
+if __name__ == "__main__":
+ __import__("doctest").testmod()
diff --git a/maths/sock_merchant.py b/maths/sock_merchant.py
new file mode 100644
index 000000000000..304efec9ba5e
--- /dev/null
+++ b/maths/sock_merchant.py
@@ -0,0 +1,20 @@
+from collections import Counter
+
+
+def sock_merchant(colors: list[int]) -> int:
+ """
+ >>> sock_merchant([10, 20, 20, 10, 10, 30, 50, 10, 20])
+ 3
+ >>> sock_merchant([1, 1, 3, 3])
+ 2
+ """
+ return sum(socks_by_color // 2 for socks_by_color in Counter(colors).values())
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+
+ colors = [int(x) for x in input("Enter socks by color :").rstrip().split()]
+ print(f"sock_merchant({colors}) = {sock_merchant(colors)}")
diff --git a/maths/softmax.py b/maths/softmax.py
index e021a7f8a6fe..95c95e66f59e 100644
--- a/maths/softmax.py
+++ b/maths/softmax.py
@@ -28,7 +28,7 @@ def softmax(vector):
The softmax vector adds up to one. We need to ceil to mitigate for
precision
- >>> np.ceil(np.sum(softmax([1,2,3,4])))
+ >>> float(np.ceil(np.sum(softmax([1,2,3,4]))))
1.0
>>> vec = np.array([5,5])
@@ -41,13 +41,13 @@ def softmax(vector):
# Calculate e^x for each x in your vector where e is Euler's
# number (approximately 2.718)
- exponentVector = np.exp(vector)
+ exponent_vector = np.exp(vector)
# Add up the all the exponentials
- sumOfExponents = np.sum(exponentVector)
+ sum_of_exponents = np.sum(exponent_vector)
# Divide every exponent by the sum of all exponents
- softmax_vector = exponentVector / sumOfExponents
+ softmax_vector = exponent_vector / sum_of_exponents
return softmax_vector
diff --git a/maths/solovay_strassen_primality_test.py b/maths/solovay_strassen_primality_test.py
new file mode 100644
index 000000000000..b2d905b07bed
--- /dev/null
+++ b/maths/solovay_strassen_primality_test.py
@@ -0,0 +1,106 @@
+"""
+This script implements the Solovay-Strassen Primality test.
+
+This probabilistic primality test is based on Euler's criterion. It is similar
+to the Fermat test but uses quadratic residues. It can quickly identify
+composite numbers but may occasionally classify composite numbers as prime.
+
+More details and concepts about this can be found on:
+https://en.wikipedia.org/wiki/Solovay%E2%80%93Strassen_primality_test
+"""
+
+import random
+
+
+def jacobi_symbol(random_a: int, number: int) -> int:
+ """
+ Calculate the Jacobi symbol. The Jacobi symbol is a generalization
+ of the Legendre symbol, which can be used to simplify computations involving
+ quadratic residues. The Jacobi symbol is used in primality tests, like the
+ Solovay-Strassen test, because it helps determine if an integer is a
+ quadratic residue modulo a given modulus, providing valuable information
+ about the number's potential primality or compositeness.
+
+ Parameters:
+ random_a: A randomly chosen integer from 2 to n-2 (inclusive)
+ number: The number that is tested for primality
+
+ Returns:
+ jacobi_symbol: The Jacobi symbol is a mathematical function
+ used to determine whether an integer is a quadratic residue modulo
+ another integer (usually prime) or not.
+
+ >>> jacobi_symbol(2, 13)
+ -1
+ >>> jacobi_symbol(5, 19)
+ 1
+ >>> jacobi_symbol(7, 14)
+ 0
+ """
+
+ if random_a in (0, 1):
+ return random_a
+
+ random_a %= number
+ t = 1
+
+ while random_a != 0:
+ while random_a % 2 == 0:
+ random_a //= 2
+ r = number % 8
+ if r in (3, 5):
+ t = -t
+
+ random_a, number = number, random_a
+
+ if random_a % 4 == number % 4 == 3:
+ t = -t
+
+ random_a %= number
+
+ return t if number == 1 else 0
+
+
+def solovay_strassen(number: int, iterations: int) -> bool:
+ """
+ Check whether the input number is prime or not using
+ the Solovay-Strassen Primality test
+
+ Parameters:
+ number: The number that is tested for primality
+ iterations: The number of times that the test is run
+ which effects the accuracy
+
+ Returns:
+ result: True if number is probably prime and false
+ if not
+
+ >>> random.seed(10)
+ >>> solovay_strassen(13, 5)
+ True
+ >>> solovay_strassen(9, 10)
+ False
+ >>> solovay_strassen(17, 15)
+ True
+ """
+
+ if number <= 1:
+ return False
+ if number <= 3:
+ return True
+
+ for _ in range(iterations):
+ a = random.randint(2, number - 2)
+ x = jacobi_symbol(a, number)
+ y = pow(a, (number - 1) // 2, number)
+
+ if x == 0 or y != x % number:
+ return False
+
+ return True
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/spearman_rank_correlation_coefficient.py b/maths/spearman_rank_correlation_coefficient.py
new file mode 100644
index 000000000000..32ff6b9e3d71
--- /dev/null
+++ b/maths/spearman_rank_correlation_coefficient.py
@@ -0,0 +1,82 @@
+from collections.abc import Sequence
+
+
+def assign_ranks(data: Sequence[float]) -> list[int]:
+ """
+ Assigns ranks to elements in the array.
+
+ :param data: List of floats.
+ :return: List of ints representing the ranks.
+
+ Example:
+ >>> assign_ranks([3.2, 1.5, 4.0, 2.7, 5.1])
+ [3, 1, 4, 2, 5]
+
+ >>> assign_ranks([10.5, 8.1, 12.4, 9.3, 11.0])
+ [3, 1, 5, 2, 4]
+ """
+ ranked_data = sorted((value, index) for index, value in enumerate(data))
+ ranks = [0] * len(data)
+
+ for position, (_, index) in enumerate(ranked_data):
+ ranks[index] = position + 1
+
+ return ranks
+
+
+def calculate_spearman_rank_correlation(
+ variable_1: Sequence[float], variable_2: Sequence[float]
+) -> float:
+ """
+ Calculates Spearman's rank correlation coefficient.
+
+ :param variable_1: List of floats representing the first variable.
+ :param variable_2: List of floats representing the second variable.
+ :return: Spearman's rank correlation coefficient.
+
+ Example Usage:
+
+ >>> x = [1, 2, 3, 4, 5]
+ >>> y = [5, 4, 3, 2, 1]
+ >>> calculate_spearman_rank_correlation(x, y)
+ -1.0
+
+ >>> x = [1, 2, 3, 4, 5]
+ >>> y = [2, 4, 6, 8, 10]
+ >>> calculate_spearman_rank_correlation(x, y)
+ 1.0
+
+ >>> x = [1, 2, 3, 4, 5]
+ >>> y = [5, 1, 2, 9, 5]
+ >>> calculate_spearman_rank_correlation(x, y)
+ 0.6
+ """
+ n = len(variable_1)
+ rank_var1 = assign_ranks(variable_1)
+ rank_var2 = assign_ranks(variable_2)
+
+ # Calculate differences of ranks
+ d = [rx - ry for rx, ry in zip(rank_var1, rank_var2)]
+
+ # Calculate the sum of squared differences
+ d_squared = sum(di**2 for di in d)
+
+ # Calculate the Spearman's rank correlation coefficient
+ rho = 1 - (6 * d_squared) / (n * (n**2 - 1))
+
+ return rho
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+
+ # Example usage:
+ print(
+ f"{calculate_spearman_rank_correlation([1, 2, 3, 4, 5], [2, 4, 6, 8, 10]) = }"
+ )
+
+ print(f"{calculate_spearman_rank_correlation([1, 2, 3, 4, 5], [5, 4, 3, 2, 1]) = }")
+
+ print(f"{calculate_spearman_rank_correlation([1, 2, 3, 4, 5], [5, 1, 2, 9, 5]) = }")
diff --git a/maths/special_numbers/__init__.py b/maths/special_numbers/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/maths/special_numbers/armstrong_numbers.py b/maths/special_numbers/armstrong_numbers.py
new file mode 100644
index 000000000000..a3cb69b814de
--- /dev/null
+++ b/maths/special_numbers/armstrong_numbers.py
@@ -0,0 +1,99 @@
+"""
+An Armstrong number is equal to the sum of its own digits each raised to the
+power of the number of digits.
+
+For example, 370 is an Armstrong number because 3*3*3 + 7*7*7 + 0*0*0 = 370.
+
+Armstrong numbers are also called Narcissistic numbers and Pluperfect numbers.
+
+On-Line Encyclopedia of Integer Sequences entry: https://oeis.org/A005188
+"""
+
+PASSING = (1, 153, 370, 371, 1634, 24678051, 115132219018763992565095597973971522401)
+FAILING: tuple = (-153, -1, 0, 1.2, 200, "A", [], {}, None)
+
+
+def armstrong_number(n: int) -> bool:
+ """
+ Return True if n is an Armstrong number or False if it is not.
+
+ >>> all(armstrong_number(n) for n in PASSING)
+ True
+ >>> any(armstrong_number(n) for n in FAILING)
+ False
+ """
+ if not isinstance(n, int) or n < 1:
+ return False
+
+ # Initialization of sum and number of digits.
+ total = 0
+ number_of_digits = 0
+ temp = n
+ # Calculation of digits of the number
+ number_of_digits = len(str(n))
+ # Dividing number into separate digits and find Armstrong number
+ temp = n
+ while temp > 0:
+ rem = temp % 10
+ total += rem**number_of_digits
+ temp //= 10
+ return n == total
+
+
+def pluperfect_number(n: int) -> bool:
+ """Return True if n is a pluperfect number or False if it is not
+
+ >>> all(pluperfect_number(n) for n in PASSING)
+ True
+ >>> any(pluperfect_number(n) for n in FAILING)
+ False
+ """
+ if not isinstance(n, int) or n < 1:
+ return False
+
+ # Init a "histogram" of the digits
+ digit_histogram = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+ digit_total = 0
+ total = 0
+ temp = n
+ while temp > 0:
+ temp, rem = divmod(temp, 10)
+ digit_histogram[rem] += 1
+ digit_total += 1
+
+ for cnt, i in zip(digit_histogram, range(len(digit_histogram))):
+ total += cnt * i**digit_total
+
+ return n == total
+
+
+def narcissistic_number(n: int) -> bool:
+ """Return True if n is a narcissistic number or False if it is not.
+
+ >>> all(narcissistic_number(n) for n in PASSING)
+ True
+ >>> any(narcissistic_number(n) for n in FAILING)
+ False
+ """
+ if not isinstance(n, int) or n < 1:
+ return False
+ expo = len(str(n)) # the power that all digits will be raised to
+ # check if sum of each digit multiplied expo times is equal to number
+ return n == sum(int(i) ** expo for i in str(n))
+
+
+def main():
+ """
+ Request that user input an integer and tell them if it is Armstrong number.
+ """
+ num = int(input("Enter an integer to see if it is an Armstrong number: ").strip())
+ print(f"{num} is {'' if armstrong_number(num) else 'not '}an Armstrong number.")
+ print(f"{num} is {'' if narcissistic_number(num) else 'not '}an Armstrong number.")
+ print(f"{num} is {'' if pluperfect_number(num) else 'not '}an Armstrong number.")
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+ main()
diff --git a/maths/special_numbers/automorphic_number.py b/maths/special_numbers/automorphic_number.py
new file mode 100644
index 000000000000..8ed9375632a4
--- /dev/null
+++ b/maths/special_numbers/automorphic_number.py
@@ -0,0 +1,59 @@
+"""
+== Automorphic Numbers ==
+A number n is said to be a Automorphic number if
+the square of n "ends" in the same digits as n itself.
+
+Examples of Automorphic Numbers: 0, 1, 5, 6, 25, 76, 376, 625, 9376, 90625, ...
+https://en.wikipedia.org/wiki/Automorphic_number
+"""
+
+# Author : Akshay Dubey (https://github.com/itsAkshayDubey)
+# Time Complexity : O(log10n)
+
+
+def is_automorphic_number(number: int) -> bool:
+ """
+ # doctest: +NORMALIZE_WHITESPACE
+ This functions takes an integer number as input.
+ returns True if the number is automorphic.
+ >>> is_automorphic_number(-1)
+ False
+ >>> is_automorphic_number(0)
+ True
+ >>> is_automorphic_number(5)
+ True
+ >>> is_automorphic_number(6)
+ True
+ >>> is_automorphic_number(7)
+ False
+ >>> is_automorphic_number(25)
+ True
+ >>> is_automorphic_number(259918212890625)
+ True
+ >>> is_automorphic_number(259918212890636)
+ False
+ >>> is_automorphic_number(740081787109376)
+ True
+ >>> is_automorphic_number(5.0)
+ Traceback (most recent call last):
+ ...
+ TypeError: Input value of [number=5.0] must be an integer
+ """
+ if not isinstance(number, int):
+ msg = f"Input value of [number={number}] must be an integer"
+ raise TypeError(msg)
+ if number < 0:
+ return False
+ number_square = number * number
+ while number > 0:
+ if number % 10 != number_square % 10:
+ return False
+ number //= 10
+ number_square //= 10
+ return True
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/special_numbers/bell_numbers.py b/maths/special_numbers/bell_numbers.py
new file mode 100644
index 000000000000..d573e7a3962d
--- /dev/null
+++ b/maths/special_numbers/bell_numbers.py
@@ -0,0 +1,81 @@
+"""
+Bell numbers represent the number of ways to partition a set into non-empty
+subsets. This module provides functions to calculate Bell numbers for sets of
+integers. In other words, the first (n + 1) Bell numbers.
+
+For more information about Bell numbers, refer to:
+https://en.wikipedia.org/wiki/Bell_number
+"""
+
+
+def bell_numbers(max_set_length: int) -> list[int]:
+ """
+ Calculate Bell numbers for the sets of lengths from 0 to max_set_length.
+ In other words, calculate first (max_set_length + 1) Bell numbers.
+
+ Args:
+ max_set_length (int): The maximum length of the sets for which
+ Bell numbers are calculated.
+
+ Returns:
+ list: A list of Bell numbers for sets of lengths from 0 to max_set_length.
+
+ Examples:
+ >>> bell_numbers(-2)
+ Traceback (most recent call last):
+ ...
+ ValueError: max_set_length must be non-negative
+ >>> bell_numbers(0)
+ [1]
+ >>> bell_numbers(1)
+ [1, 1]
+ >>> bell_numbers(5)
+ [1, 1, 2, 5, 15, 52]
+ """
+ if max_set_length < 0:
+ raise ValueError("max_set_length must be non-negative")
+
+ bell = [0] * (max_set_length + 1)
+ bell[0] = 1
+
+ for i in range(1, max_set_length + 1):
+ for j in range(i):
+ bell[i] += _binomial_coefficient(i - 1, j) * bell[j]
+
+ return bell
+
+
+def _binomial_coefficient(total_elements: int, elements_to_choose: int) -> int:
+ """
+ Calculate the binomial coefficient C(total_elements, elements_to_choose)
+
+ Args:
+ total_elements (int): The total number of elements.
+ elements_to_choose (int): The number of elements to choose.
+
+ Returns:
+ int: The binomial coefficient C(total_elements, elements_to_choose).
+
+ Examples:
+ >>> _binomial_coefficient(5, 2)
+ 10
+ >>> _binomial_coefficient(6, 3)
+ 20
+ """
+ if elements_to_choose in {0, total_elements}:
+ return 1
+
+ elements_to_choose = min(elements_to_choose, total_elements - elements_to_choose)
+
+ coefficient = 1
+ for i in range(elements_to_choose):
+ coefficient *= total_elements - i
+ coefficient //= i + 1
+
+ return coefficient
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/special_numbers/carmichael_number.py b/maths/special_numbers/carmichael_number.py
new file mode 100644
index 000000000000..c73908545702
--- /dev/null
+++ b/maths/special_numbers/carmichael_number.py
@@ -0,0 +1,86 @@
+"""
+== Carmichael Numbers ==
+A number n is said to be a Carmichael number if it
+satisfies the following modular arithmetic condition:
+
+ power(b, n-1) MOD n = 1,
+ for all b ranging from 1 to n such that b and
+ n are relatively prime, i.e, gcd(b, n) = 1
+
+Examples of Carmichael Numbers: 561, 1105, ...
+https://en.wikipedia.org/wiki/Carmichael_number
+"""
+
+from maths.greatest_common_divisor import greatest_common_divisor
+
+
+def power(x: int, y: int, mod: int) -> int:
+ """
+ Examples:
+ >>> power(2, 15, 3)
+ 2
+ >>> power(5, 1, 30)
+ 5
+ """
+
+ if y == 0:
+ return 1
+ temp = power(x, y // 2, mod) % mod
+ temp = (temp * temp) % mod
+ if y % 2 == 1:
+ temp = (temp * x) % mod
+ return temp
+
+
+def is_carmichael_number(n: int) -> bool:
+ """
+ Examples:
+ >>> is_carmichael_number(4)
+ False
+ >>> is_carmichael_number(561)
+ True
+ >>> is_carmichael_number(562)
+ False
+ >>> is_carmichael_number(900)
+ False
+ >>> is_carmichael_number(1105)
+ True
+ >>> is_carmichael_number(8911)
+ True
+ >>> is_carmichael_number(5.1)
+ Traceback (most recent call last):
+ ...
+ ValueError: Number 5.1 must instead be a positive integer
+
+ >>> is_carmichael_number(-7)
+ Traceback (most recent call last):
+ ...
+ ValueError: Number -7 must instead be a positive integer
+
+ >>> is_carmichael_number(0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Number 0 must instead be a positive integer
+ """
+
+ if n <= 0 or not isinstance(n, int):
+ msg = f"Number {n} must instead be a positive integer"
+ raise ValueError(msg)
+
+ return all(
+ power(b, n - 1, n) == 1
+ for b in range(2, n)
+ if greatest_common_divisor(b, n) == 1
+ )
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+
+ number = int(input("Enter number: ").strip())
+ if is_carmichael_number(number):
+ print(f"{number} is a Carmichael Number.")
+ else:
+ print(f"{number} is not a Carmichael Number.")
diff --git a/maths/special_numbers/catalan_number.py b/maths/special_numbers/catalan_number.py
new file mode 100644
index 000000000000..20c2cfb17c06
--- /dev/null
+++ b/maths/special_numbers/catalan_number.py
@@ -0,0 +1,53 @@
+"""
+
+Calculate the nth Catalan number
+
+Source:
+ https://en.wikipedia.org/wiki/Catalan_number
+
+"""
+
+
+def catalan(number: int) -> int:
+ """
+ :param number: nth catalan number to calculate
+ :return: the nth catalan number
+ Note: A catalan number is only defined for positive integers
+
+ >>> catalan(5)
+ 14
+ >>> catalan(0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input value of [number=0] must be > 0
+ >>> catalan(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input value of [number=-1] must be > 0
+ >>> catalan(5.0)
+ Traceback (most recent call last):
+ ...
+ TypeError: Input value of [number=5.0] must be an integer
+ """
+
+ if not isinstance(number, int):
+ msg = f"Input value of [number={number}] must be an integer"
+ raise TypeError(msg)
+
+ if number < 1:
+ msg = f"Input value of [number={number}] must be > 0"
+ raise ValueError(msg)
+
+ current_number = 1
+
+ for i in range(1, number):
+ current_number *= 4 * i - 2
+ current_number //= i + 1
+
+ return current_number
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/special_numbers/hamming_numbers.py b/maths/special_numbers/hamming_numbers.py
new file mode 100644
index 000000000000..a473cc93883b
--- /dev/null
+++ b/maths/special_numbers/hamming_numbers.py
@@ -0,0 +1,55 @@
+"""
+A Hamming number is a positive integer of the form 2^i*3^j*5^k, for some
+non-negative integers i, j, and k. They are often referred to as regular numbers.
+More info at: https://en.wikipedia.org/wiki/Regular_number.
+"""
+
+
+def hamming(n_element: int) -> list:
+ """
+ This function creates an ordered list of n length as requested, and afterwards
+ returns the last value of the list. It must be given a positive integer.
+
+ :param n_element: The number of elements on the list
+ :return: The nth element of the list
+
+ >>> hamming(-5)
+ Traceback (most recent call last):
+ ...
+ ValueError: n_element should be a positive number
+ >>> hamming(5)
+ [1, 2, 3, 4, 5]
+ >>> hamming(10)
+ [1, 2, 3, 4, 5, 6, 8, 9, 10, 12]
+ >>> hamming(15)
+ [1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 16, 18, 20, 24]
+ """
+ n_element = int(n_element)
+ if n_element < 1:
+ my_error = ValueError("n_element should be a positive number")
+ raise my_error
+
+ hamming_list = [1]
+ i, j, k = (0, 0, 0)
+ index = 1
+ while index < n_element:
+ while hamming_list[i] * 2 <= hamming_list[-1]:
+ i += 1
+ while hamming_list[j] * 3 <= hamming_list[-1]:
+ j += 1
+ while hamming_list[k] * 5 <= hamming_list[-1]:
+ k += 1
+ hamming_list.append(
+ min(hamming_list[i] * 2, hamming_list[j] * 3, hamming_list[k] * 5)
+ )
+ index += 1
+ return hamming_list
+
+
+if __name__ == "__main__":
+ n = input("Enter the last number (nth term) of the Hamming Number Series: ")
+ print("Formula of Hamming Number Series => 2^i * 3^j * 5^k")
+ hamming_numbers = hamming(int(n))
+ print("-----------------------------------------------------")
+ print(f"The list with nth numbers is: {hamming_numbers}")
+ print("-----------------------------------------------------")
diff --git a/maths/special_numbers/happy_number.py b/maths/special_numbers/happy_number.py
new file mode 100644
index 000000000000..eac3167e304b
--- /dev/null
+++ b/maths/special_numbers/happy_number.py
@@ -0,0 +1,48 @@
+def is_happy_number(number: int) -> bool:
+ """
+ A happy number is a number which eventually reaches 1 when replaced by the sum of
+ the square of each digit.
+
+ :param number: The number to check for happiness.
+ :return: True if the number is a happy number, False otherwise.
+
+ >>> is_happy_number(19)
+ True
+ >>> is_happy_number(2)
+ False
+ >>> is_happy_number(23)
+ True
+ >>> is_happy_number(1)
+ True
+ >>> is_happy_number(0)
+ Traceback (most recent call last):
+ ...
+ ValueError: number=0 must be a positive integer
+ >>> is_happy_number(-19)
+ Traceback (most recent call last):
+ ...
+ ValueError: number=-19 must be a positive integer
+ >>> is_happy_number(19.1)
+ Traceback (most recent call last):
+ ...
+ ValueError: number=19.1 must be a positive integer
+ >>> is_happy_number("happy")
+ Traceback (most recent call last):
+ ...
+ ValueError: number='happy' must be a positive integer
+ """
+ if not isinstance(number, int) or number <= 0:
+ msg = f"{number=} must be a positive integer"
+ raise ValueError(msg)
+
+ seen = set()
+ while number != 1 and number not in seen:
+ seen.add(number)
+ number = sum(int(digit) ** 2 for digit in str(number))
+ return number == 1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/special_numbers/harshad_numbers.py b/maths/special_numbers/harshad_numbers.py
new file mode 100644
index 000000000000..417120bd840e
--- /dev/null
+++ b/maths/special_numbers/harshad_numbers.py
@@ -0,0 +1,166 @@
+"""
+A harshad number (or more specifically an n-harshad number) is a number that's
+divisible by the sum of its digits in some given base n.
+Reference: https://en.wikipedia.org/wiki/Harshad_number
+"""
+
+
+def int_to_base(number: int, base: int) -> str:
+ """
+ Convert a given positive decimal integer to base 'base'.
+ Where 'base' ranges from 2 to 36.
+
+ Examples:
+ >>> int_to_base(0, 21)
+ '0'
+ >>> int_to_base(23, 2)
+ '10111'
+ >>> int_to_base(58, 5)
+ '213'
+ >>> int_to_base(167, 16)
+ 'A7'
+ >>> # bases below 2 and beyond 36 will error
+ >>> int_to_base(98, 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: 'base' must be between 2 and 36 inclusive
+ >>> int_to_base(98, 37)
+ Traceback (most recent call last):
+ ...
+ ValueError: 'base' must be between 2 and 36 inclusive
+ >>> int_to_base(-99, 16)
+ Traceback (most recent call last):
+ ...
+ ValueError: number must be a positive integer
+ """
+
+ if base < 2 or base > 36:
+ raise ValueError("'base' must be between 2 and 36 inclusive")
+
+ digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ result = ""
+
+ if number < 0:
+ raise ValueError("number must be a positive integer")
+
+ while number > 0:
+ number, remainder = divmod(number, base)
+ result = digits[remainder] + result
+
+ if result == "":
+ result = "0"
+
+ return result
+
+
+def sum_of_digits(num: int, base: int) -> str:
+ """
+ Calculate the sum of digit values in a positive integer
+ converted to the given 'base'.
+ Where 'base' ranges from 2 to 36.
+
+ Examples:
+ >>> sum_of_digits(103, 12)
+ '13'
+ >>> sum_of_digits(1275, 4)
+ '30'
+ >>> sum_of_digits(6645, 2)
+ '1001'
+ >>> # bases below 2 and beyond 36 will error
+ >>> sum_of_digits(543, 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: 'base' must be between 2 and 36 inclusive
+ >>> sum_of_digits(543, 37)
+ Traceback (most recent call last):
+ ...
+ ValueError: 'base' must be between 2 and 36 inclusive
+ """
+
+ if base < 2 or base > 36:
+ raise ValueError("'base' must be between 2 and 36 inclusive")
+
+ num_str = int_to_base(num, base)
+ res = sum(int(char, base) for char in num_str)
+ res_str = int_to_base(res, base)
+ return res_str
+
+
+def harshad_numbers_in_base(limit: int, base: int) -> list[str]:
+ """
+ Finds all Harshad numbers smaller than num in base 'base'.
+ Where 'base' ranges from 2 to 36.
+
+ Examples:
+ >>> harshad_numbers_in_base(15, 2)
+ ['1', '10', '100', '110', '1000', '1010', '1100']
+ >>> harshad_numbers_in_base(12, 34)
+ ['1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B']
+ >>> harshad_numbers_in_base(12, 4)
+ ['1', '2', '3', '10', '12', '20', '21']
+ >>> # bases below 2 and beyond 36 will error
+ >>> harshad_numbers_in_base(234, 37)
+ Traceback (most recent call last):
+ ...
+ ValueError: 'base' must be between 2 and 36 inclusive
+ >>> harshad_numbers_in_base(234, 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: 'base' must be between 2 and 36 inclusive
+ >>> harshad_numbers_in_base(-12, 6)
+ []
+ """
+
+ if base < 2 or base > 36:
+ raise ValueError("'base' must be between 2 and 36 inclusive")
+
+ if limit < 0:
+ return []
+
+ numbers = [
+ int_to_base(i, base)
+ for i in range(1, limit)
+ if i % int(sum_of_digits(i, base), base) == 0
+ ]
+
+ return numbers
+
+
+def is_harshad_number_in_base(num: int, base: int) -> bool:
+ """
+ Determines whether n in base 'base' is a harshad number.
+ Where 'base' ranges from 2 to 36.
+
+ Examples:
+ >>> is_harshad_number_in_base(18, 10)
+ True
+ >>> is_harshad_number_in_base(21, 10)
+ True
+ >>> is_harshad_number_in_base(-21, 5)
+ False
+ >>> # bases below 2 and beyond 36 will error
+ >>> is_harshad_number_in_base(45, 37)
+ Traceback (most recent call last):
+ ...
+ ValueError: 'base' must be between 2 and 36 inclusive
+ >>> is_harshad_number_in_base(45, 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: 'base' must be between 2 and 36 inclusive
+ """
+
+ if base < 2 or base > 36:
+ raise ValueError("'base' must be between 2 and 36 inclusive")
+
+ if num < 0:
+ return False
+
+ n = int_to_base(num, base)
+ d = sum_of_digits(num, base)
+ return int(n, base) % int(d, base) == 0
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/special_numbers/hexagonal_number.py b/maths/special_numbers/hexagonal_number.py
new file mode 100644
index 000000000000..3677ab95ee00
--- /dev/null
+++ b/maths/special_numbers/hexagonal_number.py
@@ -0,0 +1,49 @@
+"""
+== Hexagonal Number ==
+The nth hexagonal number hn is the number of distinct dots
+in a pattern of dots consisting of the outlines of regular
+hexagons with sides up to n dots, when the hexagons are
+overlaid so that they share one vertex.
+
+https://en.wikipedia.org/wiki/Hexagonal_number
+"""
+
+# Author : Akshay Dubey (https://github.com/itsAkshayDubey)
+
+
+def hexagonal(number: int) -> int:
+ """
+ :param number: nth hexagonal number to calculate
+ :return: the nth hexagonal number
+ Note: A hexagonal number is only defined for positive integers
+ >>> hexagonal(4)
+ 28
+ >>> hexagonal(11)
+ 231
+ >>> hexagonal(22)
+ 946
+ >>> hexagonal(0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input must be a positive integer
+ >>> hexagonal(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input must be a positive integer
+ >>> hexagonal(11.0)
+ Traceback (most recent call last):
+ ...
+ TypeError: Input value of [number=11.0] must be an integer
+ """
+ if not isinstance(number, int):
+ msg = f"Input value of [number={number}] must be an integer"
+ raise TypeError(msg)
+ if number < 1:
+ raise ValueError("Input must be a positive integer")
+ return number * (2 * number - 1)
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/krishnamurthy_number.py b/maths/special_numbers/krishnamurthy_number.py
similarity index 92%
rename from maths/krishnamurthy_number.py
rename to maths/special_numbers/krishnamurthy_number.py
index c88f68a07f27..c1d8a8fc5f56 100644
--- a/maths/krishnamurthy_number.py
+++ b/maths/special_numbers/krishnamurthy_number.py
@@ -33,12 +33,12 @@ def krishnamurthy(number: int) -> bool:
True
"""
- factSum = 0
+ fact_sum = 0
duplicate = number
while duplicate > 0:
duplicate, digit = divmod(duplicate, 10)
- factSum += factorial(digit)
- return factSum == number
+ fact_sum += factorial(digit)
+ return fact_sum == number
if __name__ == "__main__":
diff --git a/maths/special_numbers/perfect_number.py b/maths/special_numbers/perfect_number.py
new file mode 100644
index 000000000000..a022dc677638
--- /dev/null
+++ b/maths/special_numbers/perfect_number.py
@@ -0,0 +1,79 @@
+"""
+== Perfect Number ==
+In number theory, a perfect number is a positive integer that is equal to the sum of
+its positive divisors, excluding the number itself.
+For example: 6 ==> divisors[1, 2, 3, 6]
+ Excluding 6, the sum(divisors) is 1 + 2 + 3 = 6
+ So, 6 is a Perfect Number
+
+Other examples of Perfect Numbers: 28, 486, ...
+
+https://en.wikipedia.org/wiki/Perfect_number
+"""
+
+
+def perfect(number: int) -> bool:
+ """
+ Check if a number is a perfect number.
+
+ A perfect number is a positive integer that is equal to the sum of its proper
+ divisors (excluding itself).
+
+ Args:
+ number: The number to be checked.
+
+ Returns:
+ True if the number is a perfect number, False otherwise.
+
+ Start from 1 because dividing by 0 will raise ZeroDivisionError.
+ A number at most can be divisible by the half of the number except the number
+ itself. For example, 6 is at most can be divisible by 3 except by 6 itself.
+
+ Examples:
+ >>> perfect(27)
+ False
+ >>> perfect(28)
+ True
+ >>> perfect(29)
+ False
+ >>> perfect(6)
+ True
+ >>> perfect(12)
+ False
+ >>> perfect(496)
+ True
+ >>> perfect(8128)
+ True
+ >>> perfect(0)
+ False
+ >>> perfect(-1)
+ False
+ >>> perfect(12.34)
+ Traceback (most recent call last):
+ ...
+ ValueError: number must be an integer
+ >>> perfect("Hello")
+ Traceback (most recent call last):
+ ...
+ ValueError: number must be an integer
+ """
+ if not isinstance(number, int):
+ raise ValueError("number must be an integer")
+ if number <= 0:
+ return False
+ return sum(i for i in range(1, number // 2 + 1) if number % i == 0) == number
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
+ print("Program to check whether a number is a Perfect number or not...")
+ try:
+ number = int(input("Enter a positive integer: ").strip())
+ except ValueError:
+ msg = "number must be an integer"
+ print(msg)
+ raise ValueError(msg)
+
+ print(f"{number} is {'' if perfect(number) else 'not '}a Perfect Number.")
diff --git a/maths/special_numbers/polygonal_numbers.py b/maths/special_numbers/polygonal_numbers.py
new file mode 100644
index 000000000000..7a7dc91acb26
--- /dev/null
+++ b/maths/special_numbers/polygonal_numbers.py
@@ -0,0 +1,32 @@
+def polygonal_num(num: int, sides: int) -> int:
+ """
+ Returns the `num`th `sides`-gonal number. It is assumed that `num` >= 0 and
+ `sides` >= 3 (see for reference https://en.wikipedia.org/wiki/Polygonal_number).
+
+ >>> polygonal_num(0, 3)
+ 0
+ >>> polygonal_num(3, 3)
+ 6
+ >>> polygonal_num(5, 4)
+ 25
+ >>> polygonal_num(2, 5)
+ 5
+ >>> polygonal_num(-1, 0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Invalid input: num must be >= 0 and sides must be >= 3.
+ >>> polygonal_num(0, 2)
+ Traceback (most recent call last):
+ ...
+ ValueError: Invalid input: num must be >= 0 and sides must be >= 3.
+ """
+ if num < 0 or sides < 3:
+ raise ValueError("Invalid input: num must be >= 0 and sides must be >= 3.")
+
+ return ((sides - 2) * num**2 - (sides - 4) * num) // 2
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/special_numbers/pronic_number.py b/maths/special_numbers/pronic_number.py
new file mode 100644
index 000000000000..cf4d3d2eb24b
--- /dev/null
+++ b/maths/special_numbers/pronic_number.py
@@ -0,0 +1,55 @@
+"""
+== Pronic Number ==
+A number n is said to be a Proic number if
+there exists an integer m such that n = m * (m + 1)
+
+Examples of Proic Numbers: 0, 2, 6, 12, 20, 30, 42, 56, 72, 90, 110 ...
+https://en.wikipedia.org/wiki/Pronic_number
+"""
+
+# Author : Akshay Dubey (https://github.com/itsAkshayDubey)
+
+
+def is_pronic(number: int) -> bool:
+ """
+ # doctest: +NORMALIZE_WHITESPACE
+ This functions takes an integer number as input.
+ returns True if the number is pronic.
+ >>> is_pronic(-1)
+ False
+ >>> is_pronic(0)
+ True
+ >>> is_pronic(2)
+ True
+ >>> is_pronic(5)
+ False
+ >>> is_pronic(6)
+ True
+ >>> is_pronic(8)
+ False
+ >>> is_pronic(30)
+ True
+ >>> is_pronic(32)
+ False
+ >>> is_pronic(2147441940)
+ True
+ >>> is_pronic(9223372033963249500)
+ True
+ >>> is_pronic(6.0)
+ Traceback (most recent call last):
+ ...
+ TypeError: Input value of [number=6.0] must be an integer
+ """
+ if not isinstance(number, int):
+ msg = f"Input value of [number={number}] must be an integer"
+ raise TypeError(msg)
+ if number < 0 or number % 2 == 1:
+ return False
+ number_sqrt = int(number**0.5)
+ return number == number_sqrt * (number_sqrt + 1)
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/special_numbers/proth_number.py b/maths/special_numbers/proth_number.py
new file mode 100644
index 000000000000..47747ed260f7
--- /dev/null
+++ b/maths/special_numbers/proth_number.py
@@ -0,0 +1,75 @@
+"""
+Calculate the nth Proth number
+Source:
+ https://handwiki.org/wiki/Proth_number
+"""
+
+import math
+
+
+def proth(number: int) -> int:
+ """
+ :param number: nth number to calculate in the sequence
+ :return: the nth number in Proth number
+ Note: indexing starts at 1 i.e. proth(1) gives the first Proth number of 3
+ >>> proth(6)
+ 25
+ >>> proth(0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input value of [number=0] must be > 0
+ >>> proth(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: Input value of [number=-1] must be > 0
+ >>> proth(6.0)
+ Traceback (most recent call last):
+ ...
+ TypeError: Input value of [number=6.0] must be an integer
+ """
+
+ if not isinstance(number, int):
+ msg = f"Input value of [number={number}] must be an integer"
+ raise TypeError(msg)
+
+ if number < 1:
+ msg = f"Input value of [number={number}] must be > 0"
+ raise ValueError(msg)
+ elif number == 1:
+ return 3
+ elif number == 2:
+ return 5
+ else:
+ """
+ +1 for binary starting at 0 i.e. 2^0, 2^1, etc.
+ +1 to start the sequence at the 3rd Proth number
+ Hence, we have a +2 in the below statement
+ """
+ block_index = int(math.log(number // 3, 2)) + 2
+
+ proth_list = [3, 5]
+ proth_index = 2
+ increment = 3
+ for block in range(1, block_index):
+ for _ in range(increment):
+ proth_list.append(2 ** (block + 1) + proth_list[proth_index - 1])
+ proth_index += 1
+ increment *= 2
+
+ return proth_list[number - 1]
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+
+ for number in range(11):
+ value = 0
+ try:
+ value = proth(number)
+ except ValueError:
+ print(f"ValueError: there is no {number}th Proth number")
+ continue
+
+ print(f"The {number}th Proth number: {value}")
diff --git a/maths/special_numbers/triangular_numbers.py b/maths/special_numbers/triangular_numbers.py
new file mode 100644
index 000000000000..5be89e6108b2
--- /dev/null
+++ b/maths/special_numbers/triangular_numbers.py
@@ -0,0 +1,43 @@
+"""
+A triangular number or triangle number counts objects arranged in an
+equilateral triangle. This module provides a function to generate n'th
+triangular number.
+
+For more information about triangular numbers, refer to:
+https://en.wikipedia.org/wiki/Triangular_number
+"""
+
+
+def triangular_number(position: int) -> int:
+ """
+ Generate the triangular number at the specified position.
+
+ Args:
+ position (int): The position of the triangular number to generate.
+
+ Returns:
+ int: The triangular number at the specified position.
+
+ Raises:
+ ValueError: If `position` is negative.
+
+ Examples:
+ >>> triangular_number(1)
+ 1
+ >>> triangular_number(3)
+ 6
+ >>> triangular_number(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: param `position` must be non-negative
+ """
+ if position < 0:
+ raise ValueError("param `position` must be non-negative")
+
+ return position * (position + 1) // 2
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/ugly_numbers.py b/maths/special_numbers/ugly_numbers.py
similarity index 94%
rename from maths/ugly_numbers.py
rename to maths/special_numbers/ugly_numbers.py
index 4451a68cdaad..c6ceb784622a 100644
--- a/maths/ugly_numbers.py
+++ b/maths/special_numbers/ugly_numbers.py
@@ -1,54 +1,54 @@
-"""
-Ugly numbers are numbers whose only prime factors are 2, 3 or 5. The sequence
-1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, … shows the first 11 ugly numbers. By convention,
-1 is included.
-Given an integer n, we have to find the nth ugly number.
-
-For more details, refer this article
-https://www.geeksforgeeks.org/ugly-numbers/
-"""
-
-
-def ugly_numbers(n: int) -> int:
- """
- Returns the nth ugly number.
- >>> ugly_numbers(100)
- 1536
- >>> ugly_numbers(0)
- 1
- >>> ugly_numbers(20)
- 36
- >>> ugly_numbers(-5)
- 1
- >>> ugly_numbers(-5.5)
- Traceback (most recent call last):
- ...
- TypeError: 'float' object cannot be interpreted as an integer
- """
- ugly_nums = [1]
-
- i2, i3, i5 = 0, 0, 0
- next_2 = ugly_nums[i2] * 2
- next_3 = ugly_nums[i3] * 3
- next_5 = ugly_nums[i5] * 5
-
- for i in range(1, n):
- next_num = min(next_2, next_3, next_5)
- ugly_nums.append(next_num)
- if next_num == next_2:
- i2 += 1
- next_2 = ugly_nums[i2] * 2
- if next_num == next_3:
- i3 += 1
- next_3 = ugly_nums[i3] * 3
- if next_num == next_5:
- i5 += 1
- next_5 = ugly_nums[i5] * 5
- return ugly_nums[-1]
-
-
-if __name__ == "__main__":
- from doctest import testmod
-
- testmod(verbose=True)
- print(f"{ugly_numbers(200) = }")
+"""
+Ugly numbers are numbers whose only prime factors are 2, 3 or 5. The sequence
+1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, … shows the first 11 ugly numbers. By convention,
+1 is included.
+Given an integer n, we have to find the nth ugly number.
+
+For more details, refer this article
+https://www.geeksforgeeks.org/ugly-numbers/
+"""
+
+
+def ugly_numbers(n: int) -> int:
+ """
+ Returns the nth ugly number.
+ >>> ugly_numbers(100)
+ 1536
+ >>> ugly_numbers(0)
+ 1
+ >>> ugly_numbers(20)
+ 36
+ >>> ugly_numbers(-5)
+ 1
+ >>> ugly_numbers(-5.5)
+ Traceback (most recent call last):
+ ...
+ TypeError: 'float' object cannot be interpreted as an integer
+ """
+ ugly_nums = [1]
+
+ i2, i3, i5 = 0, 0, 0
+ next_2 = ugly_nums[i2] * 2
+ next_3 = ugly_nums[i3] * 3
+ next_5 = ugly_nums[i5] * 5
+
+ for _ in range(1, n):
+ next_num = min(next_2, next_3, next_5)
+ ugly_nums.append(next_num)
+ if next_num == next_2:
+ i2 += 1
+ next_2 = ugly_nums[i2] * 2
+ if next_num == next_3:
+ i3 += 1
+ next_3 = ugly_nums[i3] * 3
+ if next_num == next_5:
+ i5 += 1
+ next_5 = ugly_nums[i5] * 5
+ return ugly_nums[-1]
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod(verbose=True)
+ print(f"{ugly_numbers(200) = }")
diff --git a/maths/special_numbers/weird_number.py b/maths/special_numbers/weird_number.py
new file mode 100644
index 000000000000..5c9240d0ea4e
--- /dev/null
+++ b/maths/special_numbers/weird_number.py
@@ -0,0 +1,101 @@
+"""
+https://en.wikipedia.org/wiki/Weird_number
+
+Fun fact: The set of weird numbers has positive asymptotic density.
+"""
+
+from math import sqrt
+
+
+def factors(number: int) -> list[int]:
+ """
+ >>> factors(12)
+ [1, 2, 3, 4, 6]
+ >>> factors(1)
+ [1]
+ >>> factors(100)
+ [1, 2, 4, 5, 10, 20, 25, 50]
+
+ # >>> factors(-12)
+ # [1, 2, 3, 4, 6]
+ """
+
+ values = [1]
+ for i in range(2, int(sqrt(number)) + 1, 1):
+ if number % i == 0:
+ values.append(i)
+ if int(number // i) != i:
+ values.append(int(number // i))
+ return sorted(values)
+
+
+def abundant(n: int) -> bool:
+ """
+ >>> abundant(0)
+ True
+ >>> abundant(1)
+ False
+ >>> abundant(12)
+ True
+ >>> abundant(13)
+ False
+ >>> abundant(20)
+ True
+
+ # >>> abundant(-12)
+ # True
+ """
+ return sum(factors(n)) > n
+
+
+def semi_perfect(number: int) -> bool:
+ """
+ >>> semi_perfect(0)
+ True
+ >>> semi_perfect(1)
+ True
+ >>> semi_perfect(12)
+ True
+ >>> semi_perfect(13)
+ False
+
+ # >>> semi_perfect(-12)
+ # True
+ """
+ values = factors(number)
+ r = len(values)
+ subset = [[0 for i in range(number + 1)] for j in range(r + 1)]
+ for i in range(r + 1):
+ subset[i][0] = True
+
+ for i in range(1, number + 1):
+ subset[0][i] = False
+
+ for i in range(1, r + 1):
+ for j in range(1, number + 1):
+ if j < values[i - 1]:
+ subset[i][j] = subset[i - 1][j]
+ else:
+ subset[i][j] = subset[i - 1][j] or subset[i - 1][j - values[i - 1]]
+
+ return subset[r][number] != 0
+
+
+def weird(number: int) -> bool:
+ """
+ >>> weird(0)
+ False
+ >>> weird(70)
+ True
+ >>> weird(77)
+ False
+ """
+ return abundant(number) and not semi_perfect(number)
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod(verbose=True)
+ for number in (69, 70, 71):
+ print(f"{number} is {'' if weird(number) else 'not '}weird.")
diff --git a/maths/sum_of_arithmetic_series.py b/maths/sum_of_arithmetic_series.py
index 74eef0f18a12..3e381b8c20a8 100644
--- a/maths/sum_of_arithmetic_series.py
+++ b/maths/sum_of_arithmetic_series.py
@@ -1,5 +1,5 @@
# DarkCoder
-def sum_of_series(first_term, common_diff, num_of_terms):
+def sum_of_series(first_term: int, common_diff: int, num_of_terms: int) -> float:
"""
Find the sum of n terms in an arithmetic progression.
@@ -8,9 +8,9 @@ def sum_of_series(first_term, common_diff, num_of_terms):
>>> sum_of_series(1, 10, 100)
49600.0
"""
- sum = (num_of_terms / 2) * (2 * first_term + (num_of_terms - 1) * common_diff)
+ total = (num_of_terms / 2) * (2 * first_term + (num_of_terms - 1) * common_diff)
# formula for sum of series
- return sum
+ return total
def main():
diff --git a/maths/sum_of_digits.py b/maths/sum_of_digits.py
index 64da00d4634c..d5488bb9e9e0 100644
--- a/maths/sum_of_digits.py
+++ b/maths/sum_of_digits.py
@@ -1,10 +1,6 @@
-from timeit import timeit
-
-
def sum_of_digits(n: int) -> int:
"""
Find the sum of digits of a number.
-
>>> sum_of_digits(12345)
15
>>> sum_of_digits(123)
@@ -14,18 +10,17 @@ def sum_of_digits(n: int) -> int:
>>> sum_of_digits(0)
0
"""
- n = -n if n < 0 else n
+ n = abs(n)
res = 0
while n > 0:
res += n % 10
- n = n // 10
+ n //= 10
return res
def sum_of_digits_recursion(n: int) -> int:
"""
Find the sum of digits of a number using recursion
-
>>> sum_of_digits_recursion(12345)
15
>>> sum_of_digits_recursion(123)
@@ -35,14 +30,13 @@ def sum_of_digits_recursion(n: int) -> int:
>>> sum_of_digits_recursion(0)
0
"""
- n = -n if n < 0 else n
+ n = abs(n)
return n if n < 10 else n % 10 + sum_of_digits(n // 10)
def sum_of_digits_compact(n: int) -> int:
"""
Find the sum of digits of a number
-
>>> sum_of_digits_compact(12345)
15
>>> sum_of_digits_compact(123)
@@ -57,93 +51,24 @@ def sum_of_digits_compact(n: int) -> int:
def benchmark() -> None:
"""
- Benchmark code for comparing 3 functions,
- with 3 different length int values.
+ Benchmark multiple functions, with three different length int values.
"""
- print("\nFor small_num = ", small_num, ":")
- print(
- "> sum_of_digits()",
- "\t\tans =",
- sum_of_digits(small_num),
- "\ttime =",
- timeit("z.sum_of_digits(z.small_num)", setup="import __main__ as z"),
- "seconds",
- )
- print(
- "> sum_of_digits_recursion()",
- "\tans =",
- sum_of_digits_recursion(small_num),
- "\ttime =",
- timeit("z.sum_of_digits_recursion(z.small_num)", setup="import __main__ as z"),
- "seconds",
- )
- print(
- "> sum_of_digits_compact()",
- "\tans =",
- sum_of_digits_compact(small_num),
- "\ttime =",
- timeit("z.sum_of_digits_compact(z.small_num)", setup="import __main__ as z"),
- "seconds",
- )
+ from collections.abc import Callable
+ from timeit import timeit
- print("\nFor medium_num = ", medium_num, ":")
- print(
- "> sum_of_digits()",
- "\t\tans =",
- sum_of_digits(medium_num),
- "\ttime =",
- timeit("z.sum_of_digits(z.medium_num)", setup="import __main__ as z"),
- "seconds",
- )
- print(
- "> sum_of_digits_recursion()",
- "\tans =",
- sum_of_digits_recursion(medium_num),
- "\ttime =",
- timeit("z.sum_of_digits_recursion(z.medium_num)", setup="import __main__ as z"),
- "seconds",
- )
- print(
- "> sum_of_digits_compact()",
- "\tans =",
- sum_of_digits_compact(medium_num),
- "\ttime =",
- timeit("z.sum_of_digits_compact(z.medium_num)", setup="import __main__ as z"),
- "seconds",
- )
+ def benchmark_a_function(func: Callable, value: int) -> None:
+ call = f"{func.__name__}({value})"
+ timing = timeit(f"__main__.{call}", setup="import __main__")
+ print(f"{call:56} = {func(value)} -- {timing:.4f} seconds")
- print("\nFor large_num = ", large_num, ":")
- print(
- "> sum_of_digits()",
- "\t\tans =",
- sum_of_digits(large_num),
- "\ttime =",
- timeit("z.sum_of_digits(z.large_num)", setup="import __main__ as z"),
- "seconds",
- )
- print(
- "> sum_of_digits_recursion()",
- "\tans =",
- sum_of_digits_recursion(large_num),
- "\ttime =",
- timeit("z.sum_of_digits_recursion(z.large_num)", setup="import __main__ as z"),
- "seconds",
- )
- print(
- "> sum_of_digits_compact()",
- "\tans =",
- sum_of_digits_compact(large_num),
- "\ttime =",
- timeit("z.sum_of_digits_compact(z.large_num)", setup="import __main__ as z"),
- "seconds",
- )
+ for value in (262144, 1125899906842624, 1267650600228229401496703205376):
+ for func in (sum_of_digits, sum_of_digits_recursion, sum_of_digits_compact):
+ benchmark_a_function(func, value)
+ print()
if __name__ == "__main__":
- small_num = 262144
- medium_num = 1125899906842624
- large_num = 1267650600228229401496703205376
- benchmark()
import doctest
doctest.testmod()
+ benchmark()
diff --git a/maths/sum_of_geometric_progression.py b/maths/sum_of_geometric_progression.py
index f29dd8005cff..9079f35af6d9 100644
--- a/maths/sum_of_geometric_progression.py
+++ b/maths/sum_of_geometric_progression.py
@@ -25,4 +25,4 @@ def sum_of_geometric_progression(
return num_of_terms * first_term
# Formula for finding sum of n terms of a GeometricProgression
- return (first_term / (1 - common_ratio)) * (1 - common_ratio ** num_of_terms)
+ return (first_term / (1 - common_ratio)) * (1 - common_ratio**num_of_terms)
diff --git a/maths/sum_of_harmonic_series.py b/maths/sum_of_harmonic_series.py
new file mode 100644
index 000000000000..9e0d6b19b95a
--- /dev/null
+++ b/maths/sum_of_harmonic_series.py
@@ -0,0 +1,29 @@
+def sum_of_harmonic_progression(
+ first_term: float, common_difference: float, number_of_terms: int
+) -> float:
+ """
+ https://en.wikipedia.org/wiki/Harmonic_progression_(mathematics)
+
+ Find the sum of n terms in an harmonic progression. The calculation starts with the
+ first_term and loops adding the common difference of Arithmetic Progression by which
+ the given Harmonic Progression is linked.
+
+ >>> sum_of_harmonic_progression(1 / 2, 2, 2)
+ 0.75
+ >>> sum_of_harmonic_progression(1 / 5, 5, 5)
+ 0.45666666666666667
+ """
+ arithmetic_progression = [1 / first_term]
+ first_term = 1 / first_term
+ for _ in range(number_of_terms - 1):
+ first_term += common_difference
+ arithmetic_progression.append(first_term)
+ harmonic_series = [1 / step for step in arithmetic_progression]
+ return sum(harmonic_series)
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+ print(sum_of_harmonic_progression(1 / 2, 2, 2))
diff --git a/maths/sumset.py b/maths/sumset.py
new file mode 100644
index 000000000000..fa18f9e24b4c
--- /dev/null
+++ b/maths/sumset.py
@@ -0,0 +1,37 @@
+"""
+
+Calculates the SumSet of two sets of numbers (A and B)
+
+Source:
+ https://en.wikipedia.org/wiki/Sumset
+
+"""
+
+
+def sumset(set_a: set, set_b: set) -> set:
+ """
+ :param first set: a set of numbers
+ :param second set: a set of numbers
+ :return: the nth number in Sylvester's sequence
+
+ >>> sumset({1, 2, 3}, {4, 5, 6})
+ {5, 6, 7, 8, 9}
+
+ >>> sumset({1, 2, 3}, {4, 5, 6, 7})
+ {5, 6, 7, 8, 9, 10}
+
+ >>> sumset({1, 2, 3, 4}, 3)
+ Traceback (most recent call last):
+ ...
+ AssertionError: The input value of [set_b=3] is not a set
+ """
+ assert isinstance(set_a, set), f"The input value of [set_a={set_a}] is not a set"
+ assert isinstance(set_b, set), f"The input value of [set_b={set_b}] is not a set"
+
+ return {a + b for a in set_a for b in set_b}
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
diff --git a/maths/sylvester_sequence.py b/maths/sylvester_sequence.py
new file mode 100644
index 000000000000..607424c6a90b
--- /dev/null
+++ b/maths/sylvester_sequence.py
@@ -0,0 +1,44 @@
+"""
+
+Calculates the nth number in Sylvester's sequence
+
+Source:
+ https://en.wikipedia.org/wiki/Sylvester%27s_sequence
+
+"""
+
+
+def sylvester(number: int) -> int:
+ """
+ :param number: nth number to calculate in the sequence
+ :return: the nth number in Sylvester's sequence
+
+ >>> sylvester(8)
+ 113423713055421844361000443
+
+ >>> sylvester(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: The input value of [n=-1] has to be > 0
+
+ >>> sylvester(8.0)
+ Traceback (most recent call last):
+ ...
+ AssertionError: The input value of [n=8.0] is not an integer
+ """
+ assert isinstance(number, int), f"The input value of [n={number}] is not an integer"
+
+ if number == 1:
+ return 2
+ elif number < 1:
+ msg = f"The input value of [n={number}] has to be > 0"
+ raise ValueError(msg)
+ else:
+ num = sylvester(number - 1)
+ lower = num - 1
+ upper = num
+ return lower * upper + 1
+
+
+if __name__ == "__main__":
+ print(f"The 8th number in Sylvester's sequence: {sylvester(8)}")
diff --git a/maths/tanh.py b/maths/tanh.py
new file mode 100644
index 000000000000..011d6f17e22b
--- /dev/null
+++ b/maths/tanh.py
@@ -0,0 +1,43 @@
+"""
+This script demonstrates the implementation of the tangent hyperbolic
+or tanh function.
+
+The function takes a vector of K real numbers as input and
+then (e^x - e^(-x))/(e^x + e^(-x)). After through tanh, the
+element of the vector mostly -1 between 1.
+
+Script inspired from its corresponding Wikipedia article
+https://en.wikipedia.org/wiki/Activation_function
+"""
+
+import numpy as np
+
+
+def tangent_hyperbolic(vector: np.ndarray) -> np.ndarray:
+ """
+ Implements the tanh function
+
+ Parameters:
+ vector: np.ndarray
+
+ Returns:
+ tanh (np.array): The input numpy array after applying tanh.
+
+ mathematically (e^x - e^(-x))/(e^x + e^(-x)) can be written as (2/(1+e^(-2x))-1
+
+ Examples:
+ >>> tangent_hyperbolic(np.array([1,5,6,-0.67]))
+ array([ 0.76159416, 0.9999092 , 0.99998771, -0.58497988])
+
+ >>> tangent_hyperbolic(np.array([8,10,2,-0.98,13]))
+ array([ 0.99999977, 1. , 0.96402758, -0.7530659 , 1. ])
+
+ """
+
+ return (2 / (1 + np.exp(-2 * vector))) - 1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/test_prime_check.py b/maths/test_prime_check.py
index b6389684af9e..3ea3b2f1f88b 100644
--- a/maths/test_prime_check.py
+++ b/maths/test_prime_check.py
@@ -1,6 +1,6 @@
"""
Minimalist file that allows pytest to find and run the Test unittest. For details, see:
-http://doc.pytest.org/en/latest/goodpractices.html#conventions-for-python-test-discovery
+https://doc.pytest.org/en/latest/goodpractices.html#conventions-for-python-test-discovery
"""
from .prime_check import Test
diff --git a/maths/three_sum.py b/maths/three_sum.py
new file mode 100644
index 000000000000..09956f8415a0
--- /dev/null
+++ b/maths/three_sum.py
@@ -0,0 +1,47 @@
+"""
+https://en.wikipedia.org/wiki/3SUM
+"""
+
+
+def three_sum(nums: list[int]) -> list[list[int]]:
+ """
+ Find all unique triplets in a sorted array of integers that sum up to zero.
+
+ Args:
+ nums: A sorted list of integers.
+
+ Returns:
+ A list of lists containing unique triplets that sum up to zero.
+
+ >>> three_sum([-1, 0, 1, 2, -1, -4])
+ [[-1, -1, 2], [-1, 0, 1]]
+ >>> three_sum([1, 2, 3, 4])
+ []
+ """
+ nums.sort()
+ ans = []
+ for i in range(len(nums) - 2):
+ if i == 0 or (nums[i] != nums[i - 1]):
+ low, high, c = i + 1, len(nums) - 1, 0 - nums[i]
+ while low < high:
+ if nums[low] + nums[high] == c:
+ ans.append([nums[i], nums[low], nums[high]])
+
+ while low < high and nums[low] == nums[low + 1]:
+ low += 1
+ while low < high and nums[high] == nums[high - 1]:
+ high -= 1
+
+ low += 1
+ high -= 1
+ elif nums[low] + nums[high] < c:
+ low += 1
+ else:
+ high -= 1
+ return ans
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/trapezoidal_rule.py b/maths/trapezoidal_rule.py
index 9a4ddc8af66b..21b10b239b5f 100644
--- a/maths/trapezoidal_rule.py
+++ b/maths/trapezoidal_rule.py
@@ -1,17 +1,26 @@
"""
Numerical integration or quadrature for a smooth function f with known values at x_i
+"""
-This method is the classical approach of suming 'Equally Spaced Abscissas'
-
-method 1:
-"extended trapezoidal rule"
-"""
+def trapezoidal_rule(boundary, steps):
+ """
+ Implements the extended trapezoidal rule for numerical integration.
+ The function f(x) is provided below.
+ :param boundary: List containing the lower and upper bounds of integration [a, b]
+ :param steps: The number of steps (intervals) used in the approximation
+ :return: The numerical approximation of the integral
-def method_1(boundary, steps):
- # "extended trapezoidal rule"
- # int(f) = dx/2 * (f1 + 2f2 + ... + fn)
+ >>> abs(trapezoidal_rule([0, 1], 10) - 0.33333) < 0.01
+ True
+ >>> abs(trapezoidal_rule([0, 1], 100) - 0.33333) < 0.01
+ True
+ >>> abs(trapezoidal_rule([0, 2], 1000) - 2.66667) < 0.01
+ True
+ >>> abs(trapezoidal_rule([1, 2], 1000) - 2.33333) < 0.01
+ True
+ """
h = (boundary[1] - boundary[0]) / steps
a = boundary[0]
b = boundary[1]
@@ -19,32 +28,78 @@ def method_1(boundary, steps):
y = 0.0
y += (h / 2.0) * f(a)
for i in x_i:
- # print(i)
y += h * f(i)
y += (h / 2.0) * f(b)
return y
def make_points(a, b, h):
+ """
+ Generates points between a and b with step size h for trapezoidal integration.
+
+ :param a: The lower bound of integration
+ :param b: The upper bound of integration
+ :param h: The step size
+ :yield: The next x-value in the range (a, b)
+
+ >>> list(make_points(0, 1, 0.1)) # doctest: +NORMALIZE_WHITESPACE
+ [0.1, 0.2, 0.30000000000000004, 0.4, 0.5, 0.6, 0.7, 0.7999999999999999, \
+ 0.8999999999999999]
+ >>> list(make_points(0, 10, 2.5))
+ [2.5, 5.0, 7.5]
+ >>> list(make_points(0, 10, 2))
+ [2, 4, 6, 8]
+ >>> list(make_points(1, 21, 5))
+ [6, 11, 16]
+ >>> list(make_points(1, 5, 2))
+ [3]
+ >>> list(make_points(1, 4, 3))
+ []
+ """
x = a + h
- while x < (b - h):
+ while x <= (b - h):
yield x
- x = x + h
+ x += h
-def f(x): # enter your function here
- y = (x - 0) * (x - 0)
- return y
+def f(x):
+ """
+ This is the function to integrate, f(x) = (x - 0)^2 = x^2.
+
+ :param x: The input value
+ :return: The value of f(x)
+
+ >>> f(0)
+ 0
+ >>> f(1)
+ 1
+ >>> f(0.5)
+ 0.25
+ """
+ return x**2
def main():
- a = 0.0 # Lower bound of integration
- b = 1.0 # Upper bound of integration
- steps = 10.0 # define number of steps or resolution
- boundary = [a, b] # define boundary of integration
- y = method_1(boundary, steps)
+ """
+ Main function to test the trapezoidal rule.
+ :a: Lower bound of integration
+ :b: Upper bound of integration
+ :steps: define number of steps or resolution
+ :boundary: define boundary of integration
+
+ >>> main()
+ y = 0.3349999999999999
+ """
+ a = 0.0
+ b = 1.0
+ steps = 10.0
+ boundary = [a, b]
+ y = trapezoidal_rule(boundary, steps)
print(f"y = {y}")
if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
main()
diff --git a/other/triplet_sum.py b/maths/triplet_sum.py
similarity index 93%
rename from other/triplet_sum.py
rename to maths/triplet_sum.py
index 0e78bb52bb72..e74f67daad47 100644
--- a/other/triplet_sum.py
+++ b/maths/triplet_sum.py
@@ -1,89 +1,90 @@
-"""
-Given an array of integers and another integer target,
-we are required to find a triplet from the array such that it's sum is equal to
-the target.
-"""
-from __future__ import annotations
-
-from itertools import permutations
-from random import randint
-from timeit import repeat
-
-
-def make_dataset() -> tuple[list[int], int]:
- arr = [randint(-1000, 1000) for i in range(10)]
- r = randint(-5000, 5000)
- return (arr, r)
-
-
-dataset = make_dataset()
-
-
-def triplet_sum1(arr: list[int], target: int) -> tuple[int, int, int]:
- """
- Returns a triplet in the array with sum equal to target,
- else (0, 0, 0).
- >>> triplet_sum1([13, 29, 7, 23, 5], 35)
- (5, 7, 23)
- >>> triplet_sum1([37, 9, 19, 50, 44], 65)
- (9, 19, 37)
- >>> arr = [6, 47, 27, 1, 15]
- >>> target = 11
- >>> triplet_sum1(arr, target)
- (0, 0, 0)
- """
- for triplet in permutations(arr, 3):
- if sum(triplet) == target:
- return tuple(sorted(triplet))
- return (0, 0, 0)
-
-
-def triplet_sum2(arr: list[int], target: int) -> tuple[int, int, int]:
- """
- Returns a triplet in the array with sum equal to target,
- else (0, 0, 0).
- >>> triplet_sum2([13, 29, 7, 23, 5], 35)
- (5, 7, 23)
- >>> triplet_sum2([37, 9, 19, 50, 44], 65)
- (9, 19, 37)
- >>> arr = [6, 47, 27, 1, 15]
- >>> target = 11
- >>> triplet_sum2(arr, target)
- (0, 0, 0)
- """
- arr.sort()
- n = len(arr)
- for i in range(n - 1):
- left, right = i + 1, n - 1
- while left < right:
- if arr[i] + arr[left] + arr[right] == target:
- return (arr[i], arr[left], arr[right])
- elif arr[i] + arr[left] + arr[right] < target:
- left += 1
- elif arr[i] + arr[left] + arr[right] > target:
- right -= 1
- return (0, 0, 0)
-
-
-def solution_times() -> tuple[float, float]:
- setup_code = """
-from __main__ import dataset, triplet_sum1, triplet_sum2
-"""
- test_code1 = """
-triplet_sum1(*dataset)
-"""
- test_code2 = """
-triplet_sum2(*dataset)
-"""
- times1 = repeat(setup=setup_code, stmt=test_code1, repeat=5, number=10000)
- times2 = repeat(setup=setup_code, stmt=test_code2, repeat=5, number=10000)
- return (min(times1), min(times2))
-
-
-if __name__ == "__main__":
- from doctest import testmod
-
- testmod()
- times = solution_times()
- print(f"The time for naive implementation is {times[0]}.")
- print(f"The time for optimized implementation is {times[1]}.")
+"""
+Given an array of integers and another integer target,
+we are required to find a triplet from the array such that it's sum is equal to
+the target.
+"""
+
+from __future__ import annotations
+
+from itertools import permutations
+from random import randint
+from timeit import repeat
+
+
+def make_dataset() -> tuple[list[int], int]:
+ arr = [randint(-1000, 1000) for i in range(10)]
+ r = randint(-5000, 5000)
+ return (arr, r)
+
+
+dataset = make_dataset()
+
+
+def triplet_sum1(arr: list[int], target: int) -> tuple[int, ...]:
+ """
+ Returns a triplet in the array with sum equal to target,
+ else (0, 0, 0).
+ >>> triplet_sum1([13, 29, 7, 23, 5], 35)
+ (5, 7, 23)
+ >>> triplet_sum1([37, 9, 19, 50, 44], 65)
+ (9, 19, 37)
+ >>> arr = [6, 47, 27, 1, 15]
+ >>> target = 11
+ >>> triplet_sum1(arr, target)
+ (0, 0, 0)
+ """
+ for triplet in permutations(arr, 3):
+ if sum(triplet) == target:
+ return tuple(sorted(triplet))
+ return (0, 0, 0)
+
+
+def triplet_sum2(arr: list[int], target: int) -> tuple[int, int, int]:
+ """
+ Returns a triplet in the array with sum equal to target,
+ else (0, 0, 0).
+ >>> triplet_sum2([13, 29, 7, 23, 5], 35)
+ (5, 7, 23)
+ >>> triplet_sum2([37, 9, 19, 50, 44], 65)
+ (9, 19, 37)
+ >>> arr = [6, 47, 27, 1, 15]
+ >>> target = 11
+ >>> triplet_sum2(arr, target)
+ (0, 0, 0)
+ """
+ arr.sort()
+ n = len(arr)
+ for i in range(n - 1):
+ left, right = i + 1, n - 1
+ while left < right:
+ if arr[i] + arr[left] + arr[right] == target:
+ return (arr[i], arr[left], arr[right])
+ elif arr[i] + arr[left] + arr[right] < target:
+ left += 1
+ elif arr[i] + arr[left] + arr[right] > target:
+ right -= 1
+ return (0, 0, 0)
+
+
+def solution_times() -> tuple[float, float]:
+ setup_code = """
+from __main__ import dataset, triplet_sum1, triplet_sum2
+"""
+ test_code1 = """
+triplet_sum1(*dataset)
+"""
+ test_code2 = """
+triplet_sum2(*dataset)
+"""
+ times1 = repeat(setup=setup_code, stmt=test_code1, repeat=5, number=10000)
+ times2 = repeat(setup=setup_code, stmt=test_code2, repeat=5, number=10000)
+ return (min(times1), min(times2))
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
+ times = solution_times()
+ print(f"The time for naive implementation is {times[0]}.")
+ print(f"The time for optimized implementation is {times[1]}.")
diff --git a/maths/twin_prime.py b/maths/twin_prime.py
new file mode 100644
index 000000000000..912b10b366c0
--- /dev/null
+++ b/maths/twin_prime.py
@@ -0,0 +1,46 @@
+"""
+== Twin Prime ==
+A number n+2 is said to be a Twin prime of number n if
+both n and n+2 are prime.
+
+Examples of Twin pairs: (3, 5), (5, 7), (11, 13), (17, 19), (29, 31), (41, 43), ...
+https://en.wikipedia.org/wiki/Twin_prime
+"""
+
+# Author : Akshay Dubey (https://github.com/itsAkshayDubey)
+from maths.prime_check import is_prime
+
+
+def twin_prime(number: int) -> int:
+ """
+ # doctest: +NORMALIZE_WHITESPACE
+ This functions takes an integer number as input.
+ returns n+2 if n and n+2 are prime numbers and -1 otherwise.
+ >>> twin_prime(3)
+ 5
+ >>> twin_prime(4)
+ -1
+ >>> twin_prime(5)
+ 7
+ >>> twin_prime(17)
+ 19
+ >>> twin_prime(0)
+ -1
+ >>> twin_prime(6.0)
+ Traceback (most recent call last):
+ ...
+ TypeError: Input value of [number=6.0] must be an integer
+ """
+ if not isinstance(number, int):
+ msg = f"Input value of [number={number}] must be an integer"
+ raise TypeError(msg)
+ if is_prime(number) and is_prime(number + 2):
+ return number + 2
+ else:
+ return -1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/other/two_pointer.py b/maths/two_pointer.py
similarity index 100%
rename from other/two_pointer.py
rename to maths/two_pointer.py
index ff234cddc9e4..8a6d8eb7aff0 100644
--- a/other/two_pointer.py
+++ b/maths/two_pointer.py
@@ -17,6 +17,7 @@
[1]: https://github.com/TheAlgorithms/Python/blob/master/other/two_sum.py
"""
+
from __future__ import annotations
@@ -43,7 +44,6 @@ def two_pointer(nums: list[int], target: int) -> list[int]:
j = len(nums) - 1
while i < j:
-
if nums[i] + nums[j] == target:
return [i, j]
elif nums[i] + nums[j] < target:
diff --git a/other/two_sum.py b/maths/two_sum.py
similarity index 96%
rename from other/two_sum.py
rename to maths/two_sum.py
index 5209acbc7e44..58c933a5078a 100644
--- a/other/two_sum.py
+++ b/maths/two_sum.py
@@ -11,6 +11,7 @@
Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].
"""
+
from __future__ import annotations
@@ -31,7 +32,7 @@ def two_sum(nums: list[int], target: int) -> list[int]:
>>> two_sum([3 * i for i in range(10)], 19)
[]
"""
- chk_map = {}
+ chk_map: dict[int, int] = {}
for index, val in enumerate(nums):
compl = target - val
if compl in chk_map:
diff --git a/maths/volume.py b/maths/volume.py
index 41d2331db3cb..08bdf72b013b 100644
--- a/maths/volume.py
+++ b/maths/volume.py
@@ -1,13 +1,16 @@
"""
-Find Volumes of Various Shapes.
+Find the volume of various shapes.
-Wikipedia reference: https://en.wikipedia.org/wiki/Volume
+* https://en.wikipedia.org/wiki/Volume
+* https://en.wikipedia.org/wiki/Spherical_cap
"""
-from math import pi, pow
-from typing import Union
+from __future__ import annotations
-def vol_cube(side_length: Union[int, float]) -> float:
+from math import pi, pow # noqa: A004
+
+
+def vol_cube(side_length: float) -> float:
"""
Calculate the Volume of a Cube.
@@ -15,117 +18,549 @@ def vol_cube(side_length: Union[int, float]) -> float:
1.0
>>> vol_cube(3)
27.0
+ >>> vol_cube(0)
+ 0.0
+ >>> vol_cube(1.6)
+ 4.096000000000001
+ >>> vol_cube(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_cube() only accepts non-negative values
"""
+ if side_length < 0:
+ raise ValueError("vol_cube() only accepts non-negative values")
return pow(side_length, 3)
+def vol_spherical_cap(height: float, radius: float) -> float:
+ """
+ Calculate the volume of the spherical cap.
+
+ >>> vol_spherical_cap(1, 2)
+ 5.235987755982988
+ >>> vol_spherical_cap(1.6, 2.6)
+ 16.621119532592402
+ >>> vol_spherical_cap(0, 0)
+ 0.0
+ >>> vol_spherical_cap(-1, 2)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_spherical_cap() only accepts non-negative values
+ >>> vol_spherical_cap(1, -2)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_spherical_cap() only accepts non-negative values
+ """
+ if height < 0 or radius < 0:
+ raise ValueError("vol_spherical_cap() only accepts non-negative values")
+ # Volume is 1/3 pi * height squared * (3 * radius - height)
+ return 1 / 3 * pi * pow(height, 2) * (3 * radius - height)
+
+
+def vol_spheres_intersect(
+ radius_1: float, radius_2: float, centers_distance: float
+) -> float:
+ r"""
+ Calculate the volume of the intersection of two spheres.
+
+ The intersection is composed by two spherical caps and therefore its volume is the
+ sum of the volumes of the spherical caps.
+ First, it calculates the heights :math:`(h_1, h_2)` of the spherical caps,
+ then the two volumes and it returns the sum.
+ The height formulas are
+
+ .. math::
+ h_1 = \frac{(radius_1 - radius_2 + centers\_distance)
+ \cdot (radius_1 + radius_2 - centers\_distance)}
+ {2 \cdot centers\_distance}
+
+ h_2 = \frac{(radius_2 - radius_1 + centers\_distance)
+ \cdot (radius_2 + radius_1 - centers\_distance)}
+ {2 \cdot centers\_distance}
+
+ if `centers_distance` is 0 then it returns the volume of the smallers sphere
+
+ :return: ``vol_spherical_cap`` (:math:`h_1`, :math:`radius_2`)
+ + ``vol_spherical_cap`` (:math:`h_2`, :math:`radius_1`)
+
+ >>> vol_spheres_intersect(2, 2, 1)
+ 21.205750411731103
+ >>> vol_spheres_intersect(2.6, 2.6, 1.6)
+ 40.71504079052372
+ >>> vol_spheres_intersect(0, 0, 0)
+ 0.0
+ >>> vol_spheres_intersect(-2, 2, 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_spheres_intersect() only accepts non-negative values
+ >>> vol_spheres_intersect(2, -2, 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_spheres_intersect() only accepts non-negative values
+ >>> vol_spheres_intersect(2, 2, -1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_spheres_intersect() only accepts non-negative values
+ """
+ if radius_1 < 0 or radius_2 < 0 or centers_distance < 0:
+ raise ValueError("vol_spheres_intersect() only accepts non-negative values")
+ if centers_distance == 0:
+ return vol_sphere(min(radius_1, radius_2))
+
+ h1 = (
+ (radius_1 - radius_2 + centers_distance)
+ * (radius_1 + radius_2 - centers_distance)
+ / (2 * centers_distance)
+ )
+ h2 = (
+ (radius_2 - radius_1 + centers_distance)
+ * (radius_2 + radius_1 - centers_distance)
+ / (2 * centers_distance)
+ )
+
+ return vol_spherical_cap(h1, radius_2) + vol_spherical_cap(h2, radius_1)
+
+
+def vol_spheres_union(
+ radius_1: float, radius_2: float, centers_distance: float
+) -> float:
+ r"""
+ Calculate the volume of the union of two spheres that possibly intersect.
+
+ It is the sum of sphere :math:`A` and sphere :math:`B` minus their intersection.
+ First, it calculates the volumes :math:`(v_1, v_2)` of the spheres,
+ then the volume of the intersection :math:`i` and
+ it returns the sum :math:`v_1 + v_2 - i`.
+ If `centers_distance` is 0 then it returns the volume of the larger sphere
+
+ :return: ``vol_sphere`` (:math:`radius_1`) + ``vol_sphere`` (:math:`radius_2`)
+ - ``vol_spheres_intersect``
+ (:math:`radius_1`, :math:`radius_2`, :math:`centers\_distance`)
+
+ >>> vol_spheres_union(2, 2, 1)
+ 45.814892864851146
+ >>> vol_spheres_union(1.56, 2.2, 1.4)
+ 48.77802773671288
+ >>> vol_spheres_union(0, 2, 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_spheres_union() only accepts non-negative values, non-zero radius
+ >>> vol_spheres_union('1.56', '2.2', '1.4')
+ Traceback (most recent call last):
+ ...
+ TypeError: '<=' not supported between instances of 'str' and 'int'
+ >>> vol_spheres_union(1, None, 1)
+ Traceback (most recent call last):
+ ...
+ TypeError: '<=' not supported between instances of 'NoneType' and 'int'
+ """
+
+ if radius_1 <= 0 or radius_2 <= 0 or centers_distance < 0:
+ raise ValueError(
+ "vol_spheres_union() only accepts non-negative values, non-zero radius"
+ )
+
+ if centers_distance == 0:
+ return vol_sphere(max(radius_1, radius_2))
+
+ return (
+ vol_sphere(radius_1)
+ + vol_sphere(radius_2)
+ - vol_spheres_intersect(radius_1, radius_2, centers_distance)
+ )
+
+
def vol_cuboid(width: float, height: float, length: float) -> float:
"""
Calculate the Volume of a Cuboid.
- :return multiple of width, length and height
+
+ :return: multiple of `width`, `length` and `height`
>>> vol_cuboid(1, 1, 1)
1.0
>>> vol_cuboid(1, 2, 3)
6.0
+ >>> vol_cuboid(1.6, 2.6, 3.6)
+ 14.976
+ >>> vol_cuboid(0, 0, 0)
+ 0.0
+ >>> vol_cuboid(-1, 2, 3)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_cuboid() only accepts non-negative values
+ >>> vol_cuboid(1, -2, 3)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_cuboid() only accepts non-negative values
+ >>> vol_cuboid(1, 2, -3)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_cuboid() only accepts non-negative values
"""
+ if width < 0 or height < 0 or length < 0:
+ raise ValueError("vol_cuboid() only accepts non-negative values")
return float(width * height * length)
def vol_cone(area_of_base: float, height: float) -> float:
- """
- Calculate the Volume of a Cone.
+ r"""
+ | Calculate the Volume of a Cone.
+ | Wikipedia reference: https://en.wikipedia.org/wiki/Cone
- Wikipedia reference: https://en.wikipedia.org/wiki/Cone
- :return (1/3) * area_of_base * height
+ :return: :math:`\frac{1}{3} \cdot area\_of\_base \cdot height`
>>> vol_cone(10, 3)
10.0
>>> vol_cone(1, 1)
0.3333333333333333
+ >>> vol_cone(1.6, 1.6)
+ 0.8533333333333335
+ >>> vol_cone(0, 0)
+ 0.0
+ >>> vol_cone(-1, 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_cone() only accepts non-negative values
+ >>> vol_cone(1, -1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_cone() only accepts non-negative values
"""
+ if height < 0 or area_of_base < 0:
+ raise ValueError("vol_cone() only accepts non-negative values")
return area_of_base * height / 3.0
def vol_right_circ_cone(radius: float, height: float) -> float:
- """
- Calculate the Volume of a Right Circular Cone.
+ r"""
+ | Calculate the Volume of a Right Circular Cone.
+ | Wikipedia reference: https://en.wikipedia.org/wiki/Cone
- Wikipedia reference: https://en.wikipedia.org/wiki/Cone
- :return (1/3) * pi * radius^2 * height
+ :return: :math:`\frac{1}{3} \cdot \pi \cdot radius^2 \cdot height`
>>> vol_right_circ_cone(2, 3)
12.566370614359172
+ >>> vol_right_circ_cone(0, 0)
+ 0.0
+ >>> vol_right_circ_cone(1.6, 1.6)
+ 4.289321169701265
+ >>> vol_right_circ_cone(-1, 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_right_circ_cone() only accepts non-negative values
+ >>> vol_right_circ_cone(1, -1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_right_circ_cone() only accepts non-negative values
"""
+ if height < 0 or radius < 0:
+ raise ValueError("vol_right_circ_cone() only accepts non-negative values")
return pi * pow(radius, 2) * height / 3.0
def vol_prism(area_of_base: float, height: float) -> float:
- """
- Calculate the Volume of a Prism.
- Wikipedia reference: https://en.wikipedia.org/wiki/Prism_(geometry)
- :return V = Bh
+ r"""
+ | Calculate the Volume of a Prism.
+ | Wikipedia reference: https://en.wikipedia.org/wiki/Prism_(geometry)
+
+ :return: :math:`V = B \cdot h`
>>> vol_prism(10, 2)
20.0
>>> vol_prism(11, 1)
11.0
+ >>> vol_prism(1.6, 1.6)
+ 2.5600000000000005
+ >>> vol_prism(0, 0)
+ 0.0
+ >>> vol_prism(-1, 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_prism() only accepts non-negative values
+ >>> vol_prism(1, -1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_prism() only accepts non-negative values
"""
+ if height < 0 or area_of_base < 0:
+ raise ValueError("vol_prism() only accepts non-negative values")
return float(area_of_base * height)
def vol_pyramid(area_of_base: float, height: float) -> float:
- """
- Calculate the Volume of a Pyramid.
- Wikipedia reference: https://en.wikipedia.org/wiki/Pyramid_(geometry)
- :return (1/3) * Bh
+ r"""
+ | Calculate the Volume of a Pyramid.
+ | Wikipedia reference: https://en.wikipedia.org/wiki/Pyramid_(geometry)
+
+ :return: :math:`\frac{1}{3} \cdot B \cdot h`
>>> vol_pyramid(10, 3)
10.0
>>> vol_pyramid(1.5, 3)
1.5
+ >>> vol_pyramid(1.6, 1.6)
+ 0.8533333333333335
+ >>> vol_pyramid(0, 0)
+ 0.0
+ >>> vol_pyramid(-1, 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_pyramid() only accepts non-negative values
+ >>> vol_pyramid(1, -1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_pyramid() only accepts non-negative values
"""
+ if height < 0 or area_of_base < 0:
+ raise ValueError("vol_pyramid() only accepts non-negative values")
return area_of_base * height / 3.0
def vol_sphere(radius: float) -> float:
- """
- Calculate the Volume of a Sphere.
- Wikipedia reference: https://en.wikipedia.org/wiki/Sphere
- :return (4/3) * pi * r^3
+ r"""
+ | Calculate the Volume of a Sphere.
+ | Wikipedia reference: https://en.wikipedia.org/wiki/Sphere
+
+ :return: :math:`\frac{4}{3} \cdot \pi \cdot r^3`
>>> vol_sphere(5)
523.5987755982989
>>> vol_sphere(1)
4.1887902047863905
+ >>> vol_sphere(1.6)
+ 17.15728467880506
+ >>> vol_sphere(0)
+ 0.0
+ >>> vol_sphere(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_sphere() only accepts non-negative values
"""
+ if radius < 0:
+ raise ValueError("vol_sphere() only accepts non-negative values")
+ # Volume is 4/3 * pi * radius cubed
return 4 / 3 * pi * pow(radius, 3)
+def vol_hemisphere(radius: float) -> float:
+ r"""
+ | Calculate the volume of a hemisphere
+ | Wikipedia reference: https://en.wikipedia.org/wiki/Hemisphere
+ | Other references: https://www.cuemath.com/geometry/hemisphere
+
+ :return: :math:`\frac{2}{3} \cdot \pi \cdot radius^3`
+
+ >>> vol_hemisphere(1)
+ 2.0943951023931953
+ >>> vol_hemisphere(7)
+ 718.377520120866
+ >>> vol_hemisphere(1.6)
+ 8.57864233940253
+ >>> vol_hemisphere(0)
+ 0.0
+ >>> vol_hemisphere(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_hemisphere() only accepts non-negative values
+ """
+ if radius < 0:
+ raise ValueError("vol_hemisphere() only accepts non-negative values")
+ # Volume is radius cubed * pi * 2/3
+ return pow(radius, 3) * pi * 2 / 3
+
+
def vol_circular_cylinder(radius: float, height: float) -> float:
- """Calculate the Volume of a Circular Cylinder.
- Wikipedia reference: https://en.wikipedia.org/wiki/Cylinder
- :return pi * radius^2 * height
+ r"""
+ | Calculate the Volume of a Circular Cylinder.
+ | Wikipedia reference: https://en.wikipedia.org/wiki/Cylinder
+
+ :return: :math:`\pi \cdot radius^2 \cdot height`
>>> vol_circular_cylinder(1, 1)
3.141592653589793
>>> vol_circular_cylinder(4, 3)
150.79644737231007
+ >>> vol_circular_cylinder(1.6, 1.6)
+ 12.867963509103795
+ >>> vol_circular_cylinder(0, 0)
+ 0.0
+ >>> vol_circular_cylinder(-1, 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_circular_cylinder() only accepts non-negative values
+ >>> vol_circular_cylinder(1, -1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_circular_cylinder() only accepts non-negative values
+ """
+ if height < 0 or radius < 0:
+ raise ValueError("vol_circular_cylinder() only accepts non-negative values")
+ # Volume is radius squared * height * pi
+ return pow(radius, 2) * height * pi
+
+
+def vol_hollow_circular_cylinder(
+ inner_radius: float, outer_radius: float, height: float
+) -> float:
+ """
+ Calculate the Volume of a Hollow Circular Cylinder.
+
+ >>> vol_hollow_circular_cylinder(1, 2, 3)
+ 28.274333882308138
+ >>> vol_hollow_circular_cylinder(1.6, 2.6, 3.6)
+ 47.50088092227767
+ >>> vol_hollow_circular_cylinder(-1, 2, 3)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_hollow_circular_cylinder() only accepts non-negative values
+ >>> vol_hollow_circular_cylinder(1, -2, 3)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_hollow_circular_cylinder() only accepts non-negative values
+ >>> vol_hollow_circular_cylinder(1, 2, -3)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_hollow_circular_cylinder() only accepts non-negative values
+ >>> vol_hollow_circular_cylinder(2, 1, 3)
+ Traceback (most recent call last):
+ ...
+ ValueError: outer_radius must be greater than inner_radius
+ >>> vol_hollow_circular_cylinder(0, 0, 0)
+ Traceback (most recent call last):
+ ...
+ ValueError: outer_radius must be greater than inner_radius
+ """
+ # Volume - (outer_radius squared - inner_radius squared) * pi * height
+ if inner_radius < 0 or outer_radius < 0 or height < 0:
+ raise ValueError(
+ "vol_hollow_circular_cylinder() only accepts non-negative values"
+ )
+ if outer_radius <= inner_radius:
+ raise ValueError("outer_radius must be greater than inner_radius")
+ return pi * (pow(outer_radius, 2) - pow(inner_radius, 2)) * height
+
+
+def vol_conical_frustum(height: float, radius_1: float, radius_2: float) -> float:
+ """
+ | Calculate the Volume of a Conical Frustum.
+ | Wikipedia reference: https://en.wikipedia.org/wiki/Frustum
+
+ >>> vol_conical_frustum(45, 7, 28)
+ 48490.482608158454
+ >>> vol_conical_frustum(1, 1, 2)
+ 7.330382858376184
+ >>> vol_conical_frustum(1.6, 2.6, 3.6)
+ 48.7240076620753
+ >>> vol_conical_frustum(0, 0, 0)
+ 0.0
+ >>> vol_conical_frustum(-2, 2, 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_conical_frustum() only accepts non-negative values
+ >>> vol_conical_frustum(2, -2, 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_conical_frustum() only accepts non-negative values
+ >>> vol_conical_frustum(2, 2, -1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_conical_frustum() only accepts non-negative values
+ """
+ # Volume is 1/3 * pi * height *
+ # (radius_1 squared + radius_2 squared + radius_1 * radius_2)
+ if radius_1 < 0 or radius_2 < 0 or height < 0:
+ raise ValueError("vol_conical_frustum() only accepts non-negative values")
+ return (
+ 1
+ / 3
+ * pi
+ * height
+ * (pow(radius_1, 2) + pow(radius_2, 2) + radius_1 * radius_2)
+ )
+
+
+def vol_torus(torus_radius: float, tube_radius: float) -> float:
+ r"""
+ | Calculate the Volume of a Torus.
+ | Wikipedia reference: https://en.wikipedia.org/wiki/Torus
+
+ :return: :math:`2 \pi^2 \cdot torus\_radius \cdot tube\_radius^2`
+
+ >>> vol_torus(1, 1)
+ 19.739208802178716
+ >>> vol_torus(4, 3)
+ 710.6115168784338
+ >>> vol_torus(3, 4)
+ 947.4820225045784
+ >>> vol_torus(1.6, 1.6)
+ 80.85179925372404
+ >>> vol_torus(0, 0)
+ 0.0
+ >>> vol_torus(-1, 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_torus() only accepts non-negative values
+ >>> vol_torus(1, -1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_torus() only accepts non-negative values
+ """
+ if torus_radius < 0 or tube_radius < 0:
+ raise ValueError("vol_torus() only accepts non-negative values")
+ return 2 * pow(pi, 2) * torus_radius * pow(tube_radius, 2)
+
+
+def vol_icosahedron(tri_side: float) -> float:
+ """
+ | Calculate the Volume of an Icosahedron.
+ | Wikipedia reference: https://en.wikipedia.org/wiki/Regular_icosahedron
+
+ >>> from math import isclose
+ >>> isclose(vol_icosahedron(2.5), 34.088984228514256)
+ True
+ >>> isclose(vol_icosahedron(10), 2181.694990624912374)
+ True
+ >>> isclose(vol_icosahedron(5), 272.711873828114047)
+ True
+ >>> isclose(vol_icosahedron(3.49), 92.740688412033628)
+ True
+ >>> vol_icosahedron(0)
+ 0.0
+ >>> vol_icosahedron(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_icosahedron() only accepts non-negative values
+ >>> vol_icosahedron(-0.2)
+ Traceback (most recent call last):
+ ...
+ ValueError: vol_icosahedron() only accepts non-negative values
"""
- return pi * pow(radius, 2) * height
+ if tri_side < 0:
+ raise ValueError("vol_icosahedron() only accepts non-negative values")
+ return tri_side**3 * (3 + 5**0.5) * 5 / 12
def main():
"""Print the Results of Various Volume Calculations."""
print("Volumes:")
- print("Cube: " + str(vol_cube(2))) # = 8
- print("Cuboid: " + str(vol_cuboid(2, 2, 2))) # = 8
- print("Cone: " + str(vol_cone(2, 2))) # ~= 1.33
- print("Right Circular Cone: " + str(vol_right_circ_cone(2, 2))) # ~= 8.38
- print("Prism: " + str(vol_prism(2, 2))) # = 4
- print("Pyramid: " + str(vol_pyramid(2, 2))) # ~= 1.33
- print("Sphere: " + str(vol_sphere(2))) # ~= 33.5
- print("Circular Cylinder: " + str(vol_circular_cylinder(2, 2))) # ~= 25.1
+ print(f"Cube: {vol_cube(2) = }") # = 8
+ print(f"Cuboid: {vol_cuboid(2, 2, 2) = }") # = 8
+ print(f"Cone: {vol_cone(2, 2) = }") # ~= 1.33
+ print(f"Right Circular Cone: {vol_right_circ_cone(2, 2) = }") # ~= 8.38
+ print(f"Prism: {vol_prism(2, 2) = }") # = 4
+ print(f"Pyramid: {vol_pyramid(2, 2) = }") # ~= 1.33
+ print(f"Sphere: {vol_sphere(2) = }") # ~= 33.5
+ print(f"Hemisphere: {vol_hemisphere(2) = }") # ~= 16.75
+ print(f"Circular Cylinder: {vol_circular_cylinder(2, 2) = }") # ~= 25.1
+ print(f"Torus: {vol_torus(2, 2) = }") # ~= 157.9
+ print(f"Conical Frustum: {vol_conical_frustum(2, 2, 4) = }") # ~= 58.6
+ print(f"Spherical cap: {vol_spherical_cap(1, 2) = }") # ~= 5.24
+ print(f"Spheres intersetion: {vol_spheres_intersect(2, 2, 1) = }") # ~= 21.21
+ print(f"Spheres union: {vol_spheres_union(2, 2, 1) = }") # ~= 45.81
+ print(
+ f"Hollow Circular Cylinder: {vol_hollow_circular_cylinder(1, 2, 3) = }"
+ ) # ~= 28.3
+ print(f"Icosahedron: {vol_icosahedron(2.5) = }") # ~=34.09
if __name__ == "__main__":
diff --git a/maths/zellers_congruence.py b/maths/zellers_congruence.py
index 2d4a22a0a5ba..b958ed3b8659 100644
--- a/maths/zellers_congruence.py
+++ b/maths/zellers_congruence.py
@@ -3,25 +3,26 @@
def zeller(date_input: str) -> str:
-
"""
- Zellers Congruence Algorithm
- Find the day of the week for nearly any Gregorian or Julian calendar date
+ | Zellers Congruence Algorithm
+ | Find the day of the week for nearly any Gregorian or Julian calendar date
>>> zeller('01-31-2010')
'Your date 01-31-2010, is a Sunday!'
- Validate out of range month
+ Validate out of range month:
+
>>> zeller('13-31-2010')
Traceback (most recent call last):
- ...
+ ...
ValueError: Month must be between 1 - 12
>>> zeller('.2-31-2010')
Traceback (most recent call last):
- ...
+ ...
ValueError: invalid literal for int() with base 10: '.2'
Validate out of range date:
+
>>> zeller('01-33-2010')
Traceback (most recent call last):
...
@@ -32,30 +33,35 @@ def zeller(date_input: str) -> str:
ValueError: invalid literal for int() with base 10: '.4'
Validate second separator:
+
>>> zeller('01-31*2010')
Traceback (most recent call last):
...
ValueError: Date separator must be '-' or '/'
Validate first separator:
+
>>> zeller('01^31-2010')
Traceback (most recent call last):
...
ValueError: Date separator must be '-' or '/'
Validate out of range year:
+
>>> zeller('01-31-8999')
Traceback (most recent call last):
...
ValueError: Year out of range. There has to be some sort of limit...right?
Test null input:
+
>>> zeller()
Traceback (most recent call last):
...
TypeError: zeller() missing 1 required positional argument: 'date_input'
- Test length of date_input:
+ Test length of `date_input`:
+
>>> zeller('')
Traceback (most recent call last):
...
diff --git a/matrix/binary_search_matrix.py b/matrix/binary_search_matrix.py
new file mode 100644
index 000000000000..6f203b7a3484
--- /dev/null
+++ b/matrix/binary_search_matrix.py
@@ -0,0 +1,57 @@
+def binary_search(array: list, lower_bound: int, upper_bound: int, value: int) -> int:
+ """
+ This function carries out Binary search on a 1d array and
+ return -1 if it do not exist
+ array: A 1d sorted array
+ value : the value meant to be searched
+ >>> matrix = [1, 4, 7, 11, 15]
+ >>> binary_search(matrix, 0, len(matrix) - 1, 1)
+ 0
+ >>> binary_search(matrix, 0, len(matrix) - 1, 23)
+ -1
+ """
+
+ r = int((lower_bound + upper_bound) // 2)
+ if array[r] == value:
+ return r
+ if lower_bound >= upper_bound:
+ return -1
+ if array[r] < value:
+ return binary_search(array, r + 1, upper_bound, value)
+ else:
+ return binary_search(array, lower_bound, r - 1, value)
+
+
+def mat_bin_search(value: int, matrix: list) -> list:
+ """
+ This function loops over a 2d matrix and calls binarySearch on
+ the selected 1d array and returns [-1, -1] is it do not exist
+ value : value meant to be searched
+ matrix = a sorted 2d matrix
+ >>> matrix = [[1, 4, 7, 11, 15],
+ ... [2, 5, 8, 12, 19],
+ ... [3, 6, 9, 16, 22],
+ ... [10, 13, 14, 17, 24],
+ ... [18, 21, 23, 26, 30]]
+ >>> target = 1
+ >>> mat_bin_search(target, matrix)
+ [0, 0]
+ >>> target = 34
+ >>> mat_bin_search(target, matrix)
+ [-1, -1]
+ """
+ index = 0
+ if matrix[index][0] == value:
+ return [index, 0]
+ while index < len(matrix) and matrix[index][0] < value:
+ r = binary_search(matrix[index], 0, len(matrix[index]) - 1, value)
+ if r != -1:
+ return [index, r]
+ index += 1
+ return [-1, -1]
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/matrix/count_islands_in_matrix.py b/matrix/count_islands_in_matrix.py
index ad9c67fb8c1b..64c595e8499d 100644
--- a/matrix/count_islands_in_matrix.py
+++ b/matrix/count_islands_in_matrix.py
@@ -3,13 +3,13 @@
# connections.
-class matrix: # Public class to implement a graph
- def __init__(self, row: int, col: int, graph: list):
+class Matrix: # Public class to implement a graph
+ def __init__(self, row: int, col: int, graph: list[list[bool]]) -> None:
self.ROW = row
self.COL = col
self.graph = graph
- def is_safe(self, i, j, visited) -> bool:
+ def is_safe(self, i: int, j: int, visited: list[list[bool]]) -> bool:
return (
0 <= i < self.ROW
and 0 <= j < self.COL
@@ -17,13 +17,14 @@ def is_safe(self, i, j, visited) -> bool:
and self.graph[i][j]
)
- def diffs(self, i, j, visited): # Checking all 8 elements surrounding nth element
- rowNbr = [-1, -1, -1, 0, 0, 1, 1, 1] # Coordinate order
- colNbr = [-1, 0, 1, -1, 1, -1, 0, 1]
+ def diffs(self, i: int, j: int, visited: list[list[bool]]) -> None:
+ # Checking all 8 elements surrounding nth element
+ row_nbr = [-1, -1, -1, 0, 0, 1, 1, 1] # Coordinate order
+ col_nbr = [-1, 0, 1, -1, 1, -1, 0, 1]
visited[i][j] = True # Make those cells visited
for k in range(8):
- if self.is_safe(i + rowNbr[k], j + colNbr[k], visited):
- self.diffs(i + rowNbr[k], j + colNbr[k], visited)
+ if self.is_safe(i + row_nbr[k], j + col_nbr[k], visited):
+ self.diffs(i + row_nbr[k], j + col_nbr[k], visited)
def count_islands(self) -> int: # And finally, count all islands.
visited = [[False for j in range(self.COL)] for i in range(self.ROW)]
diff --git a/matrix/count_negative_numbers_in_sorted_matrix.py b/matrix/count_negative_numbers_in_sorted_matrix.py
new file mode 100644
index 000000000000..2799ff3b45fe
--- /dev/null
+++ b/matrix/count_negative_numbers_in_sorted_matrix.py
@@ -0,0 +1,151 @@
+"""
+Given an matrix of numbers in which all rows and all columns are sorted in decreasing
+order, return the number of negative numbers in grid.
+
+Reference: https://leetcode.com/problems/count-negative-numbers-in-a-sorted-matrix
+"""
+
+
+def generate_large_matrix() -> list[list[int]]:
+ """
+ >>> generate_large_matrix() # doctest: +ELLIPSIS
+ [[1000, ..., -999], [999, ..., -1001], ..., [2, ..., -1998]]
+ """
+ return [list(range(1000 - i, -1000 - i, -1)) for i in range(1000)]
+
+
+grid = generate_large_matrix()
+test_grids = (
+ [[4, 3, 2, -1], [3, 2, 1, -1], [1, 1, -1, -2], [-1, -1, -2, -3]],
+ [[3, 2], [1, 0]],
+ [[7, 7, 6]],
+ [[7, 7, 6], [-1, -2, -3]],
+ grid,
+)
+
+
+def validate_grid(grid: list[list[int]]) -> None:
+ """
+ Validate that the rows and columns of the grid is sorted in decreasing order.
+ >>> for grid in test_grids:
+ ... validate_grid(grid)
+ """
+ assert all(row == sorted(row, reverse=True) for row in grid)
+ assert all(list(col) == sorted(col, reverse=True) for col in zip(*grid))
+
+
+def find_negative_index(array: list[int]) -> int:
+ """
+ Find the smallest negative index
+
+ >>> find_negative_index([0,0,0,0])
+ 4
+ >>> find_negative_index([4,3,2,-1])
+ 3
+ >>> find_negative_index([1,0,-1,-10])
+ 2
+ >>> find_negative_index([0,0,0,-1])
+ 3
+ >>> find_negative_index([11,8,7,-3,-5,-9])
+ 3
+ >>> find_negative_index([-1,-1,-2,-3])
+ 0
+ >>> find_negative_index([5,1,0])
+ 3
+ >>> find_negative_index([-5,-5,-5])
+ 0
+ >>> find_negative_index([0])
+ 1
+ >>> find_negative_index([])
+ 0
+ """
+ left = 0
+ right = len(array) - 1
+
+ # Edge cases such as no values or all numbers are negative.
+ if not array or array[0] < 0:
+ return 0
+
+ while right + 1 > left:
+ mid = (left + right) // 2
+ num = array[mid]
+
+ # Num must be negative and the index must be greater than or equal to 0.
+ if num < 0 and array[mid - 1] >= 0:
+ return mid
+
+ if num >= 0:
+ left = mid + 1
+ else:
+ right = mid - 1
+ # No negative numbers so return the last index of the array + 1 which is the length.
+ return len(array)
+
+
+def count_negatives_binary_search(grid: list[list[int]]) -> int:
+ """
+ An O(m logn) solution that uses binary search in order to find the boundary between
+ positive and negative numbers
+
+ >>> [count_negatives_binary_search(grid) for grid in test_grids]
+ [8, 0, 0, 3, 1498500]
+ """
+ total = 0
+ bound = len(grid[0])
+
+ for i in range(len(grid)):
+ bound = find_negative_index(grid[i][:bound])
+ total += bound
+ return (len(grid) * len(grid[0])) - total
+
+
+def count_negatives_brute_force(grid: list[list[int]]) -> int:
+ """
+ This solution is O(n^2) because it iterates through every column and row.
+
+ >>> [count_negatives_brute_force(grid) for grid in test_grids]
+ [8, 0, 0, 3, 1498500]
+ """
+ return len([number for row in grid for number in row if number < 0])
+
+
+def count_negatives_brute_force_with_break(grid: list[list[int]]) -> int:
+ """
+ Similar to the brute force solution above but uses break in order to reduce the
+ number of iterations.
+
+ >>> [count_negatives_brute_force_with_break(grid) for grid in test_grids]
+ [8, 0, 0, 3, 1498500]
+ """
+ total = 0
+ for row in grid:
+ for i, number in enumerate(row):
+ if number < 0:
+ total += len(row) - i
+ break
+ return total
+
+
+def benchmark() -> None:
+ """Benchmark our functions next to each other"""
+ from timeit import timeit
+
+ print("Running benchmarks")
+ setup = (
+ "from __main__ import count_negatives_binary_search, "
+ "count_negatives_brute_force, count_negatives_brute_force_with_break, grid"
+ )
+ for func in (
+ "count_negatives_binary_search", # took 0.7727 seconds
+ "count_negatives_brute_force_with_break", # took 4.6505 seconds
+ "count_negatives_brute_force", # took 12.8160 seconds
+ ):
+ time = timeit(f"{func}(grid=grid)", setup=setup, number=500)
+ print(f"{func}() took {time:0.4f} seconds")
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+ benchmark()
diff --git a/matrix/count_paths.py b/matrix/count_paths.py
new file mode 100644
index 000000000000..4861ad5fd0aa
--- /dev/null
+++ b/matrix/count_paths.py
@@ -0,0 +1,75 @@
+"""
+Given a grid, where you start from the top left position [0, 0],
+you want to find how many paths you can take to get to the bottom right position.
+
+start here -> 0 0 0 0
+ 1 1 0 0
+ 0 0 0 1
+ 0 1 0 0 <- finish here
+how many 'distinct' paths can you take to get to the finish?
+Using a recursive depth-first search algorithm below, you are able to
+find the number of distinct unique paths (count).
+
+'*' will demonstrate a path
+In the example above, there are two distinct paths:
+1. 2.
+ * * * 0 * * * *
+ 1 1 * 0 1 1 * *
+ 0 0 * 1 0 0 * 1
+ 0 1 * * 0 1 * *
+"""
+
+
+def depth_first_search(grid: list[list[int]], row: int, col: int, visit: set) -> int:
+ """
+ Recursive Backtracking Depth First Search Algorithm
+
+ Starting from top left of a matrix, count the number of
+ paths that can reach the bottom right of a matrix.
+ 1 represents a block (inaccessible)
+ 0 represents a valid space (accessible)
+
+ 0 0 0 0
+ 1 1 0 0
+ 0 0 0 1
+ 0 1 0 0
+ >>> grid = [[0, 0, 0, 0], [1, 1, 0, 0], [0, 0, 0, 1], [0, 1, 0, 0]]
+ >>> depth_first_search(grid, 0, 0, set())
+ 2
+
+ 0 0 0 0 0
+ 0 1 1 1 0
+ 0 1 1 1 0
+ 0 0 0 0 0
+ >>> grid = [[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0]]
+ >>> depth_first_search(grid, 0, 0, set())
+ 2
+ """
+ row_length, col_length = len(grid), len(grid[0])
+ if (
+ min(row, col) < 0
+ or row == row_length
+ or col == col_length
+ or (row, col) in visit
+ or grid[row][col] == 1
+ ):
+ return 0
+ if row == row_length - 1 and col == col_length - 1:
+ return 1
+
+ visit.add((row, col))
+
+ count = 0
+ count += depth_first_search(grid, row + 1, col, visit)
+ count += depth_first_search(grid, row - 1, col, visit)
+ count += depth_first_search(grid, row, col + 1, visit)
+ count += depth_first_search(grid, row, col - 1, visit)
+
+ visit.remove((row, col))
+ return count
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/matrix/cramers_rule_2x2.py b/matrix/cramers_rule_2x2.py
new file mode 100644
index 000000000000..081035bec002
--- /dev/null
+++ b/matrix/cramers_rule_2x2.py
@@ -0,0 +1,83 @@
+# https://www.chilimath.com/lessons/advanced-algebra/cramers-rule-with-two-variables
+# https://en.wikipedia.org/wiki/Cramer%27s_rule
+
+
+def cramers_rule_2x2(equation1: list[int], equation2: list[int]) -> tuple[float, float]:
+ """
+ Solves the system of linear equation in 2 variables.
+ :param: equation1: list of 3 numbers
+ :param: equation2: list of 3 numbers
+ :return: String of result
+ input format : [a1, b1, d1], [a2, b2, d2]
+ determinant = [[a1, b1], [a2, b2]]
+ determinant_x = [[d1, b1], [d2, b2]]
+ determinant_y = [[a1, d1], [a2, d2]]
+
+ >>> cramers_rule_2x2([2, 3, 0], [5, 1, 0])
+ (0.0, 0.0)
+ >>> cramers_rule_2x2([0, 4, 50], [2, 0, 26])
+ (13.0, 12.5)
+ >>> cramers_rule_2x2([11, 2, 30], [1, 0, 4])
+ (4.0, -7.0)
+ >>> cramers_rule_2x2([4, 7, 1], [1, 2, 0])
+ (2.0, -1.0)
+
+ >>> cramers_rule_2x2([1, 2, 3], [2, 4, 6])
+ Traceback (most recent call last):
+ ...
+ ValueError: Infinite solutions. (Consistent system)
+ >>> cramers_rule_2x2([1, 2, 3], [2, 4, 7])
+ Traceback (most recent call last):
+ ...
+ ValueError: No solution. (Inconsistent system)
+ >>> cramers_rule_2x2([1, 2, 3], [11, 22])
+ Traceback (most recent call last):
+ ...
+ ValueError: Please enter a valid equation.
+ >>> cramers_rule_2x2([0, 1, 6], [0, 0, 3])
+ Traceback (most recent call last):
+ ...
+ ValueError: No solution. (Inconsistent system)
+ >>> cramers_rule_2x2([0, 0, 6], [0, 0, 3])
+ Traceback (most recent call last):
+ ...
+ ValueError: Both a & b of two equations can't be zero.
+ >>> cramers_rule_2x2([1, 2, 3], [1, 2, 3])
+ Traceback (most recent call last):
+ ...
+ ValueError: Infinite solutions. (Consistent system)
+ >>> cramers_rule_2x2([0, 4, 50], [0, 3, 99])
+ Traceback (most recent call last):
+ ...
+ ValueError: No solution. (Inconsistent system)
+ """
+
+ # Check if the input is valid
+ if not len(equation1) == len(equation2) == 3:
+ raise ValueError("Please enter a valid equation.")
+ if equation1[0] == equation1[1] == equation2[0] == equation2[1] == 0:
+ raise ValueError("Both a & b of two equations can't be zero.")
+
+ # Extract the coefficients
+ a1, b1, c1 = equation1
+ a2, b2, c2 = equation2
+
+ # Calculate the determinants of the matrices
+ determinant = a1 * b2 - a2 * b1
+ determinant_x = c1 * b2 - c2 * b1
+ determinant_y = a1 * c2 - a2 * c1
+
+ # Check if the system of linear equations has a solution (using Cramer's rule)
+ if determinant == 0:
+ if determinant_x == determinant_y == 0:
+ raise ValueError("Infinite solutions. (Consistent system)")
+ else:
+ raise ValueError("No solution. (Inconsistent system)")
+ elif determinant_x == determinant_y == 0:
+ # Trivial solution (Inconsistent system)
+ return (0.0, 0.0)
+ else:
+ x = determinant_x / determinant
+ y = determinant_y / determinant
+ # Non-Trivial Solution (Consistent system)
+ return (x, y)
diff --git a/matrix/inverse_of_matrix.py b/matrix/inverse_of_matrix.py
index 9deca6c3c08e..e53d90df8253 100644
--- a/matrix/inverse_of_matrix.py
+++ b/matrix/inverse_of_matrix.py
@@ -2,22 +2,25 @@
from decimal import Decimal
+from numpy import array
+
def inverse_of_matrix(matrix: list[list[float]]) -> list[list[float]]:
"""
A matrix multiplied with its inverse gives the identity matrix.
- This function finds the inverse of a 2x2 matrix.
+ This function finds the inverse of a 2x2 and 3x3 matrix.
If the determinant of a matrix is 0, its inverse does not exist.
Sources for fixing inaccurate float arithmetic:
https://stackoverflow.com/questions/6563058/how-do-i-use-accurate-float-arithmetic-in-python
https://docs.python.org/3/library/decimal.html
+ Doctests for 2x2
>>> inverse_of_matrix([[2, 5], [2, 0]])
[[0.0, 0.5], [0.2, -0.2]]
>>> inverse_of_matrix([[2.5, 5], [1, 2]])
Traceback (most recent call last):
- ...
+ ...
ValueError: This matrix has no inverse.
>>> inverse_of_matrix([[12, -16], [-9, 0]])
[[0.0, -0.1111111111111111], [-0.0625, -0.08333333333333333]]
@@ -25,16 +28,128 @@ def inverse_of_matrix(matrix: list[list[float]]) -> list[list[float]]:
[[0.16666666666666666, -0.0625], [-0.3333333333333333, 0.25]]
>>> inverse_of_matrix([[10, 5], [3, 2.5]])
[[0.25, -0.5], [-0.3, 1.0]]
+
+ Doctests for 3x3
+ >>> inverse_of_matrix([[2, 5, 7], [2, 0, 1], [1, 2, 3]])
+ [[2.0, 5.0, -4.0], [1.0, 1.0, -1.0], [-5.0, -12.0, 10.0]]
+ >>> inverse_of_matrix([[1, 2, 2], [1, 2, 2], [3, 2, -1]])
+ Traceback (most recent call last):
+ ...
+ ValueError: This matrix has no inverse.
+
+ >>> inverse_of_matrix([[],[]])
+ Traceback (most recent call last):
+ ...
+ ValueError: Please provide a matrix of size 2x2 or 3x3.
+
+ >>> inverse_of_matrix([[1, 2], [3, 4], [5, 6]])
+ Traceback (most recent call last):
+ ...
+ ValueError: Please provide a matrix of size 2x2 or 3x3.
+
+ >>> inverse_of_matrix([[1, 2, 1], [0,3, 4]])
+ Traceback (most recent call last):
+ ...
+ ValueError: Please provide a matrix of size 2x2 or 3x3.
+
+ >>> inverse_of_matrix([[1, 2, 3], [7, 8, 9], [7, 8, 9]])
+ Traceback (most recent call last):
+ ...
+ ValueError: This matrix has no inverse.
+
+ >>> inverse_of_matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+ [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]
"""
- D = Decimal # An abbreviation to be conciseness
- # Calculate the determinant of the matrix
- determinant = D(matrix[0][0]) * D(matrix[1][1]) - D(matrix[1][0]) * D(matrix[0][1])
- if determinant == 0:
- raise ValueError("This matrix has no inverse.")
- # Creates a copy of the matrix with swapped positions of the elements
- swapped_matrix = [[0.0, 0.0], [0.0, 0.0]]
- swapped_matrix[0][0], swapped_matrix[1][1] = matrix[1][1], matrix[0][0]
- swapped_matrix[1][0], swapped_matrix[0][1] = -matrix[1][0], -matrix[0][1]
- # Calculate the inverse of the matrix
- return [[float(D(n) / determinant) or 0.0 for n in row] for row in swapped_matrix]
+ d = Decimal
+
+ # Check if the provided matrix has 2 rows and 2 columns
+ # since this implementation only works for 2x2 matrices
+ if len(matrix) == 2 and len(matrix[0]) == 2 and len(matrix[1]) == 2:
+ # Calculate the determinant of the matrix
+ determinant = float(
+ d(matrix[0][0]) * d(matrix[1][1]) - d(matrix[1][0]) * d(matrix[0][1])
+ )
+ if determinant == 0:
+ raise ValueError("This matrix has no inverse.")
+
+ # Creates a copy of the matrix with swapped positions of the elements
+ swapped_matrix = [[0.0, 0.0], [0.0, 0.0]]
+ swapped_matrix[0][0], swapped_matrix[1][1] = matrix[1][1], matrix[0][0]
+ swapped_matrix[1][0], swapped_matrix[0][1] = -matrix[1][0], -matrix[0][1]
+
+ # Calculate the inverse of the matrix
+ return [
+ [(float(d(n)) / determinant) or 0.0 for n in row] for row in swapped_matrix
+ ]
+ elif (
+ len(matrix) == 3
+ and len(matrix[0]) == 3
+ and len(matrix[1]) == 3
+ and len(matrix[2]) == 3
+ ):
+ # Calculate the determinant of the matrix using Sarrus rule
+ determinant = float(
+ (
+ (d(matrix[0][0]) * d(matrix[1][1]) * d(matrix[2][2]))
+ + (d(matrix[0][1]) * d(matrix[1][2]) * d(matrix[2][0]))
+ + (d(matrix[0][2]) * d(matrix[1][0]) * d(matrix[2][1]))
+ )
+ - (
+ (d(matrix[0][2]) * d(matrix[1][1]) * d(matrix[2][0]))
+ + (d(matrix[0][1]) * d(matrix[1][0]) * d(matrix[2][2]))
+ + (d(matrix[0][0]) * d(matrix[1][2]) * d(matrix[2][1]))
+ )
+ )
+ if determinant == 0:
+ raise ValueError("This matrix has no inverse.")
+
+ # Creating cofactor matrix
+ cofactor_matrix = [
+ [d(0.0), d(0.0), d(0.0)],
+ [d(0.0), d(0.0), d(0.0)],
+ [d(0.0), d(0.0), d(0.0)],
+ ]
+ cofactor_matrix[0][0] = (d(matrix[1][1]) * d(matrix[2][2])) - (
+ d(matrix[1][2]) * d(matrix[2][1])
+ )
+ cofactor_matrix[0][1] = -(
+ (d(matrix[1][0]) * d(matrix[2][2])) - (d(matrix[1][2]) * d(matrix[2][0]))
+ )
+ cofactor_matrix[0][2] = (d(matrix[1][0]) * d(matrix[2][1])) - (
+ d(matrix[1][1]) * d(matrix[2][0])
+ )
+ cofactor_matrix[1][0] = -(
+ (d(matrix[0][1]) * d(matrix[2][2])) - (d(matrix[0][2]) * d(matrix[2][1]))
+ )
+ cofactor_matrix[1][1] = (d(matrix[0][0]) * d(matrix[2][2])) - (
+ d(matrix[0][2]) * d(matrix[2][0])
+ )
+ cofactor_matrix[1][2] = -(
+ (d(matrix[0][0]) * d(matrix[2][1])) - (d(matrix[0][1]) * d(matrix[2][0]))
+ )
+ cofactor_matrix[2][0] = (d(matrix[0][1]) * d(matrix[1][2])) - (
+ d(matrix[0][2]) * d(matrix[1][1])
+ )
+ cofactor_matrix[2][1] = -(
+ (d(matrix[0][0]) * d(matrix[1][2])) - (d(matrix[0][2]) * d(matrix[1][0]))
+ )
+ cofactor_matrix[2][2] = (d(matrix[0][0]) * d(matrix[1][1])) - (
+ d(matrix[0][1]) * d(matrix[1][0])
+ )
+
+ # Transpose the cofactor matrix (Adjoint matrix)
+ adjoint_matrix = array(cofactor_matrix)
+ for i in range(3):
+ for j in range(3):
+ adjoint_matrix[i][j] = cofactor_matrix[j][i]
+
+ # Inverse of the matrix using the formula (1/determinant) * adjoint matrix
+ inverse_matrix = array(cofactor_matrix)
+ for i in range(3):
+ for j in range(3):
+ inverse_matrix[i][j] /= d(determinant)
+
+ # Calculate the inverse of the matrix
+ return [[float(d(n)) or 0.0 for n in row] for row in inverse_matrix]
+ raise ValueError("Please provide a matrix of size 2x2 or 3x3.")
diff --git a/matrix/largest_square_area_in_matrix.py b/matrix/largest_square_area_in_matrix.py
new file mode 100644
index 000000000000..16263fb798f1
--- /dev/null
+++ b/matrix/largest_square_area_in_matrix.py
@@ -0,0 +1,188 @@
+"""
+Question:
+Given a binary matrix mat of size n * m, find out the maximum size square
+sub-matrix with all 1s.
+
+---
+Example 1:
+
+Input:
+n = 2, m = 2
+mat = [[1, 1],
+ [1, 1]]
+
+Output:
+2
+
+Explanation: The maximum size of the square
+sub-matrix is 2. The matrix itself is the
+maximum sized sub-matrix in this case.
+---
+Example 2
+
+Input:
+n = 2, m = 2
+mat = [[0, 0],
+ [0, 0]]
+Output: 0
+
+Explanation: There is no 1 in the matrix.
+
+
+Approach:
+We initialize another matrix (dp) with the same dimensions
+as the original one initialized with all 0's.
+
+dp_array(i,j) represents the side length of the maximum square whose
+bottom right corner is the cell with index (i,j) in the original matrix.
+
+Starting from index (0,0), for every 1 found in the original matrix,
+we update the value of the current element as
+
+dp_array(i,j)=dp_array(dp(i-1,j),dp_array(i-1,j-1),dp_array(i,j-1)) + 1.
+"""
+
+
+def largest_square_area_in_matrix_top_down_approch(
+ rows: int, cols: int, mat: list[list[int]]
+) -> int:
+ """
+ Function updates the largest_square_area[0], if recursive call found
+ square with maximum area.
+
+ We aren't using dp_array here, so the time complexity would be exponential.
+
+ >>> largest_square_area_in_matrix_top_down_approch(2, 2, [[1,1], [1,1]])
+ 2
+ >>> largest_square_area_in_matrix_top_down_approch(2, 2, [[0,0], [0,0]])
+ 0
+ """
+
+ def update_area_of_max_square(row: int, col: int) -> int:
+ # BASE CASE
+ if row >= rows or col >= cols:
+ return 0
+
+ right = update_area_of_max_square(row, col + 1)
+ diagonal = update_area_of_max_square(row + 1, col + 1)
+ down = update_area_of_max_square(row + 1, col)
+
+ if mat[row][col]:
+ sub_problem_sol = 1 + min([right, diagonal, down])
+ largest_square_area[0] = max(largest_square_area[0], sub_problem_sol)
+ return sub_problem_sol
+ else:
+ return 0
+
+ largest_square_area = [0]
+ update_area_of_max_square(0, 0)
+ return largest_square_area[0]
+
+
+def largest_square_area_in_matrix_top_down_approch_with_dp(
+ rows: int, cols: int, mat: list[list[int]]
+) -> int:
+ """
+ Function updates the largest_square_area[0], if recursive call found
+ square with maximum area.
+
+ We are using dp_array here, so the time complexity would be O(N^2).
+
+ >>> largest_square_area_in_matrix_top_down_approch_with_dp(2, 2, [[1,1], [1,1]])
+ 2
+ >>> largest_square_area_in_matrix_top_down_approch_with_dp(2, 2, [[0,0], [0,0]])
+ 0
+ """
+
+ def update_area_of_max_square_using_dp_array(
+ row: int, col: int, dp_array: list[list[int]]
+ ) -> int:
+ if row >= rows or col >= cols:
+ return 0
+ if dp_array[row][col] != -1:
+ return dp_array[row][col]
+
+ right = update_area_of_max_square_using_dp_array(row, col + 1, dp_array)
+ diagonal = update_area_of_max_square_using_dp_array(row + 1, col + 1, dp_array)
+ down = update_area_of_max_square_using_dp_array(row + 1, col, dp_array)
+
+ if mat[row][col]:
+ sub_problem_sol = 1 + min([right, diagonal, down])
+ largest_square_area[0] = max(largest_square_area[0], sub_problem_sol)
+ dp_array[row][col] = sub_problem_sol
+ return sub_problem_sol
+ else:
+ return 0
+
+ largest_square_area = [0]
+ dp_array = [[-1] * cols for _ in range(rows)]
+ update_area_of_max_square_using_dp_array(0, 0, dp_array)
+
+ return largest_square_area[0]
+
+
+def largest_square_area_in_matrix_bottom_up(
+ rows: int, cols: int, mat: list[list[int]]
+) -> int:
+ """
+ Function updates the largest_square_area, using bottom up approach.
+
+ >>> largest_square_area_in_matrix_bottom_up(2, 2, [[1,1], [1,1]])
+ 2
+ >>> largest_square_area_in_matrix_bottom_up(2, 2, [[0,0], [0,0]])
+ 0
+
+ """
+ dp_array = [[0] * (cols + 1) for _ in range(rows + 1)]
+ largest_square_area = 0
+ for row in range(rows - 1, -1, -1):
+ for col in range(cols - 1, -1, -1):
+ right = dp_array[row][col + 1]
+ diagonal = dp_array[row + 1][col + 1]
+ bottom = dp_array[row + 1][col]
+
+ if mat[row][col] == 1:
+ dp_array[row][col] = 1 + min(right, diagonal, bottom)
+ largest_square_area = max(dp_array[row][col], largest_square_area)
+ else:
+ dp_array[row][col] = 0
+
+ return largest_square_area
+
+
+def largest_square_area_in_matrix_bottom_up_space_optimization(
+ rows: int, cols: int, mat: list[list[int]]
+) -> int:
+ """
+ Function updates the largest_square_area, using bottom up
+ approach. with space optimization.
+
+ >>> largest_square_area_in_matrix_bottom_up_space_optimization(2, 2, [[1,1], [1,1]])
+ 2
+ >>> largest_square_area_in_matrix_bottom_up_space_optimization(2, 2, [[0,0], [0,0]])
+ 0
+ """
+ current_row = [0] * (cols + 1)
+ next_row = [0] * (cols + 1)
+ largest_square_area = 0
+ for row in range(rows - 1, -1, -1):
+ for col in range(cols - 1, -1, -1):
+ right = current_row[col + 1]
+ diagonal = next_row[col + 1]
+ bottom = next_row[col]
+
+ if mat[row][col] == 1:
+ current_row[col] = 1 + min(right, diagonal, bottom)
+ largest_square_area = max(current_row[col], largest_square_area)
+ else:
+ current_row[col] = 0
+ next_row = current_row
+
+ return largest_square_area
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+ print(largest_square_area_in_matrix_bottom_up(2, 2, [[1, 1], [1, 1]]))
diff --git a/matrix/matrix_based_game.py b/matrix/matrix_based_game.py
new file mode 100644
index 000000000000..6181086c6704
--- /dev/null
+++ b/matrix/matrix_based_game.py
@@ -0,0 +1,284 @@
+"""
+Matrix-Based Game Script
+=========================
+This script implements a matrix-based game where players interact with a grid of
+elements. The primary goals are to:
+- Identify connected elements of the same type from a selected position.
+- Remove those elements, adjust the matrix by simulating gravity, and reorganize empty
+ columns.
+- Calculate and display the score based on the number of elements removed in each move.
+
+Functions:
+-----------
+1. `find_repeat`: Finds all connected elements of the same type.
+2. `increment_score`: Calculates the score for a given move.
+3. `move_x`: Simulates gravity in a column.
+4. `move_y`: Reorganizes the matrix by shifting columns leftward when a column becomes
+ empty.
+5. `play`: Executes a single move, updating the matrix and returning the score.
+
+Input Format:
+--------------
+1. Matrix size (`lines`): Integer specifying the size of the matrix (N x N).
+2. Matrix content (`matrix`): Rows of the matrix, each consisting of characters.
+3. Number of moves (`movs`): Integer indicating the number of moves.
+4. List of moves (`movements`): A comma-separated string of coordinates for each move.
+
+(0,0) position starts from first left column to last right, and below row to up row
+
+
+Example Input:
+---------------
+4
+RRBG
+RBBG
+YYGG
+XYGG
+2
+0 1,1 1
+
+Example (0,0) = X
+
+Output:
+--------
+The script outputs the total score after processing all moves.
+
+Usage:
+-------
+Run the script and provide the required inputs as prompted.
+
+"""
+
+
+def validate_matrix_size(size: int) -> None:
+ """
+ >>> validate_matrix_size(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: Matrix size must be a positive integer.
+ """
+ if not isinstance(size, int) or size <= 0:
+ raise ValueError("Matrix size must be a positive integer.")
+
+
+def validate_matrix_content(matrix: list[str], size: int) -> None:
+ """
+ Validates that the number of elements in the matrix matches the given size.
+
+ >>> validate_matrix_content(['aaaa', 'aaaa', 'aaaa', 'aaaa'], 3)
+ Traceback (most recent call last):
+ ...
+ ValueError: The matrix dont match with size.
+ >>> validate_matrix_content(['aa%', 'aaa', 'aaa'], 3)
+ Traceback (most recent call last):
+ ...
+ ValueError: Matrix rows can only contain letters and numbers.
+ >>> validate_matrix_content(['aaa', 'aaa', 'aaaa'], 3)
+ Traceback (most recent call last):
+ ...
+ ValueError: Each row in the matrix must have exactly 3 characters.
+ """
+ print(matrix)
+ if len(matrix) != size:
+ raise ValueError("The matrix dont match with size.")
+ for row in matrix:
+ if len(row) != size:
+ msg = f"Each row in the matrix must have exactly {size} characters."
+ raise ValueError(msg)
+ if not all(char.isalnum() for char in row):
+ raise ValueError("Matrix rows can only contain letters and numbers.")
+
+
+def validate_moves(moves: list[tuple[int, int]], size: int) -> None:
+ """
+ >>> validate_moves([(1, 2), (-1, 0)], 3)
+ Traceback (most recent call last):
+ ...
+ ValueError: Move is out of bounds for a matrix.
+ """
+ for move in moves:
+ x, y = move
+ if not (0 <= x < size and 0 <= y < size):
+ raise ValueError("Move is out of bounds for a matrix.")
+
+
+def parse_moves(input_str: str) -> list[tuple[int, int]]:
+ """
+ >>> parse_moves("0 1, 1 1")
+ [(0, 1), (1, 1)]
+ >>> parse_moves("0 1, 1 1, 2")
+ Traceback (most recent call last):
+ ...
+ ValueError: Each move must have exactly two numbers.
+ >>> parse_moves("0 1, 1 1, 2 4 5 6")
+ Traceback (most recent call last):
+ ...
+ ValueError: Each move must have exactly two numbers.
+ """
+ moves = []
+ for pair in input_str.split(","):
+ parts = pair.strip().split()
+ if len(parts) != 2:
+ raise ValueError("Each move must have exactly two numbers.")
+ x, y = map(int, parts)
+ moves.append((x, y))
+ return moves
+
+
+def find_repeat(
+ matrix_g: list[list[str]], row: int, column: int, size: int
+) -> set[tuple[int, int]]:
+ """
+ Finds all connected elements of the same type from a given position.
+
+ >>> find_repeat([['A', 'B', 'A'], ['A', 'B', 'A'], ['A', 'A', 'A']], 0, 0, 3)
+ {(1, 2), (2, 1), (0, 0), (2, 0), (0, 2), (2, 2), (1, 0)}
+ >>> find_repeat([['-', '-', '-'], ['-', '-', '-'], ['-', '-', '-']], 1, 1, 3)
+ set()
+ """
+
+ column = size - 1 - column
+ visited = set()
+ repeated = set()
+
+ if (color := matrix_g[column][row]) != "-":
+
+ def dfs(row_n: int, column_n: int) -> None:
+ if row_n < 0 or row_n >= size or column_n < 0 or column_n >= size:
+ return
+ if (row_n, column_n) in visited:
+ return
+ visited.add((row_n, column_n))
+ if matrix_g[row_n][column_n] == color:
+ repeated.add((row_n, column_n))
+ dfs(row_n - 1, column_n)
+ dfs(row_n + 1, column_n)
+ dfs(row_n, column_n - 1)
+ dfs(row_n, column_n + 1)
+
+ dfs(column, row)
+
+ return repeated
+
+
+def increment_score(count: int) -> int:
+ """
+ Calculates the score for a move based on the number of elements removed.
+
+ >>> increment_score(3)
+ 6
+ >>> increment_score(0)
+ 0
+ """
+ return int(count * (count + 1) / 2)
+
+
+def move_x(matrix_g: list[list[str]], column: int, size: int) -> list[list[str]]:
+ """
+ Simulates gravity in a specific column.
+
+ >>> move_x([['-', 'A'], ['-', '-'], ['-', 'C']], 1, 2)
+ [['-', '-'], ['-', 'A'], ['-', 'C']]
+ """
+
+ new_list = []
+
+ for row in range(size):
+ if matrix_g[row][column] != "-":
+ new_list.append(matrix_g[row][column])
+ else:
+ new_list.insert(0, matrix_g[row][column])
+ for row in range(size):
+ matrix_g[row][column] = new_list[row]
+ return matrix_g
+
+
+def move_y(matrix_g: list[list[str]], size: int) -> list[list[str]]:
+ """
+ Shifts all columns leftward when an entire column becomes empty.
+
+ >>> move_y([['-', 'A'], ['-', '-'], ['-', 'C']], 2)
+ [['A', '-'], ['-', '-'], ['-', 'C']]
+ """
+
+ empty_columns = []
+
+ for column in range(size - 1, -1, -1):
+ if all(matrix_g[row][column] == "-" for row in range(size)):
+ empty_columns.append(column)
+
+ for column in empty_columns:
+ for col in range(column + 1, size):
+ for row in range(size):
+ matrix_g[row][col - 1] = matrix_g[row][col]
+ for row in range(size):
+ matrix_g[row][-1] = "-"
+
+ return matrix_g
+
+
+def play(
+ matrix_g: list[list[str]], pos_x: int, pos_y: int, size: int
+) -> tuple[list[list[str]], int]:
+ """
+ Processes a single move, updating the matrix and calculating the score.
+
+ >>> play([['R', 'G'], ['R', 'G']], 0, 0, 2)
+ ([['G', '-'], ['G', '-']], 3)
+ """
+
+ same_colors = find_repeat(matrix_g, pos_x, pos_y, size)
+
+ if len(same_colors) != 0:
+ for pos in same_colors:
+ matrix_g[pos[0]][pos[1]] = "-"
+ for column in range(size):
+ matrix_g = move_x(matrix_g, column, size)
+
+ matrix_g = move_y(matrix_g, size)
+
+ return (matrix_g, increment_score(len(same_colors)))
+
+
+def process_game(size: int, matrix: list[str], moves: list[tuple[int, int]]) -> int:
+ """Processes the game logic for the given matrix and moves.
+
+ Args:
+ size (int): Size of the game board.
+ matrix (List[str]): Initial game matrix.
+ moves (List[Tuple[int, int]]): List of moves as (x, y) coordinates.
+
+ Returns:
+ int: The total score obtained.
+ >>> process_game(3, ['aaa', 'bbb', 'ccc'], [(0, 0)])
+ 6
+ """
+
+ game_matrix = [list(row) for row in matrix]
+ total_score = 0
+
+ for move in moves:
+ pos_x, pos_y = move
+ game_matrix, score = play(game_matrix, pos_x, pos_y, size)
+ total_score += score
+
+ return total_score
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod(verbose=True)
+ try:
+ size = int(input("Enter the size of the matrix: "))
+ validate_matrix_size(size)
+ print(f"Enter the {size} rows of the matrix:")
+ matrix = [input(f"Row {i + 1}: ") for i in range(size)]
+ validate_matrix_content(matrix, size)
+ moves_input = input("Enter the moves (e.g., '0 0, 1 1'): ")
+ moves = parse_moves(moves_input)
+ validate_moves(moves, size)
+ score = process_game(size, matrix, moves)
+ print(f"Total score: {score}")
+ except ValueError as e:
+ print(f"{e}")
diff --git a/matrix/matrix_class.py b/matrix/matrix_class.py
index 57a2fc45ffd1..a5940a38e836 100644
--- a/matrix/matrix_class.py
+++ b/matrix/matrix_class.py
@@ -1,358 +1,366 @@
-# An OOP approach to representing and manipulating matrices
-
-
-class Matrix:
- """
- Matrix object generated from a 2D array where each element is an array representing
- a row.
- Rows can contain type int or float.
- Common operations and information available.
- >>> rows = [
- ... [1, 2, 3],
- ... [4, 5, 6],
- ... [7, 8, 9]
- ... ]
- >>> matrix = Matrix(rows)
- >>> print(matrix)
- [[1. 2. 3.]
- [4. 5. 6.]
- [7. 8. 9.]]
-
- Matrix rows and columns are available as 2D arrays
- >>> print(matrix.rows)
- [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
- >>> print(matrix.columns())
- [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
-
- Order is returned as a tuple
- >>> matrix.order
- (3, 3)
-
- Squareness and invertability are represented as bool
- >>> matrix.is_square
- True
- >>> matrix.is_invertable()
- False
-
- Identity, Minors, Cofactors and Adjugate are returned as Matrices. Inverse can be
- a Matrix or Nonetype
- >>> print(matrix.identity())
- [[1. 0. 0.]
- [0. 1. 0.]
- [0. 0. 1.]]
- >>> print(matrix.minors())
- [[-3. -6. -3.]
- [-6. -12. -6.]
- [-3. -6. -3.]]
- >>> print(matrix.cofactors())
- [[-3. 6. -3.]
- [6. -12. 6.]
- [-3. 6. -3.]]
- >>> # won't be apparent due to the nature of the cofactor matrix
- >>> print(matrix.adjugate())
- [[-3. 6. -3.]
- [6. -12. 6.]
- [-3. 6. -3.]]
- >>> print(matrix.inverse())
- None
-
- Determinant is an int, float, or Nonetype
- >>> matrix.determinant()
- 0
-
- Negation, scalar multiplication, addition, subtraction, multiplication and
- exponentiation are available and all return a Matrix
- >>> print(-matrix)
- [[-1. -2. -3.]
- [-4. -5. -6.]
- [-7. -8. -9.]]
- >>> matrix2 = matrix * 3
- >>> print(matrix2)
- [[3. 6. 9.]
- [12. 15. 18.]
- [21. 24. 27.]]
- >>> print(matrix + matrix2)
- [[4. 8. 12.]
- [16. 20. 24.]
- [28. 32. 36.]]
- >>> print(matrix - matrix2)
- [[-2. -4. -6.]
- [-8. -10. -12.]
- [-14. -16. -18.]]
- >>> print(matrix ** 3)
- [[468. 576. 684.]
- [1062. 1305. 1548.]
- [1656. 2034. 2412.]]
-
- Matrices can also be modified
- >>> matrix.add_row([10, 11, 12])
- >>> print(matrix)
- [[1. 2. 3.]
- [4. 5. 6.]
- [7. 8. 9.]
- [10. 11. 12.]]
- >>> matrix2.add_column([8, 16, 32])
- >>> print(matrix2)
- [[3. 6. 9. 8.]
- [12. 15. 18. 16.]
- [21. 24. 27. 32.]]
- >>> print(matrix * matrix2)
- [[90. 108. 126. 136.]
- [198. 243. 288. 304.]
- [306. 378. 450. 472.]
- [414. 513. 612. 640.]]
-
- """
-
- def __init__(self, rows):
- error = TypeError(
- "Matrices must be formed from a list of zero or more lists containing at "
- "least one and the same number of values, each of which must be of type "
- "int or float."
- )
- if len(rows) != 0:
- cols = len(rows[0])
- if cols == 0:
- raise error
- for row in rows:
- if len(row) != cols:
- raise error
- for value in row:
- if not isinstance(value, (int, float)):
- raise error
- self.rows = rows
- else:
- self.rows = []
-
- # MATRIX INFORMATION
- def columns(self):
- return [[row[i] for row in self.rows] for i in range(len(self.rows[0]))]
-
- @property
- def num_rows(self):
- return len(self.rows)
-
- @property
- def num_columns(self):
- return len(self.rows[0])
-
- @property
- def order(self):
- return (self.num_rows, self.num_columns)
-
- @property
- def is_square(self):
- return self.order[0] == self.order[1]
-
- def identity(self):
- values = [
- [0 if column_num != row_num else 1 for column_num in range(self.num_rows)]
- for row_num in range(self.num_rows)
- ]
- return Matrix(values)
-
- def determinant(self):
- if not self.is_square:
- return None
- if self.order == (0, 0):
- return 1
- if self.order == (1, 1):
- return self.rows[0][0]
- if self.order == (2, 2):
- return (self.rows[0][0] * self.rows[1][1]) - (
- self.rows[0][1] * self.rows[1][0]
- )
- else:
- return sum(
- self.rows[0][column] * self.cofactors().rows[0][column]
- for column in range(self.num_columns)
- )
-
- def is_invertable(self):
- return bool(self.determinant())
-
- def get_minor(self, row, column):
- values = [
- [
- self.rows[other_row][other_column]
- for other_column in range(self.num_columns)
- if other_column != column
- ]
- for other_row in range(self.num_rows)
- if other_row != row
- ]
- return Matrix(values).determinant()
-
- def get_cofactor(self, row, column):
- if (row + column) % 2 == 0:
- return self.get_minor(row, column)
- return -1 * self.get_minor(row, column)
-
- def minors(self):
- return Matrix(
- [
- [self.get_minor(row, column) for column in range(self.num_columns)]
- for row in range(self.num_rows)
- ]
- )
-
- def cofactors(self):
- return Matrix(
- [
- [
- self.minors().rows[row][column]
- if (row + column) % 2 == 0
- else self.minors().rows[row][column] * -1
- for column in range(self.minors().num_columns)
- ]
- for row in range(self.minors().num_rows)
- ]
- )
-
- def adjugate(self):
- values = [
- [self.cofactors().rows[column][row] for column in range(self.num_columns)]
- for row in range(self.num_rows)
- ]
- return Matrix(values)
-
- def inverse(self):
- determinant = self.determinant()
- return None if not determinant else self.adjugate() * (1 / determinant)
-
- def __repr__(self):
- return str(self.rows)
-
- def __str__(self):
- if self.num_rows == 0:
- return "[]"
- if self.num_rows == 1:
- return "[[" + ". ".join(self.rows[0]) + "]]"
- return (
- "["
- + "\n ".join(
- [
- "[" + ". ".join([str(value) for value in row]) + ".]"
- for row in self.rows
- ]
- )
- + "]"
- )
-
- # MATRIX MANIPULATION
- def add_row(self, row, position=None):
- type_error = TypeError("Row must be a list containing all ints and/or floats")
- if not isinstance(row, list):
- raise type_error
- for value in row:
- if not isinstance(value, (int, float)):
- raise type_error
- if len(row) != self.num_columns:
- raise ValueError(
- "Row must be equal in length to the other rows in the matrix"
- )
- if position is None:
- self.rows.append(row)
- else:
- self.rows = self.rows[0:position] + [row] + self.rows[position:]
-
- def add_column(self, column, position=None):
- type_error = TypeError(
- "Column must be a list containing all ints and/or floats"
- )
- if not isinstance(column, list):
- raise type_error
- for value in column:
- if not isinstance(value, (int, float)):
- raise type_error
- if len(column) != self.num_rows:
- raise ValueError(
- "Column must be equal in length to the other columns in the matrix"
- )
- if position is None:
- self.rows = [self.rows[i] + [column[i]] for i in range(self.num_rows)]
- else:
- self.rows = [
- self.rows[i][0:position] + [column[i]] + self.rows[i][position:]
- for i in range(self.num_rows)
- ]
-
- # MATRIX OPERATIONS
- def __eq__(self, other):
- if not isinstance(other, Matrix):
- raise TypeError("A Matrix can only be compared with another Matrix")
- return self.rows == other.rows
-
- def __ne__(self, other):
- return not self == other
-
- def __neg__(self):
- return self * -1
-
- def __add__(self, other):
- if self.order != other.order:
- raise ValueError("Addition requires matrices of the same order")
- return Matrix(
- [
- [self.rows[i][j] + other.rows[i][j] for j in range(self.num_columns)]
- for i in range(self.num_rows)
- ]
- )
-
- def __sub__(self, other):
- if self.order != other.order:
- raise ValueError("Subtraction requires matrices of the same order")
- return Matrix(
- [
- [self.rows[i][j] - other.rows[i][j] for j in range(self.num_columns)]
- for i in range(self.num_rows)
- ]
- )
-
- def __mul__(self, other):
- if isinstance(other, (int, float)):
- return Matrix([[element * other for element in row] for row in self.rows])
- elif isinstance(other, Matrix):
- if self.num_columns != other.num_rows:
- raise ValueError(
- "The number of columns in the first matrix must "
- "be equal to the number of rows in the second"
- )
- return Matrix(
- [
- [Matrix.dot_product(row, column) for column in other.columns()]
- for row in self.rows
- ]
- )
- else:
- raise TypeError(
- "A Matrix can only be multiplied by an int, float, or another matrix"
- )
-
- def __pow__(self, other):
- if not isinstance(other, int):
- raise TypeError("A Matrix can only be raised to the power of an int")
- if not self.is_square:
- raise ValueError("Only square matrices can be raised to a power")
- if other == 0:
- return self.identity()
- if other < 0:
- if self.is_invertable:
- return self.inverse() ** (-other)
- raise ValueError(
- "Only invertable matrices can be raised to a negative power"
- )
- result = self
- for i in range(other - 1):
- result *= self
- return result
-
- @classmethod
- def dot_product(cls, row, column):
- return sum(row[i] * column[i] for i in range(len(row)))
-
-
-if __name__ == "__main__":
- import doctest
-
- doctest.testmod()
+# An OOP approach to representing and manipulating matrices
+
+from __future__ import annotations
+
+
+class Matrix:
+ """
+ Matrix object generated from a 2D array where each element is an array representing
+ a row.
+ Rows can contain type int or float.
+ Common operations and information available.
+ >>> rows = [
+ ... [1, 2, 3],
+ ... [4, 5, 6],
+ ... [7, 8, 9]
+ ... ]
+ >>> matrix = Matrix(rows)
+ >>> print(matrix)
+ [[1. 2. 3.]
+ [4. 5. 6.]
+ [7. 8. 9.]]
+
+ Matrix rows and columns are available as 2D arrays
+ >>> matrix.rows
+ [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+ >>> matrix.columns()
+ [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
+
+ Order is returned as a tuple
+ >>> matrix.order
+ (3, 3)
+
+ Squareness and invertability are represented as bool
+ >>> matrix.is_square
+ True
+ >>> matrix.is_invertable()
+ False
+
+ Identity, Minors, Cofactors and Adjugate are returned as Matrices. Inverse can be
+ a Matrix or Nonetype
+ >>> print(matrix.identity())
+ [[1. 0. 0.]
+ [0. 1. 0.]
+ [0. 0. 1.]]
+ >>> print(matrix.minors())
+ [[-3. -6. -3.]
+ [-6. -12. -6.]
+ [-3. -6. -3.]]
+ >>> print(matrix.cofactors())
+ [[-3. 6. -3.]
+ [6. -12. 6.]
+ [-3. 6. -3.]]
+ >>> # won't be apparent due to the nature of the cofactor matrix
+ >>> print(matrix.adjugate())
+ [[-3. 6. -3.]
+ [6. -12. 6.]
+ [-3. 6. -3.]]
+ >>> matrix.inverse()
+ Traceback (most recent call last):
+ ...
+ TypeError: Only matrices with a non-zero determinant have an inverse
+
+ Determinant is an int, float, or Nonetype
+ >>> matrix.determinant()
+ 0
+
+ Negation, scalar multiplication, addition, subtraction, multiplication and
+ exponentiation are available and all return a Matrix
+ >>> print(-matrix)
+ [[-1. -2. -3.]
+ [-4. -5. -6.]
+ [-7. -8. -9.]]
+ >>> matrix2 = matrix * 3
+ >>> print(matrix2)
+ [[3. 6. 9.]
+ [12. 15. 18.]
+ [21. 24. 27.]]
+ >>> print(matrix + matrix2)
+ [[4. 8. 12.]
+ [16. 20. 24.]
+ [28. 32. 36.]]
+ >>> print(matrix - matrix2)
+ [[-2. -4. -6.]
+ [-8. -10. -12.]
+ [-14. -16. -18.]]
+ >>> print(matrix ** 3)
+ [[468. 576. 684.]
+ [1062. 1305. 1548.]
+ [1656. 2034. 2412.]]
+
+ Matrices can also be modified
+ >>> matrix.add_row([10, 11, 12])
+ >>> print(matrix)
+ [[1. 2. 3.]
+ [4. 5. 6.]
+ [7. 8. 9.]
+ [10. 11. 12.]]
+ >>> matrix2.add_column([8, 16, 32])
+ >>> print(matrix2)
+ [[3. 6. 9. 8.]
+ [12. 15. 18. 16.]
+ [21. 24. 27. 32.]]
+ >>> print(matrix * matrix2)
+ [[90. 108. 126. 136.]
+ [198. 243. 288. 304.]
+ [306. 378. 450. 472.]
+ [414. 513. 612. 640.]]
+ """
+
+ def __init__(self, rows: list[list[int]]):
+ error = TypeError(
+ "Matrices must be formed from a list of zero or more lists containing at "
+ "least one and the same number of values, each of which must be of type "
+ "int or float."
+ )
+ if len(rows) != 0:
+ cols = len(rows[0])
+ if cols == 0:
+ raise error
+ for row in rows:
+ if len(row) != cols:
+ raise error
+ for value in row:
+ if not isinstance(value, (int, float)):
+ raise error
+ self.rows = rows
+ else:
+ self.rows = []
+
+ # MATRIX INFORMATION
+ def columns(self) -> list[list[int]]:
+ return [[row[i] for row in self.rows] for i in range(len(self.rows[0]))]
+
+ @property
+ def num_rows(self) -> int:
+ return len(self.rows)
+
+ @property
+ def num_columns(self) -> int:
+ return len(self.rows[0])
+
+ @property
+ def order(self) -> tuple[int, int]:
+ return self.num_rows, self.num_columns
+
+ @property
+ def is_square(self) -> bool:
+ return self.order[0] == self.order[1]
+
+ def identity(self) -> Matrix:
+ values = [
+ [0 if column_num != row_num else 1 for column_num in range(self.num_rows)]
+ for row_num in range(self.num_rows)
+ ]
+ return Matrix(values)
+
+ def determinant(self) -> int:
+ if not self.is_square:
+ return 0
+ if self.order == (0, 0):
+ return 1
+ if self.order == (1, 1):
+ return int(self.rows[0][0])
+ if self.order == (2, 2):
+ return int(
+ (self.rows[0][0] * self.rows[1][1])
+ - (self.rows[0][1] * self.rows[1][0])
+ )
+ else:
+ return sum(
+ self.rows[0][column] * self.cofactors().rows[0][column]
+ for column in range(self.num_columns)
+ )
+
+ def is_invertable(self) -> bool:
+ return bool(self.determinant())
+
+ def get_minor(self, row: int, column: int) -> int:
+ values = [
+ [
+ self.rows[other_row][other_column]
+ for other_column in range(self.num_columns)
+ if other_column != column
+ ]
+ for other_row in range(self.num_rows)
+ if other_row != row
+ ]
+ return Matrix(values).determinant()
+
+ def get_cofactor(self, row: int, column: int) -> int:
+ if (row + column) % 2 == 0:
+ return self.get_minor(row, column)
+ return -1 * self.get_minor(row, column)
+
+ def minors(self) -> Matrix:
+ return Matrix(
+ [
+ [self.get_minor(row, column) for column in range(self.num_columns)]
+ for row in range(self.num_rows)
+ ]
+ )
+
+ def cofactors(self) -> Matrix:
+ return Matrix(
+ [
+ [
+ self.minors().rows[row][column]
+ if (row + column) % 2 == 0
+ else self.minors().rows[row][column] * -1
+ for column in range(self.minors().num_columns)
+ ]
+ for row in range(self.minors().num_rows)
+ ]
+ )
+
+ def adjugate(self) -> Matrix:
+ values = [
+ [self.cofactors().rows[column][row] for column in range(self.num_columns)]
+ for row in range(self.num_rows)
+ ]
+ return Matrix(values)
+
+ def inverse(self) -> Matrix:
+ determinant = self.determinant()
+ if not determinant:
+ raise TypeError("Only matrices with a non-zero determinant have an inverse")
+ return self.adjugate() * (1 / determinant)
+
+ def __repr__(self) -> str:
+ return str(self.rows)
+
+ def __str__(self) -> str:
+ if self.num_rows == 0:
+ return "[]"
+ if self.num_rows == 1:
+ return "[[" + ". ".join(str(self.rows[0])) + "]]"
+ return (
+ "["
+ + "\n ".join(
+ [
+ "[" + ". ".join([str(value) for value in row]) + ".]"
+ for row in self.rows
+ ]
+ )
+ + "]"
+ )
+
+ # MATRIX MANIPULATION
+ def add_row(self, row: list[int], position: int | None = None) -> None:
+ type_error = TypeError("Row must be a list containing all ints and/or floats")
+ if not isinstance(row, list):
+ raise type_error
+ for value in row:
+ if not isinstance(value, (int, float)):
+ raise type_error
+ if len(row) != self.num_columns:
+ raise ValueError(
+ "Row must be equal in length to the other rows in the matrix"
+ )
+ if position is None:
+ self.rows.append(row)
+ else:
+ self.rows = self.rows[0:position] + [row] + self.rows[position:]
+
+ def add_column(self, column: list[int], position: int | None = None) -> None:
+ type_error = TypeError(
+ "Column must be a list containing all ints and/or floats"
+ )
+ if not isinstance(column, list):
+ raise type_error
+ for value in column:
+ if not isinstance(value, (int, float)):
+ raise type_error
+ if len(column) != self.num_rows:
+ raise ValueError(
+ "Column must be equal in length to the other columns in the matrix"
+ )
+ if position is None:
+ self.rows = [self.rows[i] + [column[i]] for i in range(self.num_rows)]
+ else:
+ self.rows = [
+ self.rows[i][0:position] + [column[i]] + self.rows[i][position:]
+ for i in range(self.num_rows)
+ ]
+
+ # MATRIX OPERATIONS
+ def __eq__(self, other: object) -> bool:
+ if not isinstance(other, Matrix):
+ return NotImplemented
+ return self.rows == other.rows
+
+ def __ne__(self, other: object) -> bool:
+ return not self == other
+
+ def __neg__(self) -> Matrix:
+ return self * -1
+
+ def __add__(self, other: Matrix) -> Matrix:
+ if self.order != other.order:
+ raise ValueError("Addition requires matrices of the same order")
+ return Matrix(
+ [
+ [self.rows[i][j] + other.rows[i][j] for j in range(self.num_columns)]
+ for i in range(self.num_rows)
+ ]
+ )
+
+ def __sub__(self, other: Matrix) -> Matrix:
+ if self.order != other.order:
+ raise ValueError("Subtraction requires matrices of the same order")
+ return Matrix(
+ [
+ [self.rows[i][j] - other.rows[i][j] for j in range(self.num_columns)]
+ for i in range(self.num_rows)
+ ]
+ )
+
+ def __mul__(self, other: Matrix | float) -> Matrix:
+ if isinstance(other, (int, float)):
+ return Matrix(
+ [[int(element * other) for element in row] for row in self.rows]
+ )
+ elif isinstance(other, Matrix):
+ if self.num_columns != other.num_rows:
+ raise ValueError(
+ "The number of columns in the first matrix must "
+ "be equal to the number of rows in the second"
+ )
+ return Matrix(
+ [
+ [Matrix.dot_product(row, column) for column in other.columns()]
+ for row in self.rows
+ ]
+ )
+ else:
+ raise TypeError(
+ "A Matrix can only be multiplied by an int, float, or another matrix"
+ )
+
+ def __pow__(self, other: int) -> Matrix:
+ if not isinstance(other, int):
+ raise TypeError("A Matrix can only be raised to the power of an int")
+ if not self.is_square:
+ raise ValueError("Only square matrices can be raised to a power")
+ if other == 0:
+ return self.identity()
+ if other < 0:
+ if self.is_invertable():
+ return self.inverse() ** (-other)
+ raise ValueError(
+ "Only invertable matrices can be raised to a negative power"
+ )
+ result = self
+ for _ in range(other - 1):
+ result *= self
+ return result
+
+ @classmethod
+ def dot_product(cls, row: list[int], column: list[int]) -> int:
+ return sum(row[i] * column[i] for i in range(len(row)))
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/matrix/matrix_equalization.py b/matrix/matrix_equalization.py
new file mode 100644
index 000000000000..e7e76505cf63
--- /dev/null
+++ b/matrix/matrix_equalization.py
@@ -0,0 +1,55 @@
+from sys import maxsize
+
+
+def array_equalization(vector: list[int], step_size: int) -> int:
+ """
+ This algorithm equalizes all elements of the input vector
+ to a common value, by making the minimal number of
+ "updates" under the constraint of a step size (step_size).
+
+ >>> array_equalization([1, 1, 6, 2, 4, 6, 5, 1, 7, 2, 2, 1, 7, 2, 2], 4)
+ 4
+ >>> array_equalization([22, 81, 88, 71, 22, 81, 632, 81, 81, 22, 92], 2)
+ 5
+ >>> array_equalization([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 5)
+ 0
+ >>> array_equalization([22, 22, 22, 33, 33, 33], 2)
+ 2
+ >>> array_equalization([1, 2, 3], 0)
+ Traceback (most recent call last):
+ ValueError: Step size must be positive and non-zero.
+ >>> array_equalization([1, 2, 3], -1)
+ Traceback (most recent call last):
+ ValueError: Step size must be positive and non-zero.
+ >>> array_equalization([1, 2, 3], 0.5)
+ Traceback (most recent call last):
+ ValueError: Step size must be an integer.
+ >>> array_equalization([1, 2, 3], maxsize)
+ 1
+ """
+ if step_size <= 0:
+ raise ValueError("Step size must be positive and non-zero.")
+ if not isinstance(step_size, int):
+ raise ValueError("Step size must be an integer.")
+
+ unique_elements = set(vector)
+ min_updates = maxsize
+
+ for element in unique_elements:
+ elem_index = 0
+ updates = 0
+ while elem_index < len(vector):
+ if vector[elem_index] != element:
+ updates += 1
+ elem_index += step_size
+ else:
+ elem_index += 1
+ min_updates = min(min_updates, updates)
+
+ return min_updates
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
diff --git a/matrix/matrix_multiplication_recursion.py b/matrix/matrix_multiplication_recursion.py
new file mode 100644
index 000000000000..57c4d80de017
--- /dev/null
+++ b/matrix/matrix_multiplication_recursion.py
@@ -0,0 +1,181 @@
+# @Author : ojas-wani
+# @File : matrix_multiplication_recursion.py
+# @Date : 10/06/2023
+
+
+"""
+Perform matrix multiplication using a recursive algorithm.
+https://en.wikipedia.org/wiki/Matrix_multiplication
+"""
+
+# type Matrix = list[list[int]] # psf/black currenttly fails on this line
+Matrix = list[list[int]]
+
+matrix_1_to_4 = [
+ [1, 2],
+ [3, 4],
+]
+
+matrix_5_to_8 = [
+ [5, 6],
+ [7, 8],
+]
+
+matrix_5_to_9_high = [
+ [5, 6],
+ [7, 8],
+ [9],
+]
+
+matrix_5_to_9_wide = [
+ [5, 6],
+ [7, 8, 9],
+]
+
+matrix_count_up = [
+ [1, 2, 3, 4],
+ [5, 6, 7, 8],
+ [9, 10, 11, 12],
+ [13, 14, 15, 16],
+]
+
+matrix_unordered = [
+ [5, 8, 1, 2],
+ [6, 7, 3, 0],
+ [4, 5, 9, 1],
+ [2, 6, 10, 14],
+]
+matrices = (
+ matrix_1_to_4,
+ matrix_5_to_8,
+ matrix_5_to_9_high,
+ matrix_5_to_9_wide,
+ matrix_count_up,
+ matrix_unordered,
+)
+
+
+def is_square(matrix: Matrix) -> bool:
+ """
+ >>> is_square([])
+ True
+ >>> is_square(matrix_1_to_4)
+ True
+ >>> is_square(matrix_5_to_9_high)
+ False
+ """
+ len_matrix = len(matrix)
+ return all(len(row) == len_matrix for row in matrix)
+
+
+def matrix_multiply(matrix_a: Matrix, matrix_b: Matrix) -> Matrix:
+ """
+ >>> matrix_multiply(matrix_1_to_4, matrix_5_to_8)
+ [[19, 22], [43, 50]]
+ """
+ return [
+ [sum(a * b for a, b in zip(row, col)) for col in zip(*matrix_b)]
+ for row in matrix_a
+ ]
+
+
+def matrix_multiply_recursive(matrix_a: Matrix, matrix_b: Matrix) -> Matrix:
+ """
+ :param matrix_a: A square Matrix.
+ :param matrix_b: Another square Matrix with the same dimensions as matrix_a.
+ :return: Result of matrix_a * matrix_b.
+ :raises ValueError: If the matrices cannot be multiplied.
+
+ >>> matrix_multiply_recursive([], [])
+ []
+ >>> matrix_multiply_recursive(matrix_1_to_4, matrix_5_to_8)
+ [[19, 22], [43, 50]]
+ >>> matrix_multiply_recursive(matrix_count_up, matrix_unordered)
+ [[37, 61, 74, 61], [105, 165, 166, 129], [173, 269, 258, 197], [241, 373, 350, 265]]
+ >>> matrix_multiply_recursive(matrix_1_to_4, matrix_5_to_9_wide)
+ Traceback (most recent call last):
+ ...
+ ValueError: Invalid matrix dimensions
+ >>> matrix_multiply_recursive(matrix_1_to_4, matrix_5_to_9_high)
+ Traceback (most recent call last):
+ ...
+ ValueError: Invalid matrix dimensions
+ >>> matrix_multiply_recursive(matrix_1_to_4, matrix_count_up)
+ Traceback (most recent call last):
+ ...
+ ValueError: Invalid matrix dimensions
+ """
+ if not matrix_a or not matrix_b:
+ return []
+ if not all(
+ (len(matrix_a) == len(matrix_b), is_square(matrix_a), is_square(matrix_b))
+ ):
+ raise ValueError("Invalid matrix dimensions")
+
+ # Initialize the result matrix with zeros
+ result = [[0] * len(matrix_b[0]) for _ in range(len(matrix_a))]
+
+ # Recursive multiplication of matrices
+ def multiply(
+ i_loop: int,
+ j_loop: int,
+ k_loop: int,
+ matrix_a: Matrix,
+ matrix_b: Matrix,
+ result: Matrix,
+ ) -> None:
+ """
+ :param matrix_a: A square Matrix.
+ :param matrix_b: Another square Matrix with the same dimensions as matrix_a.
+ :param result: Result matrix
+ :param i: Index used for iteration during multiplication.
+ :param j: Index used for iteration during multiplication.
+ :param k: Index used for iteration during multiplication.
+ >>> 0 > 1 # Doctests in inner functions are never run
+ True
+ """
+ if i_loop >= len(matrix_a):
+ return
+ if j_loop >= len(matrix_b[0]):
+ return multiply(i_loop + 1, 0, 0, matrix_a, matrix_b, result)
+ if k_loop >= len(matrix_b):
+ return multiply(i_loop, j_loop + 1, 0, matrix_a, matrix_b, result)
+ result[i_loop][j_loop] += matrix_a[i_loop][k_loop] * matrix_b[k_loop][j_loop]
+ return multiply(i_loop, j_loop, k_loop + 1, matrix_a, matrix_b, result)
+
+ # Perform the recursive matrix multiplication
+ multiply(0, 0, 0, matrix_a, matrix_b, result)
+ return result
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ failure_count, test_count = testmod()
+ if not failure_count:
+ matrix_a = matrices[0]
+ for matrix_b in matrices[1:]:
+ print("Multiplying:")
+ for row in matrix_a:
+ print(row)
+ print("By:")
+ for row in matrix_b:
+ print(row)
+ print("Result:")
+ try:
+ result = matrix_multiply_recursive(matrix_a, matrix_b)
+ for row in result:
+ print(row)
+ assert result == matrix_multiply(matrix_a, matrix_b)
+ except ValueError as e:
+ print(f"{e!r}")
+ print()
+ matrix_a = matrix_b
+
+ print("Benchmark:")
+ from functools import partial
+ from timeit import timeit
+
+ mytimeit = partial(timeit, globals=globals(), number=100_000)
+ for func in ("matrix_multiply", "matrix_multiply_recursive"):
+ print(f"{func:>25}(): {mytimeit(f'{func}(matrix_count_up, matrix_unordered)')}")
diff --git a/matrix/matrix_operation.py b/matrix/matrix_operation.py
index dca01f9c3183..d63e758f1838 100644
--- a/matrix/matrix_operation.py
+++ b/matrix/matrix_operation.py
@@ -4,8 +4,10 @@
from __future__ import annotations
+from typing import Any
-def add(*matrix_s: list[list]) -> list[list]:
+
+def add(*matrix_s: list[list[int]]) -> list[list[int]]:
"""
>>> add([[1,2],[3,4]],[[2,3],[4,5]])
[[3, 5], [7, 9]]
@@ -13,19 +15,28 @@ def add(*matrix_s: list[list]) -> list[list]:
[[3.2, 5.4], [7, 9]]
>>> add([[1, 2], [4, 5]], [[3, 7], [3, 4]], [[3, 5], [5, 7]])
[[7, 14], [12, 16]]
+ >>> add([3], [4, 5])
+ Traceback (most recent call last):
+ ...
+ TypeError: Expected a matrix, got int/list instead
"""
if all(_check_not_integer(m) for m in matrix_s):
for i in matrix_s[1:]:
_verify_matrix_sizes(matrix_s[0], i)
return [[sum(t) for t in zip(*m)] for m in zip(*matrix_s)]
+ raise TypeError("Expected a matrix, got int/list instead")
-def subtract(matrix_a: list[list], matrix_b: list[list]) -> list[list]:
+def subtract(matrix_a: list[list[int]], matrix_b: list[list[int]]) -> list[list[int]]:
"""
>>> subtract([[1,2],[3,4]],[[2,3],[4,5]])
[[-1, -1], [-1, -1]]
>>> subtract([[1,2.5],[3,4]],[[2,3],[4,5.5]])
[[-1, -0.5], [-1, -1.5]]
+ >>> subtract([3], [4, 5])
+ Traceback (most recent call last):
+ ...
+ TypeError: Expected a matrix, got int/list instead
"""
if (
_check_not_integer(matrix_a)
@@ -33,9 +44,10 @@ def subtract(matrix_a: list[list], matrix_b: list[list]) -> list[list]:
and _verify_matrix_sizes(matrix_a, matrix_b)
):
return [[i - j for i, j in zip(*m)] for m in zip(matrix_a, matrix_b)]
+ raise TypeError("Expected a matrix, got int/list instead")
-def scalar_multiply(matrix: list[list], n: int) -> list[list]:
+def scalar_multiply(matrix: list[list[int]], n: float) -> list[list[float]]:
"""
>>> scalar_multiply([[1,2],[3,4]],5)
[[5, 10], [15, 20]]
@@ -45,7 +57,7 @@ def scalar_multiply(matrix: list[list], n: int) -> list[list]:
return [[x * n for x in row] for row in matrix]
-def multiply(matrix_a: list[list], matrix_b: list[list]) -> list[list]:
+def multiply(matrix_a: list[list[int]], matrix_b: list[list[int]]) -> list[list[int]]:
"""
>>> multiply([[1,2],[3,4]],[[5,5],[7,5]])
[[19, 15], [43, 35]]
@@ -58,16 +70,17 @@ def multiply(matrix_a: list[list], matrix_b: list[list]) -> list[list]:
rows, cols = _verify_matrix_sizes(matrix_a, matrix_b)
if cols[0] != rows[1]:
- raise ValueError(
- f"Cannot multiply matrix of dimensions ({rows[0]},{cols[0]}) "
- f"and ({rows[1]},{cols[1]})"
+ msg = (
+ "Cannot multiply matrix of dimensions "
+ f"({rows[0]},{cols[0]}) and ({rows[1]},{cols[1]})"
)
+ raise ValueError(msg)
return [
[sum(m * n for m, n in zip(i, j)) for j in zip(*matrix_b)] for i in matrix_a
]
-def identity(n: int) -> list[list]:
+def identity(n: int) -> list[list[int]]:
"""
:param n: dimension for nxn matrix
:type n: int
@@ -79,21 +92,28 @@ def identity(n: int) -> list[list]:
return [[int(row == column) for column in range(n)] for row in range(n)]
-def transpose(matrix: list[list], return_map: bool = True) -> list[list]:
+def transpose(
+ matrix: list[list[int]], return_map: bool = True
+) -> list[list[int]] | map[list[int]]:
"""
>>> transpose([[1,2],[3,4]]) # doctest: +ELLIPSIS