From e1b9098663fa1758bfaf054534784f7c9f26d5b2 Mon Sep 17 00:00:00 2001 From: KRISHNA DIPAYAN BHUNIA Date: Thu, 9 Jan 2025 17:18:40 +0530 Subject: [PATCH 1/9] singelton class --- design_patterns/singleton_dp.ipynb | 59 +++++++++++++++++++++++++++++- 1 file changed, 58 insertions(+), 1 deletion(-) diff --git a/design_patterns/singleton_dp.ipynb b/design_patterns/singleton_dp.ipynb index 24d56c9..eb396ee 100644 --- a/design_patterns/singleton_dp.ipynb +++ b/design_patterns/singleton_dp.ipynb @@ -10,9 +10,18 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 1, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "Instance1\n", + "Instance1\n" + ] + }, { "name": "stdout", "output_type": "stream", @@ -49,6 +58,54 @@ "print(singleton1.value) # \"Instance1\"\n", "print(singleton2.value) # \"Instance1\" (value does not change)\n" ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "notebookRunGroups": { + "groupValue": "2" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "__new__ called\n", + "__init__ called\n", + "__new__ called\n", + "__init__ called\n", + "True\n", + "First\n", + "First\n" + ] + } + ], + "source": [ + "class Singleton:\n", + " _instance = None\n", + "\n", + " def __new__(cls, *args, **kwargs):\n", + " print(\"__new__ called\")\n", + " if cls._instance is None:\n", + " cls._instance = super().__new__(cls)\n", + " return cls._instance\n", + "\n", + " def __init__(self, value):\n", + " print(\"__init__ called\")\n", + " if not hasattr(self, \"value\"): # Ensures value is set only once\n", + " self.value = value\n", + "\n", + "\n", + "# Creating instances\n", + "s1 = Singleton(\"First\")\n", + "s2 = Singleton(\"Second\")\n", + "\n", + "print(s1 is s2) # True (Same instance)\n", + "print(s1.value) # \"First\"\n", + "print(s2.value) # \"First\"\n" + ] } ], "metadata": { From a4e0355cb0a36bb7629dca1b432d0694ecfe77f5 Mon Sep 17 00:00:00 2001 From: KRISHNA DIPAYAN BHUNIA Date: Thu, 9 Jan 2025 19:46:41 +0530 Subject: [PATCH 2/9] multitasking --- .../Multitasking/README.md | 7 +++ .../Multitasking/multitasking_demo.ipynb | 57 +++++++++++++++++++ 2 files changed, 64 insertions(+) create mode 100644 Multi Parallel Programming/Multitasking/README.md create mode 100644 Multi Parallel Programming/Multitasking/multitasking_demo.ipynb diff --git a/Multi Parallel Programming/Multitasking/README.md b/Multi Parallel Programming/Multitasking/README.md new file mode 100644 index 0000000..3f52b15 --- /dev/null +++ b/Multi Parallel Programming/Multitasking/README.md @@ -0,0 +1,7 @@ +## **Multitasking (concurrent.futures & asyncio)** + +* **Used for:** Handling multiple tasks efficiently, especially I/O-bound tasks. +* **Options:** + * **ThreadPoolExecutor** (for I/O-bound tasks) + * **ProcessPoolExecutor** (for CPU-bound tasks) + * **asyncio** (for asynchronous programming) diff --git a/Multi Parallel Programming/Multitasking/multitasking_demo.ipynb b/Multi Parallel Programming/Multitasking/multitasking_demo.ipynb new file mode 100644 index 0000000..87e4016 --- /dev/null +++ b/Multi Parallel Programming/Multitasking/multitasking_demo.ipynb @@ -0,0 +1,57 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Task 0 start: 02 end: 04', 'Task 1 start: 02 end: 04', 'Task 2 start: 02 end: 04', 'Task 3 start: 04 end: 06', 'Task 4 start: 04 end: 06']\n" + ] + } + ], + "source": [ + "from concurrent.futures import ThreadPoolExecutor\n", + "import time\n", + "\n", + "def get_time():\n", + " return time.strftime(\"%S\")\n", + "\n", + "def task(n):\n", + " start = get_time()\n", + " time.sleep(2)\n", + " end = get_time()\n", + " return f\"Task {n} start: {start} end: {end}\"\n", + "\n", + "with ThreadPoolExecutor(max_workers=3) as executor:\n", + " results = list(executor.map(task, range(5)))\n", + "\n", + "print(results)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 7990d727026cbda9028aa95305b8625426f6f40a Mon Sep 17 00:00:00 2001 From: KRISHNA DIPAYAN BHUNIA Date: Tue, 1 Apr 2025 12:15:19 +0530 Subject: [PATCH 3/9] ok --- abstract example.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/abstract example.ipynb b/abstract example.ipynb index 6f8c2cc..5f2b277 100644 --- a/abstract example.ipynb +++ b/abstract example.ipynb @@ -523,7 +523,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -537,7 +537,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.12.4" } }, "nbformat": 4, From 197769e1f177d1af964050eb9bf181c762238f9c Mon Sep 17 00:00:00 2001 From: KRISHNA DIPAYAN BHUNIA Date: Tue, 15 Apr 2025 16:13:36 +0530 Subject: [PATCH 4/9] move files --- .../Altimetrik.ipynb | 0 ...ees Earning More Than Their Managers.ipynb | 0 .../Hybrid Intelligence.ipynb | 0 .../Interview Question.ipynb | 0 LICENSE => Basic python/LICENSE | 0 .../abstract example.ipynb | 0 .../arr traversal.ipynb | 0 .../class and variables.ipynb | 0 .../class oops concept.ipynb | 0 .../classInheritSuper.ipynb | 0 cmds.cmd => Basic python/cmds.cmd | 0 .../csp tsp interview.ipynb | 0 .../dict expression.ipynb | 0 .../duplicate emails.ipynb | 0 .../fibonnaci.ipynb | 0 .../mongodb test.ipynb | 0 .../multiprocessing.ipynb | 0 .../numPyPractise.ipynb | 0 .../pandasPractice.ipynb | 0 .../pandasSQLLeetcode.ipynb | 0 .../practice sessions.ipynb | 0 .../private variables in class.ipynb | 0 .../protected variables.ipynb | 0 .../set_operations.ipynb | 0 test_prog.py => Basic python/test_prog.py | 0 Candidate Interview/pandas_program.ipynb | 14723 ++++++++++++++++ 26 files changed, 14723 insertions(+) rename Altimetrik.ipynb => Basic python/Altimetrik.ipynb (100%) rename Employees Earning More Than Their Managers.ipynb => Basic python/Employees Earning More Than Their Managers.ipynb (100%) rename Hybrid Intelligence.ipynb => Basic python/Hybrid Intelligence.ipynb (100%) rename Interview Question.ipynb => Basic python/Interview Question.ipynb (100%) rename LICENSE => Basic python/LICENSE (100%) rename abstract example.ipynb => Basic python/abstract example.ipynb (100%) rename arr traversal.ipynb => Basic python/arr traversal.ipynb (100%) rename class and variables.ipynb => Basic python/class and variables.ipynb (100%) rename class oops concept.ipynb => Basic python/class oops concept.ipynb (100%) rename classInheritSuper.ipynb => Basic python/classInheritSuper.ipynb (100%) rename cmds.cmd => Basic python/cmds.cmd (100%) rename csp tsp interview.ipynb => Basic python/csp tsp interview.ipynb (100%) rename dict expression.ipynb => Basic python/dict expression.ipynb (100%) rename duplicate emails.ipynb => Basic python/duplicate emails.ipynb (100%) rename fibonnaci.ipynb => Basic python/fibonnaci.ipynb (100%) rename mongodb test.ipynb => Basic python/mongodb test.ipynb (100%) rename multiprocessing.ipynb => Basic python/multiprocessing.ipynb (100%) rename numPyPractise.ipynb => Basic python/numPyPractise.ipynb (100%) rename pandasPractice.ipynb => Basic python/pandasPractice.ipynb (100%) rename pandasSQLLeetcode.ipynb => Basic python/pandasSQLLeetcode.ipynb (100%) rename practice sessions.ipynb => Basic python/practice sessions.ipynb (100%) rename private variables in class.ipynb => Basic python/private variables in class.ipynb (100%) rename protected variables.ipynb => Basic python/protected variables.ipynb (100%) rename set_operations.ipynb => Basic python/set_operations.ipynb (100%) rename test_prog.py => Basic python/test_prog.py (100%) create mode 100644 Candidate Interview/pandas_program.ipynb diff --git a/Altimetrik.ipynb b/Basic python/Altimetrik.ipynb similarity index 100% rename from Altimetrik.ipynb rename to Basic python/Altimetrik.ipynb diff --git a/Employees Earning More Than Their Managers.ipynb b/Basic python/Employees Earning More Than Their Managers.ipynb similarity index 100% rename from Employees Earning More Than Their Managers.ipynb rename to Basic python/Employees Earning More Than Their Managers.ipynb diff --git a/Hybrid Intelligence.ipynb b/Basic python/Hybrid Intelligence.ipynb similarity index 100% rename from Hybrid Intelligence.ipynb rename to Basic python/Hybrid Intelligence.ipynb diff --git a/Interview Question.ipynb b/Basic python/Interview Question.ipynb similarity index 100% rename from Interview Question.ipynb rename to Basic python/Interview Question.ipynb diff --git a/LICENSE b/Basic python/LICENSE similarity index 100% rename from LICENSE rename to Basic python/LICENSE diff --git a/abstract example.ipynb b/Basic python/abstract example.ipynb similarity index 100% rename from abstract example.ipynb rename to Basic python/abstract example.ipynb diff --git a/arr traversal.ipynb b/Basic python/arr traversal.ipynb similarity index 100% rename from arr traversal.ipynb rename to Basic python/arr traversal.ipynb diff --git a/class and variables.ipynb b/Basic python/class and variables.ipynb similarity index 100% rename from class and variables.ipynb rename to Basic python/class and variables.ipynb diff --git a/class oops concept.ipynb b/Basic python/class oops concept.ipynb similarity index 100% rename from class oops concept.ipynb rename to Basic python/class oops concept.ipynb diff --git a/classInheritSuper.ipynb b/Basic python/classInheritSuper.ipynb similarity index 100% rename from classInheritSuper.ipynb rename to Basic python/classInheritSuper.ipynb diff --git a/cmds.cmd b/Basic python/cmds.cmd similarity index 100% rename from cmds.cmd rename to Basic python/cmds.cmd diff --git a/csp tsp interview.ipynb b/Basic python/csp tsp interview.ipynb similarity index 100% rename from csp tsp interview.ipynb rename to Basic python/csp tsp interview.ipynb diff --git a/dict expression.ipynb b/Basic python/dict expression.ipynb similarity index 100% rename from dict expression.ipynb rename to Basic python/dict expression.ipynb diff --git a/duplicate emails.ipynb b/Basic python/duplicate emails.ipynb similarity index 100% rename from duplicate emails.ipynb rename to Basic python/duplicate emails.ipynb diff --git a/fibonnaci.ipynb b/Basic python/fibonnaci.ipynb similarity index 100% rename from fibonnaci.ipynb rename to Basic python/fibonnaci.ipynb diff --git a/mongodb test.ipynb b/Basic python/mongodb test.ipynb similarity index 100% rename from mongodb test.ipynb rename to Basic python/mongodb test.ipynb diff --git a/multiprocessing.ipynb b/Basic python/multiprocessing.ipynb similarity index 100% rename from multiprocessing.ipynb rename to Basic python/multiprocessing.ipynb diff --git a/numPyPractise.ipynb b/Basic python/numPyPractise.ipynb similarity index 100% rename from numPyPractise.ipynb rename to Basic python/numPyPractise.ipynb diff --git a/pandasPractice.ipynb b/Basic python/pandasPractice.ipynb similarity index 100% rename from pandasPractice.ipynb rename to Basic python/pandasPractice.ipynb diff --git a/pandasSQLLeetcode.ipynb b/Basic python/pandasSQLLeetcode.ipynb similarity index 100% rename from pandasSQLLeetcode.ipynb rename to Basic python/pandasSQLLeetcode.ipynb diff --git a/practice sessions.ipynb b/Basic python/practice sessions.ipynb similarity index 100% rename from practice sessions.ipynb rename to Basic python/practice sessions.ipynb diff --git a/private variables in class.ipynb b/Basic python/private variables in class.ipynb similarity index 100% rename from private variables in class.ipynb rename to Basic python/private variables in class.ipynb diff --git a/protected variables.ipynb b/Basic python/protected variables.ipynb similarity index 100% rename from protected variables.ipynb rename to Basic python/protected variables.ipynb diff --git a/set_operations.ipynb b/Basic python/set_operations.ipynb similarity index 100% rename from set_operations.ipynb rename to Basic python/set_operations.ipynb diff --git a/test_prog.py b/Basic python/test_prog.py similarity index 100% rename from test_prog.py rename to Basic python/test_prog.py diff --git a/Candidate Interview/pandas_program.ipynb b/Candidate Interview/pandas_program.ipynb new file mode 100644 index 0000000..5a2b73a --- /dev/null +++ b/Candidate Interview/pandas_program.ipynb @@ -0,0 +1,14723 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/30/d2x00hds1rdg0vwzqncdyqz80000gp/T/ipykernel_3914/3647442266.py:7: DeprecationWarning: This function is deprecated. Please call randint(1, 300 + 1) instead\n", + " 'B': np.random.random_integers(300),\n" + ] + }, + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "A", + "rawType": "float64", + "type": "float" + }, + { + "name": "B", + "rawType": "int64", + "type": "integer" + }, + { + "name": "C", + "rawType": "float64", + "type": "float" + } + ], + "conversionMethod": "pd.DataFrame", + "ref": "80f74aa1-e716-440e-be9a-1779eb7564f4", + "rows": [ + [ + "0", + "2.374735922001252", + "107", + "1.4610619527630395" + ], + [ + "1", + "-0.5618535517937199", + "107", + "0.19192208894448984" + ], + [ + "2", + "0.48128942754051407", + "107", + "-0.7186070332984024" + ], + [ + "3", + "-0.22496925122249672", + "107", + "2.2449821637649734" + ], + [ + "4", + "1.294553170190664", + "107", + "-0.053895169203449105" + ], + [ + "5", + "0.058525831771919216", + "107", + "0.8682457315260561" + ], + [ + "6", + "-1.1032613456846516", + "107", + "-1.4710187256285383" + ], + [ + "7", + "0.9738980014467691", + "107", + "-0.1874571735961874" + ], + [ + "8", + "0.32545803171139975", + "107", + "0.7153900819794405" + ], + [ + "9", + "2.0660995992436018", + "107", + "-0.07228114728115244" + ], + [ + "10", + "1.6387514717671863", + "107", + "0.2004724187314635" + ], + [ + "11", + "-2.839597285433967", + "107", + "-0.4386247964305805" + ], + [ + "12", + "2.3169377551140418", + "107", + "0.849579160599714" + ], + [ + "13", + "0.9209074393868837", + "107", + "-0.4444153281093881" + ], + [ + "14", + "-1.5044153538115812", + "107", + "0.4446134130966002" + ], + [ + "15", + "1.5695518606012648", + "107", + "-1.7928560122413844" + ], + [ + "16", + "0.004827697845084351", + "107", + "-0.14688885135483734" + ], + [ + "17", + "-0.048217097717830996", + "107", + "-1.6324248682577553" + ], + [ + "18", + "-1.5359540823399316", + "107", + "-1.669533293386337" + ], + [ + "19", + "-0.9530619368989881", + "107", + "-0.6951011490306881" + ], + [ + "20", + "-0.5510000826175417", + "107", + "0.2722046082492214" + ], + [ + "21", + "1.3634583887946388", + "107", + "-1.0207776739699703" + ], + [ + "22", + "2.7234187143862116", + "107", + "0.054617055533465464" + ], + [ + "23", + "-1.166322111900619", + "107", + "-0.04335155306216916" + ], + [ + "24", + "0.18651549389688335", + "107", + "0.33309073102275205" + ], + [ + "25", + "0.5908107595531694", + "107", + "-0.19651569290954968" + ], + [ + "26", + "1.3037711943330912", + "107", + "-0.5429700277549696" + ], + [ + "27", + "0.1436669557955834", + "107", + "-2.020063217217287" + ], + [ + "28", + "-0.6121571664706843", + "107", + "1.5114428052946307" + ], + [ + "29", + "1.7497927707841585", + "107", + "0.2863904799863863" + ], + [ + "30", + "-2.155170654564772", + "107", + "-0.276666712277675" + ], + [ + "31", + "0.672994697886957", + "107", + "1.016625327880247" + ], + [ + "32", + "0.7756594072424987", + "107", + "0.2956242473497136" + ], + [ + "33", + "-0.7986999562537076", + "107", + "0.9395312274027844" + ], + [ + "34", + "-0.2373046431471692", + "107", + "0.42883166643041315" + ], + [ + "35", + "0.16935780175705312", + "107", + "-0.16724697222997897" + ], + [ + "36", + "-0.38859934612329866", + "107", + "-0.59921039324077" + ], + [ + "37", + "-1.087558625310206", + "107", + "0.4830922437793807" + ], + [ + "38", + "1.6075705965315936", + "107", + "1.0335209388895523" + ], + [ + "39", + "-0.9726367585230138", + "107", + "1.3943234616490823" + ], + [ + "40", + "0.1401236439968343", + "107", + "1.9991132660399489" + ], + [ + "41", + "-1.5874885386132978", + "107", + "1.6681225699796232" + ], + [ + "42", + "-0.8588573359746461", + "107", + "-1.5198603847994274" + ], + [ + "43", + "1.507868377475159", + "107", + "0.46887922989830183" + ], + [ + "44", + "-0.35005967371261976", + "107", + "-0.39303908189771164" + ], + [ + "45", + "1.883394545254388", + "107", + "-2.1253853966864584" + ], + [ + "46", + "1.5748854612580956", + "107", + "-2.0776573159166296" + ], + [ + "47", + "0.9583503895626445", + "107", + "2.346874406706858" + ], + [ + "48", + "0.20224036771385803", + "107", + "-0.3167136469090614" + ], + [ + "49", + "-1.44912630504906", + "107", + "1.908447504341495" + ] + ], + "shape": { + "columns": 3, + "rows": 300 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ABC
02.3747361071.461062
1-0.5618541070.191922
20.481289107-0.718607
3-0.2249691072.244982
41.294553107-0.053895
............
2950.121822107-0.221466
296-1.460891107-0.613256
2970.1960371071.660419
2980.574601107-0.710114
2990.4622041071.071295
\n", + "

300 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " A B C\n", + "0 2.374736 107 1.461062\n", + "1 -0.561854 107 0.191922\n", + "2 0.481289 107 -0.718607\n", + "3 -0.224969 107 2.244982\n", + "4 1.294553 107 -0.053895\n", + ".. ... ... ...\n", + "295 0.121822 107 -0.221466\n", + "296 -1.460891 107 -0.613256\n", + "297 0.196037 107 1.660419\n", + "298 0.574601 107 -0.710114\n", + "299 0.462204 107 1.071295\n", + "\n", + "[300 rows x 3 columns]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "# Create a DataFrame\n", + "df = pd.DataFrame({\n", + " 'A': np.random.randn(300),\n", + " 'B': np.random.ra(300),\n", + " 'C': np.random.randn(300),\n", + "\n", + "})\n", + "\n", + "# Drop rows with missing values\n", + "df.dropna()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on package numpy.random in numpy:\n", + "\n", + "NAME\n", + " numpy.random\n", + "\n", + "DESCRIPTION\n", + " ========================\n", + " Random Number Generation\n", + " ========================\n", + "\n", + " Use ``default_rng()`` to create a `Generator` and call its methods.\n", + "\n", + " =============== =========================================================\n", + " Generator\n", + " --------------- ---------------------------------------------------------\n", + " Generator Class implementing all of the random number distributions\n", + " default_rng Default constructor for ``Generator``\n", + " =============== =========================================================\n", + "\n", + " ============================================= ===\n", + " BitGenerator Streams that work with Generator\n", + " --------------------------------------------- ---\n", + " MT19937\n", + " PCG64\n", + " PCG64DXSM\n", + " Philox\n", + " SFC64\n", + " ============================================= ===\n", + "\n", + " ============================================= ===\n", + " Getting entropy to initialize a BitGenerator\n", + " --------------------------------------------- ---\n", + " SeedSequence\n", + " ============================================= ===\n", + "\n", + "\n", + " Legacy\n", + " ------\n", + "\n", + " For backwards compatibility with previous versions of numpy before 1.17, the\n", + " various aliases to the global `RandomState` methods are left alone and do not\n", + " use the new `Generator` API.\n", + "\n", + " ==================== =========================================================\n", + " Utility functions\n", + " -------------------- ---------------------------------------------------------\n", + " random Uniformly distributed floats over ``[0, 1)``\n", + " bytes Uniformly distributed random bytes.\n", + " permutation Randomly permute a sequence / generate a random sequence.\n", + " shuffle Randomly permute a sequence in place.\n", + " choice Random sample from 1-D array.\n", + " ==================== =========================================================\n", + "\n", + " ==================== =========================================================\n", + " Compatibility\n", + " functions - removed\n", + " in the new API\n", + " -------------------- ---------------------------------------------------------\n", + " rand Uniformly distributed values.\n", + " randn Normally distributed values.\n", + " ranf Uniformly distributed floating point numbers.\n", + " random_integers Uniformly distributed integers in a given range.\n", + " (deprecated, use ``integers(..., closed=True)`` instead)\n", + " random_sample Alias for `random_sample`\n", + " randint Uniformly distributed integers in a given range\n", + " seed Seed the legacy random number generator.\n", + " ==================== =========================================================\n", + "\n", + " ==================== =========================================================\n", + " Univariate\n", + " distributions\n", + " -------------------- ---------------------------------------------------------\n", + " beta Beta distribution over ``[0, 1]``.\n", + " binomial Binomial distribution.\n", + " chisquare :math:`\\chi^2` distribution.\n", + " exponential Exponential distribution.\n", + " f F (Fisher-Snedecor) distribution.\n", + " gamma Gamma distribution.\n", + " geometric Geometric distribution.\n", + " gumbel Gumbel distribution.\n", + " hypergeometric Hypergeometric distribution.\n", + " laplace Laplace distribution.\n", + " logistic Logistic distribution.\n", + " lognormal Log-normal distribution.\n", + " logseries Logarithmic series distribution.\n", + " negative_binomial Negative binomial distribution.\n", + " noncentral_chisquare Non-central chi-square distribution.\n", + " noncentral_f Non-central F distribution.\n", + " normal Normal / Gaussian distribution.\n", + " pareto Pareto distribution.\n", + " poisson Poisson distribution.\n", + " power Power distribution.\n", + " rayleigh Rayleigh distribution.\n", + " triangular Triangular distribution.\n", + " uniform Uniform distribution.\n", + " vonmises Von Mises circular distribution.\n", + " wald Wald (inverse Gaussian) distribution.\n", + " weibull Weibull distribution.\n", + " zipf Zipf's distribution over ranked data.\n", + " ==================== =========================================================\n", + "\n", + " ==================== ==========================================================\n", + " Multivariate\n", + " distributions\n", + " -------------------- ----------------------------------------------------------\n", + " dirichlet Multivariate generalization of Beta distribution.\n", + " multinomial Multivariate generalization of the binomial distribution.\n", + " multivariate_normal Multivariate generalization of the normal distribution.\n", + " ==================== ==========================================================\n", + "\n", + " ==================== =========================================================\n", + " Standard\n", + " distributions\n", + " -------------------- ---------------------------------------------------------\n", + " standard_cauchy Standard Cauchy-Lorentz distribution.\n", + " standard_exponential Standard exponential distribution.\n", + " standard_gamma Standard Gamma distribution.\n", + " standard_normal Standard normal distribution.\n", + " standard_t Standard Student's t-distribution.\n", + " ==================== =========================================================\n", + "\n", + " ==================== =========================================================\n", + " Internal functions\n", + " -------------------- ---------------------------------------------------------\n", + " get_state Get tuple representing internal state of generator.\n", + " set_state Set state of generator.\n", + " ==================== =========================================================\n", + "\n", + "PACKAGE CONTENTS\n", + " _bounded_integers\n", + " _common\n", + " _generator\n", + " _mt19937\n", + " _pcg64\n", + " _philox\n", + " _pickle\n", + " _sfc64\n", + " bit_generator\n", + " mtrand\n", + " tests (package)\n", + "\n", + "CLASSES\n", + " builtins.object\n", + " numpy.random._generator.Generator\n", + " numpy.random.bit_generator.BitGenerator\n", + " numpy.random._mt19937.MT19937\n", + " numpy.random._pcg64.PCG64\n", + " numpy.random._pcg64.PCG64DXSM\n", + " numpy.random._philox.Philox\n", + " numpy.random._sfc64.SFC64\n", + " numpy.random.bit_generator.SeedSequence\n", + " numpy.random.mtrand.RandomState\n", + "\n", + " class BitGenerator(builtins.object)\n", + " | BitGenerator(seed=None)\n", + " |\n", + " | Base Class for generic BitGenerators, which provide a stream\n", + " | of random bits based on different algorithms. Must be overridden.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | seed : {None, int, array_like[ints], SeedSequence}, optional\n", + " | A seed to initialize the `BitGenerator`. If None, then fresh,\n", + " | unpredictable entropy will be pulled from the OS. If an ``int`` or\n", + " | ``array_like[ints]`` is passed, then it will be passed to\n", + " | `~numpy.random.SeedSequence` to derive the initial `BitGenerator` state.\n", + " | One may also pass in a `SeedSequence` instance.\n", + " | All integer values must be non-negative.\n", + " |\n", + " | Attributes\n", + " | ----------\n", + " | lock : threading.Lock\n", + " | Lock instance that is shared so that the same BitGenerator can\n", + " | be used in multiple Generators without corrupting the state. Code that\n", + " | generates values from a bit generator should hold the bit generator's\n", + " | lock.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | SeedSequence\n", + " |\n", + " | Methods defined here:\n", + " |\n", + " | __getstate__(self)\n", + " |\n", + " | __init__(self, /, *args, **kwargs)\n", + " | Initialize self. See help(type(self)) for accurate signature.\n", + " |\n", + " | __reduce__(self)\n", + " |\n", + " | __setstate__(self, state_seed_seq)\n", + " |\n", + " | random_raw(self, size=None, output=True)\n", + " | random_raw(self, size=None)\n", + " |\n", + " | Return randoms as generated by the underlying BitGenerator\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " | output : bool, optional\n", + " | Output values. Used for performance testing since the generated\n", + " | values are not returned.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : uint or ndarray\n", + " | Drawn samples.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | This method directly exposes the raw underlying pseudo-random\n", + " | number generator. All values are returned as unsigned 64-bit\n", + " | values irrespective of the number of bits produced by the PRNG.\n", + " |\n", + " | See the class docstring for the number of bits returned.\n", + " |\n", + " | spawn(self, n_children)\n", + " | spawn(n_children)\n", + " |\n", + " | Create new independent child bit generators.\n", + " |\n", + " | See :ref:`seedsequence-spawn` for additional notes on spawning\n", + " | children. Some bit generators also implement ``jumped``\n", + " | as a different approach for creating independent streams.\n", + " |\n", + " | .. versionadded:: 1.25.0\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | n_children : int\n", + " |\n", + " | Returns\n", + " | -------\n", + " | child_bit_generators : list of BitGenerators\n", + " |\n", + " | Raises\n", + " | ------\n", + " | TypeError\n", + " | When the underlying SeedSequence does not implement spawning.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.spawn, random.SeedSequence.spawn :\n", + " | Equivalent method on the generator and seed sequence.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Static methods defined here:\n", + " |\n", + " | __new__(*args, **kwargs)\n", + " | Create and return a new object. See help(type) for accurate signature.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors defined here:\n", + " |\n", + " | capsule\n", + " |\n", + " | cffi\n", + " | CFFI interface\n", + " |\n", + " | Returns\n", + " | -------\n", + " | interface : namedtuple\n", + " | Named tuple containing CFFI wrapper\n", + " |\n", + " | * state_address - Memory address of the state struct\n", + " | * state - pointer to the state struct\n", + " | * next_uint64 - function pointer to produce 64 bit integers\n", + " | * next_uint32 - function pointer to produce 32 bit integers\n", + " | * next_double - function pointer to produce doubles\n", + " | * bitgen - pointer to the bit generator struct\n", + " |\n", + " | ctypes\n", + " | ctypes interface\n", + " |\n", + " | Returns\n", + " | -------\n", + " | interface : namedtuple\n", + " | Named tuple containing ctypes wrapper\n", + " |\n", + " | * state_address - Memory address of the state struct\n", + " | * state - pointer to the state struct\n", + " | * next_uint64 - function pointer to produce 64 bit integers\n", + " | * next_uint32 - function pointer to produce 32 bit integers\n", + " | * next_double - function pointer to produce doubles\n", + " | * bitgen - pointer to the bit generator struct\n", + " |\n", + " | lock\n", + " |\n", + " | seed_seq\n", + " | Get the seed sequence used to initialize the bit generator.\n", + " |\n", + " | .. versionadded:: 1.25.0\n", + " |\n", + " | Returns\n", + " | -------\n", + " | seed_seq : ISeedSequence\n", + " | The SeedSequence object used to initialize the BitGenerator.\n", + " | This is normally a `np.random.SeedSequence` instance.\n", + " |\n", + " | state\n", + " | Get or set the PRNG state\n", + " |\n", + " | The base BitGenerator.state must be overridden by a subclass\n", + " |\n", + " | Returns\n", + " | -------\n", + " | state : dict\n", + " | Dictionary containing the information required to describe the\n", + " | state of the PRNG\n", + "\n", + " class Generator(builtins.object)\n", + " | Generator(bit_generator)\n", + " |\n", + " | Container for the BitGenerators.\n", + " |\n", + " | `Generator` exposes a number of methods for generating random\n", + " | numbers drawn from a variety of probability distributions. In addition to\n", + " | the distribution-specific arguments, each method takes a keyword argument\n", + " | `size` that defaults to ``None``. If `size` is ``None``, then a single\n", + " | value is generated and returned. If `size` is an integer, then a 1-D\n", + " | array filled with generated values is returned. If `size` is a tuple,\n", + " | then an array with that shape is filled and returned.\n", + " |\n", + " | The function :func:`numpy.random.default_rng` will instantiate\n", + " | a `Generator` with numpy's default `BitGenerator`.\n", + " |\n", + " | **No Compatibility Guarantee**\n", + " |\n", + " | `Generator` does not provide a version compatibility guarantee. In\n", + " | particular, as better algorithms evolve the bit stream may change.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | bit_generator : BitGenerator\n", + " | BitGenerator to use as the core generator.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The Python stdlib module :external+python:mod:`random` contains\n", + " | pseudo-random number generator with a number of methods that are similar\n", + " | to the ones available in `Generator`.\n", + " | It uses Mersenne Twister, and this bit generator can\n", + " | be accessed using `MT19937`. `Generator`, besides being\n", + " | NumPy-aware, has the advantage that it provides a much larger number\n", + " | of probability distributions to choose from.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> from numpy.random import Generator, PCG64\n", + " | >>> rng = Generator(PCG64())\n", + " | >>> rng.standard_normal()\n", + " | -0.203 # random\n", + " |\n", + " | See Also\n", + " | --------\n", + " | default_rng : Recommended constructor for `Generator`.\n", + " |\n", + " | Methods defined here:\n", + " |\n", + " | __getstate__(self)\n", + " |\n", + " | __init__(self, /, *args, **kwargs)\n", + " | Initialize self. See help(type(self)) for accurate signature.\n", + " |\n", + " | __reduce__(self)\n", + " |\n", + " | __repr__(...)\n", + " | Return repr(self).\n", + " |\n", + " | __setstate__(self, bit_gen)\n", + " |\n", + " | __str__(self, /)\n", + " | Return str(self).\n", + " |\n", + " | beta(self, a, b, size=None)\n", + " | beta(a, b, size=None)\n", + " |\n", + " | Draw samples from a Beta distribution.\n", + " |\n", + " | The Beta distribution is a special case of the Dirichlet distribution,\n", + " | and is related to the Gamma distribution. It has the probability\n", + " | distribution function\n", + " |\n", + " | .. math:: f(x; a,b) = \\frac{1}{B(\\alpha, \\beta)} x^{\\alpha - 1}\n", + " | (1 - x)^{\\beta - 1},\n", + " |\n", + " | where the normalization, B, is the beta function,\n", + " |\n", + " | .. math:: B(\\alpha, \\beta) = \\int_0^1 t^{\\alpha - 1}\n", + " | (1 - t)^{\\beta - 1} dt.\n", + " |\n", + " | It is often seen in Bayesian inference and order statistics.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | a : float or array_like of floats\n", + " | Alpha, positive (>0).\n", + " | b : float or array_like of floats\n", + " | Beta, positive (>0).\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``a`` and ``b`` are both scalars.\n", + " | Otherwise, ``np.broadcast(a, b).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized beta distribution.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | The beta distribution has mean a/(a+b). If ``a == b`` and both\n", + " | are > 1, the distribution is symmetric with mean 0.5.\n", + " |\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> a, b, size = 2.0, 2.0, 10000\n", + " | >>> sample = rng.beta(a=a, b=b, size=size)\n", + " | >>> np.mean(sample)\n", + " | 0.5047328775385895 # may vary\n", + " |\n", + " | Otherwise the distribution is skewed left or right according to\n", + " | whether ``a`` or ``b`` is greater. The distribution is mirror\n", + " | symmetric. See for example:\n", + " |\n", + " | >>> a, b, size = 2, 7, 10000\n", + " | >>> sample_left = rng.beta(a=a, b=b, size=size)\n", + " | >>> sample_right = rng.beta(a=b, b=a, size=size)\n", + " | >>> m_left, m_right = np.mean(sample_left), np.mean(sample_right)\n", + " | >>> print(m_left, m_right)\n", + " | 0.2238596793678923 0.7774613834041182 # may vary\n", + " | >>> print(m_left - a/(a+b))\n", + " | 0.001637457145670096 # may vary\n", + " | >>> print(m_right - b/(a+b))\n", + " | -0.0003163943736596009 # may vary\n", + " |\n", + " | Display the histogram of the two samples:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> plt.hist([sample_left, sample_right],\n", + " | ... 50, density=True, histtype='bar')\n", + " | >>> plt.show()\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Wikipedia, \"Beta distribution\",\n", + " | https://en.wikipedia.org/wiki/Beta_distribution\n", + " |\n", + " | binomial(self, n, p, size=None)\n", + " | binomial(n, p, size=None)\n", + " |\n", + " | Draw samples from a binomial distribution.\n", + " |\n", + " | Samples are drawn from a binomial distribution with specified\n", + " | parameters, n trials and p probability of success where\n", + " | n an integer >= 0 and p is in the interval [0,1]. (n may be\n", + " | input as a float, but it is truncated to an integer in use)\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | n : int or array_like of ints\n", + " | Parameter of the distribution, >= 0. Floats are also accepted,\n", + " | but they will be truncated to integers.\n", + " | p : float or array_like of floats\n", + " | Parameter of the distribution, >= 0 and <=1.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``n`` and ``p`` are both scalars.\n", + " | Otherwise, ``np.broadcast(n, p).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized binomial distribution, where\n", + " | each sample is equal to the number of successes over the n trials.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.binom : probability density function, distribution or\n", + " | cumulative density function, etc.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability mass function (PMF) for the binomial distribution is\n", + " |\n", + " | .. math:: P(N) = \\binom{n}{N}p^N(1-p)^{n-N},\n", + " |\n", + " | where :math:`n` is the number of trials, :math:`p` is the probability\n", + " | of success, and :math:`N` is the number of successes.\n", + " |\n", + " | When estimating the standard error of a proportion in a population by\n", + " | using a random sample, the normal distribution works well unless the\n", + " | product p*n <=5, where p = population proportion estimate, and n =\n", + " | number of samples, in which case the binomial distribution is used\n", + " | instead. For example, a sample of 15 people shows 4 who are left\n", + " | handed, and 11 who are right handed. Then p = 4/15 = 27%. 0.27*15 = 4,\n", + " | so the binomial distribution should be used in this case.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Dalgaard, Peter, \"Introductory Statistics with R\",\n", + " | Springer-Verlag, 2002.\n", + " | .. [2] Glantz, Stanton A. \"Primer of Biostatistics.\", McGraw-Hill,\n", + " | Fifth Edition, 2002.\n", + " | .. [3] Lentner, Marvin, \"Elementary Applied Statistics\", Bogden\n", + " | and Quigley, 1972.\n", + " | .. [4] Weisstein, Eric W. \"Binomial Distribution.\" From MathWorld--A\n", + " | Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/BinomialDistribution.html\n", + " | .. [5] Wikipedia, \"Binomial distribution\",\n", + " | https://en.wikipedia.org/wiki/Binomial_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> n, p, size = 10, .5, 10000\n", + " | >>> s = rng.binomial(n, p, 10000)\n", + " |\n", + " | Assume a company drills 9 wild-cat oil exploration wells, each with\n", + " | an estimated probability of success of ``p=0.1``. All nine wells fail.\n", + " | What is the probability of that happening?\n", + " |\n", + " | Over ``size = 20,000`` trials the probability of this happening\n", + " | is on average:\n", + " |\n", + " | >>> n, p, size = 9, 0.1, 20000\n", + " | >>> np.sum(rng.binomial(n=n, p=p, size=size) == 0)/size\n", + " | 0.39015 # may vary\n", + " |\n", + " | The following can be used to visualize a sample with ``n=100``,\n", + " | ``p=0.4`` and the corresponding probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> from scipy.stats import binom\n", + " | >>> n, p, size = 100, 0.4, 10000\n", + " | >>> sample = rng.binomial(n, p, size=size)\n", + " | >>> count, bins, _ = plt.hist(sample, 30, density=True)\n", + " | >>> x = np.arange(n)\n", + " | >>> y = binom.pmf(x, n, p)\n", + " | >>> plt.plot(x, y, linewidth=2, color='r')\n", + " |\n", + " | bytes(self, length)\n", + " | bytes(length)\n", + " |\n", + " | Return random bytes.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | length : int\n", + " | Number of random bytes.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : bytes\n", + " | String of length `length`.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | This function generates random bytes from a discrete uniform\n", + " | distribution. The generated bytes are independent from the CPU's\n", + " | native endianness.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> rng.bytes(10)\n", + " | b'\\xfeC\\x9b\\x86\\x17\\xf2\\xa1\\xafcp' # random\n", + " |\n", + " | chisquare(self, df, size=None)\n", + " | chisquare(df, size=None)\n", + " |\n", + " | Draw samples from a chi-square distribution.\n", + " |\n", + " | When `df` independent random variables, each with standard normal\n", + " | distributions (mean 0, variance 1), are squared and summed, the\n", + " | resulting distribution is chi-square (see Notes). This distribution\n", + " | is often used in hypothesis testing.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | df : float or array_like of floats\n", + " | Number of degrees of freedom, must be > 0.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``df`` is a scalar. Otherwise,\n", + " | ``np.array(df).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized chi-square distribution.\n", + " |\n", + " | Raises\n", + " | ------\n", + " | ValueError\n", + " | When `df` <= 0 or when an inappropriate `size` (e.g. ``size=-1``)\n", + " | is given.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The variable obtained by summing the squares of `df` independent,\n", + " | standard normally distributed random variables:\n", + " |\n", + " | .. math:: Q = \\sum_{i=1}^{\\mathtt{df}} X^2_i\n", + " |\n", + " | is chi-square distributed, denoted\n", + " |\n", + " | .. math:: Q \\sim \\chi^2_k.\n", + " |\n", + " | The probability density function of the chi-squared distribution is\n", + " |\n", + " | .. math:: p(x) = \\frac{(1/2)^{k/2}}{\\Gamma(k/2)}\n", + " | x^{k/2 - 1} e^{-x/2},\n", + " |\n", + " | where :math:`\\Gamma` is the gamma function,\n", + " |\n", + " | .. math:: \\Gamma(x) = \\int_0^{-\\infty} t^{x - 1} e^{-t} dt.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] NIST \"Engineering Statistics Handbook\"\n", + " | https://www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> rng.chisquare(2,4)\n", + " | array([ 1.89920014, 9.00867716, 3.13710533, 5.62318272]) # random\n", + " |\n", + " | The distribution of a chi-square random variable\n", + " | with 20 degrees of freedom looks as follows:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> import scipy.stats as stats\n", + " | >>> s = rng.chisquare(20, 10000)\n", + " | >>> count, bins, _ = plt.hist(s, 30, density=True)\n", + " | >>> x = np.linspace(0, 60, 1000)\n", + " | >>> plt.plot(x, stats.chi2.pdf(x, df=20))\n", + " | >>> plt.xlim([0, 60])\n", + " | >>> plt.show()\n", + " |\n", + " | choice(self, a, size=None, replace=True, p=None, axis=0, shuffle=True)\n", + " | choice(a, size=None, replace=True, p=None, axis=0, shuffle=True)\n", + " |\n", + " | Generates a random sample from a given array\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | a : {array_like, int}\n", + " | If an ndarray, a random sample is generated from its elements.\n", + " | If an int, the random sample is generated from np.arange(a).\n", + " | size : {int, tuple[int]}, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn from the 1-d `a`. If `a` has more\n", + " | than one dimension, the `size` shape will be inserted into the\n", + " | `axis` dimension, so the output ``ndim`` will be ``a.ndim - 1 +\n", + " | len(size)``. Default is None, in which case a single value is\n", + " | returned.\n", + " | replace : bool, optional\n", + " | Whether the sample is with or without replacement. Default is True,\n", + " | meaning that a value of ``a`` can be selected multiple times.\n", + " | p : 1-D array_like, optional\n", + " | The probabilities associated with each entry in a.\n", + " | If not given, the sample assumes a uniform distribution over all\n", + " | entries in ``a``.\n", + " | axis : int, optional\n", + " | The axis along which the selection is performed. The default, 0,\n", + " | selects by row.\n", + " | shuffle : bool, optional\n", + " | Whether the sample is shuffled when sampling without replacement.\n", + " | Default is True, False provides a speedup.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | samples : single item or ndarray\n", + " | The generated random samples\n", + " |\n", + " | Raises\n", + " | ------\n", + " | ValueError\n", + " | If a is an int and less than zero, if p is not 1-dimensional, if\n", + " | a is array-like with a size 0, if p is not a vector of\n", + " | probabilities, if a and p have different lengths, or if\n", + " | replace=False and the sample size is greater than the population\n", + " | size.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | integers, shuffle, permutation\n", + " |\n", + " | Notes\n", + " | -----\n", + " | Setting user-specified probabilities through ``p`` uses a more general but less\n", + " | efficient sampler than the default. The general sampler produces a different sample\n", + " | than the optimized sampler even if each element of ``p`` is 1 / len(a).\n", + " |\n", + " | ``p`` must sum to 1 when cast to ``float64``. To ensure this, you may wish\n", + " | to normalize using ``p = p / np.sum(p, dtype=float)``.\n", + " |\n", + " | When passing ``a`` as an integer type and ``size`` is not specified, the return\n", + " | type is a native Python ``int``.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Generate a uniform random sample from np.arange(5) of size 3:\n", + " |\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> rng.choice(5, 3)\n", + " | array([0, 3, 4]) # random\n", + " | >>> #This is equivalent to rng.integers(0,5,3)\n", + " |\n", + " | Generate a non-uniform random sample from np.arange(5) of size 3:\n", + " |\n", + " | >>> rng.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0])\n", + " | array([3, 3, 0]) # random\n", + " |\n", + " | Generate a uniform random sample from np.arange(5) of size 3 without\n", + " | replacement:\n", + " |\n", + " | >>> rng.choice(5, 3, replace=False)\n", + " | array([3,1,0]) # random\n", + " | >>> #This is equivalent to rng.permutation(np.arange(5))[:3]\n", + " |\n", + " | Generate a uniform random sample from a 2-D array along the first\n", + " | axis (the default), without replacement:\n", + " |\n", + " | >>> rng.choice([[0, 1, 2], [3, 4, 5], [6, 7, 8]], 2, replace=False)\n", + " | array([[3, 4, 5], # random\n", + " | [0, 1, 2]])\n", + " |\n", + " | Generate a non-uniform random sample from np.arange(5) of size\n", + " | 3 without replacement:\n", + " |\n", + " | >>> rng.choice(5, 3, replace=False, p=[0.1, 0, 0.3, 0.6, 0])\n", + " | array([2, 3, 0]) # random\n", + " |\n", + " | Any of the above can be repeated with an arbitrary array-like\n", + " | instead of just integers. For instance:\n", + " |\n", + " | >>> aa_milne_arr = ['pooh', 'rabbit', 'piglet', 'Christopher']\n", + " | >>> rng.choice(aa_milne_arr, 5, p=[0.5, 0.1, 0.1, 0.3])\n", + " | array(['pooh', 'pooh', 'pooh', 'Christopher', 'piglet'], # random\n", + " | dtype='0` and\n", + " | :math:`\\sum_{i=1}^k x_i = 1`.\n", + " |\n", + " | The probability density function :math:`p` of a\n", + " | Dirichlet-distributed random vector :math:`X` is\n", + " | proportional to\n", + " |\n", + " | .. math:: p(x) \\propto \\prod_{i=1}^{k}{x^{\\alpha_i-1}_i},\n", + " |\n", + " | where :math:`\\alpha` is a vector containing the positive\n", + " | concentration parameters.\n", + " |\n", + " | The method uses the following property for computation: let :math:`Y`\n", + " | be a random vector which has components that follow a standard gamma\n", + " | distribution, then :math:`X = \\frac{1}{\\sum_{i=1}^k{Y_i}} Y`\n", + " | is Dirichlet-distributed\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] David McKay, \"Information Theory, Inference and Learning\n", + " | Algorithms,\" chapter 23,\n", + " | https://www.inference.org.uk/mackay/itila/\n", + " | .. [2] Wikipedia, \"Dirichlet distribution\",\n", + " | https://en.wikipedia.org/wiki/Dirichlet_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Taking an example cited in Wikipedia, this distribution can be used if\n", + " | one wanted to cut strings (each of initial length 1.0) into K pieces\n", + " | with different lengths, where each piece had, on average, a designated\n", + " | average length, but allowing some variation in the relative sizes of\n", + " | the pieces.\n", + " |\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> s = rng.dirichlet((10, 5, 3), 20).transpose()\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> plt.barh(range(20), s[0])\n", + " | >>> plt.barh(range(20), s[1], left=s[0], color='g')\n", + " | >>> plt.barh(range(20), s[2], left=s[0]+s[1], color='r')\n", + " | >>> plt.title(\"Lengths of Strings\")\n", + " |\n", + " | exponential(self, scale=1.0, size=None)\n", + " | exponential(scale=1.0, size=None)\n", + " |\n", + " | Draw samples from an exponential distribution.\n", + " |\n", + " | Its probability density function is\n", + " |\n", + " | .. math:: f(x; \\frac{1}{\\beta}) = \\frac{1}{\\beta} \\exp(-\\frac{x}{\\beta}),\n", + " |\n", + " | for ``x > 0`` and 0 elsewhere. :math:`\\beta` is the scale parameter,\n", + " | which is the inverse of the rate parameter :math:`\\lambda = 1/\\beta`.\n", + " | The rate parameter is an alternative, widely used parameterization\n", + " | of the exponential distribution [3]_.\n", + " |\n", + " | The exponential distribution is a continuous analogue of the\n", + " | geometric distribution. It describes many common situations, such as\n", + " | the size of raindrops measured over many rainstorms [1]_, or the time\n", + " | between page requests to Wikipedia [2]_.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | scale : float or array_like of floats\n", + " | The scale parameter, :math:`\\beta = 1/\\lambda`. Must be\n", + " | non-negative.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``scale`` is a scalar. Otherwise,\n", + " | ``np.array(scale).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized exponential distribution.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Assume a company has 10000 customer support agents and the time\n", + " | between customer calls is exponentially distributed and that the\n", + " | average time between customer calls is 4 minutes.\n", + " |\n", + " | >>> scale, size = 4, 10000\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> time_between_calls = rng.exponential(scale=scale, size=size)\n", + " |\n", + " | What is the probability that a customer will call in the next\n", + " | 4 to 5 minutes?\n", + " |\n", + " | >>> x = ((time_between_calls < 5).sum())/size\n", + " | >>> y = ((time_between_calls < 4).sum())/size\n", + " | >>> x - y\n", + " | 0.08 # may vary\n", + " |\n", + " | The corresponding distribution can be visualized as follows:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> scale, size = 4, 10000\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> sample = rng.exponential(scale=scale, size=size)\n", + " | >>> count, bins, _ = plt.hist(sample, 30, density=True)\n", + " | >>> plt.plot(bins, scale**(-1)*np.exp(-scale**-1*bins), linewidth=2, color='r')\n", + " | >>> plt.show()\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Peyton Z. Peebles Jr., \"Probability, Random Variables and\n", + " | Random Signal Principles\", 4th ed, 2001, p. 57.\n", + " | .. [2] Wikipedia, \"Poisson process\",\n", + " | https://en.wikipedia.org/wiki/Poisson_process\n", + " | .. [3] Wikipedia, \"Exponential distribution\",\n", + " | https://en.wikipedia.org/wiki/Exponential_distribution\n", + " |\n", + " | f(self, dfnum, dfden, size=None)\n", + " | f(dfnum, dfden, size=None)\n", + " |\n", + " | Draw samples from an F distribution.\n", + " |\n", + " | Samples are drawn from an F distribution with specified parameters,\n", + " | `dfnum` (degrees of freedom in numerator) and `dfden` (degrees of\n", + " | freedom in denominator), where both parameters must be greater than\n", + " | zero.\n", + " |\n", + " | The random variate of the F distribution (also known as the\n", + " | Fisher distribution) is a continuous probability distribution\n", + " | that arises in ANOVA tests, and is the ratio of two chi-square\n", + " | variates.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | dfnum : float or array_like of floats\n", + " | Degrees of freedom in numerator, must be > 0.\n", + " | dfden : float or array_like of float\n", + " | Degrees of freedom in denominator, must be > 0.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``dfnum`` and ``dfden`` are both scalars.\n", + " | Otherwise, ``np.broadcast(dfnum, dfden).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized Fisher distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.f : probability density function, distribution or\n", + " | cumulative density function, etc.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The F statistic is used to compare in-group variances to between-group\n", + " | variances. Calculating the distribution depends on the sampling, and\n", + " | so it is a function of the respective degrees of freedom in the\n", + " | problem. The variable `dfnum` is the number of samples minus one, the\n", + " | between-groups degrees of freedom, while `dfden` is the within-groups\n", + " | degrees of freedom, the sum of the number of samples in each group\n", + " | minus the number of groups.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Glantz, Stanton A. \"Primer of Biostatistics.\", McGraw-Hill,\n", + " | Fifth Edition, 2002.\n", + " | .. [2] Wikipedia, \"F-distribution\",\n", + " | https://en.wikipedia.org/wiki/F-distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | An example from Glantz[1], pp 47-40:\n", + " |\n", + " | Two groups, children of diabetics (25 people) and children from people\n", + " | without diabetes (25 controls). Fasting blood glucose was measured,\n", + " | case group had a mean value of 86.1, controls had a mean value of\n", + " | 82.2. Standard deviations were 2.09 and 2.49 respectively. Are these\n", + " | data consistent with the null hypothesis that the parents diabetic\n", + " | status does not affect their children's blood glucose levels?\n", + " | Calculating the F statistic from the data gives a value of 36.01.\n", + " |\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> dfnum = 1. # between group degrees of freedom\n", + " | >>> dfden = 48. # within groups degrees of freedom\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> s = rng.f(dfnum, dfden, 1000)\n", + " |\n", + " | The lower bound for the top 1% of the samples is :\n", + " |\n", + " | >>> np.sort(s)[-10]\n", + " | 7.61988120985 # random\n", + " |\n", + " | So there is about a 1% chance that the F statistic will exceed 7.62,\n", + " | the measured value is 36, so the null hypothesis is rejected at the 1%\n", + " | level.\n", + " |\n", + " | The corresponding probability density function for ``n = 20``\n", + " | and ``m = 20`` is:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> from scipy import stats\n", + " | >>> dfnum, dfden, size = 20, 20, 10000\n", + " | >>> s = rng.f(dfnum=dfnum, dfden=dfden, size=size)\n", + " | >>> bins, density, _ = plt.hist(s, 30, density=True)\n", + " | >>> x = np.linspace(0, 5, 1000)\n", + " | >>> plt.plot(x, stats.f.pdf(x, dfnum, dfden))\n", + " | >>> plt.xlim([0, 5])\n", + " | >>> plt.show()\n", + " |\n", + " | gamma(self, shape, scale=1.0, size=None)\n", + " | gamma(shape, scale=1.0, size=None)\n", + " |\n", + " | Draw samples from a Gamma distribution.\n", + " |\n", + " | Samples are drawn from a Gamma distribution with specified parameters,\n", + " | `shape` (sometimes designated \"k\") and `scale` (sometimes designated\n", + " | \"theta\"), where both parameters are > 0.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | shape : float or array_like of floats\n", + " | The shape of the gamma distribution. Must be non-negative.\n", + " | scale : float or array_like of floats, optional\n", + " | The scale of the gamma distribution. Must be non-negative.\n", + " | Default is equal to 1.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``shape`` and ``scale`` are both scalars.\n", + " | Otherwise, ``np.broadcast(shape, scale).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized gamma distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.gamma : probability density function, distribution or\n", + " | cumulative density function, etc.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density for the Gamma distribution is\n", + " |\n", + " | .. math:: p(x) = x^{k-1}\\frac{e^{-x/\\theta}}{\\theta^k\\Gamma(k)},\n", + " |\n", + " | where :math:`k` is the shape and :math:`\\theta` the scale,\n", + " | and :math:`\\Gamma` is the Gamma function.\n", + " |\n", + " | The Gamma distribution is often used to model the times to failure of\n", + " | electronic components, and arises naturally in processes for which the\n", + " | waiting times between Poisson distributed events are relevant.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Weisstein, Eric W. \"Gamma Distribution.\" From MathWorld--A\n", + " | Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/GammaDistribution.html\n", + " | .. [2] Wikipedia, \"Gamma distribution\",\n", + " | https://en.wikipedia.org/wiki/Gamma_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> shape, scale = 2., 2. # mean=4, std=2*sqrt(2)\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> s = rng.gamma(shape, scale, 1000)\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> import scipy.special as sps # doctest: +SKIP\n", + " | >>> count, bins, _ = plt.hist(s, 50, density=True)\n", + " | >>> y = bins**(shape-1)*(np.exp(-bins/scale) / # doctest: +SKIP\n", + " | ... (sps.gamma(shape)*scale**shape))\n", + " | >>> plt.plot(bins, y, linewidth=2, color='r') # doctest: +SKIP\n", + " | >>> plt.show()\n", + " |\n", + " | geometric(self, p, size=None)\n", + " | geometric(p, size=None)\n", + " |\n", + " | Draw samples from the geometric distribution.\n", + " |\n", + " | Bernoulli trials are experiments with one of two outcomes:\n", + " | success or failure (an example of such an experiment is flipping\n", + " | a coin). The geometric distribution models the number of trials\n", + " | that must be run in order to achieve success. It is therefore\n", + " | supported on the positive integers, ``k = 1, 2, ...``.\n", + " |\n", + " | The probability mass function of the geometric distribution is\n", + " |\n", + " | .. math:: f(k) = (1 - p)^{k - 1} p\n", + " |\n", + " | where `p` is the probability of success of an individual trial.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | p : float or array_like of floats\n", + " | The probability of success of an individual trial.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``p`` is a scalar. Otherwise,\n", + " | ``np.array(p).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized geometric distribution.\n", + " |\n", + " | References\n", + " | ----------\n", + " |\n", + " | .. [1] Wikipedia, \"Geometric distribution\",\n", + " | https://en.wikipedia.org/wiki/Geometric_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw 10,000 values from the geometric distribution, with the\n", + " | probability of an individual success equal to ``p = 0.35``:\n", + " |\n", + " | >>> p, size = 0.35, 10000\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> sample = rng.geometric(p=p, size=size)\n", + " |\n", + " | What proportion of trials succeeded after a single run?\n", + " |\n", + " | >>> (sample == 1).sum()/size\n", + " | 0.34889999999999999 # may vary\n", + " |\n", + " | The geometric distribution with ``p=0.35`` looks as follows:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, _ = plt.hist(sample, bins=30, density=True)\n", + " | >>> plt.plot(bins, (1-p)**(bins-1)*p)\n", + " | >>> plt.xlim([0, 25])\n", + " | >>> plt.show()\n", + " |\n", + " | gumbel(self, loc=0.0, scale=1.0, size=None)\n", + " | gumbel(loc=0.0, scale=1.0, size=None)\n", + " |\n", + " | Draw samples from a Gumbel distribution.\n", + " |\n", + " | Draw samples from a Gumbel distribution with specified location and\n", + " | scale. For more information on the Gumbel distribution, see\n", + " | Notes and References below.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | loc : float or array_like of floats, optional\n", + " | The location of the mode of the distribution. Default is 0.\n", + " | scale : float or array_like of floats, optional\n", + " | The scale parameter of the distribution. Default is 1. Must be non-\n", + " | negative.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``loc`` and ``scale`` are both scalars.\n", + " | Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized Gumbel distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.gumbel_l\n", + " | scipy.stats.gumbel_r\n", + " | scipy.stats.genextreme\n", + " | weibull\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The Gumbel (or Smallest Extreme Value (SEV) or the Smallest Extreme\n", + " | Value Type I) distribution is one of a class of Generalized Extreme\n", + " | Value (GEV) distributions used in modeling extreme value problems.\n", + " | The Gumbel is a special case of the Extreme Value Type I distribution\n", + " | for maximums from distributions with \"exponential-like\" tails.\n", + " |\n", + " | The probability density for the Gumbel distribution is\n", + " |\n", + " | .. math:: p(x) = \\frac{e^{-(x - \\mu)/ \\beta}}{\\beta} e^{ -e^{-(x - \\mu)/\n", + " | \\beta}},\n", + " |\n", + " | where :math:`\\mu` is the mode, a location parameter, and\n", + " | :math:`\\beta` is the scale parameter.\n", + " |\n", + " | The Gumbel (named for German mathematician Emil Julius Gumbel) was used\n", + " | very early in the hydrology literature, for modeling the occurrence of\n", + " | flood events. It is also used for modeling maximum wind speed and\n", + " | rainfall rates. It is a \"fat-tailed\" distribution - the probability of\n", + " | an event in the tail of the distribution is larger than if one used a\n", + " | Gaussian, hence the surprisingly frequent occurrence of 100-year\n", + " | floods. Floods were initially modeled as a Gaussian process, which\n", + " | underestimated the frequency of extreme events.\n", + " |\n", + " | It is one of a class of extreme value distributions, the Generalized\n", + " | Extreme Value (GEV) distributions, which also includes the Weibull and\n", + " | Frechet.\n", + " |\n", + " | The function has a mean of :math:`\\mu + 0.57721\\beta` and a variance\n", + " | of :math:`\\frac{\\pi^2}{6}\\beta^2`.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Gumbel, E. J., \"Statistics of Extremes,\"\n", + " | New York: Columbia University Press, 1958.\n", + " | .. [2] Reiss, R.-D. and Thomas, M., \"Statistical Analysis of Extreme\n", + " | Values from Insurance, Finance, Hydrology and Other Fields,\"\n", + " | Basel: Birkhauser Verlag, 2001.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> mu, beta = 0, 0.1 # location and scale\n", + " | >>> s = rng.gumbel(mu, beta, 1000)\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, _ = plt.hist(s, 30, density=True)\n", + " | >>> plt.plot(bins, (1/beta)*np.exp(-(bins - mu)/beta)\n", + " | ... * np.exp( -np.exp( -(bins - mu) /beta) ),\n", + " | ... linewidth=2, color='r')\n", + " | >>> plt.show()\n", + " |\n", + " | Show how an extreme value distribution can arise from a Gaussian process\n", + " | and compare to a Gaussian:\n", + " |\n", + " | >>> means = []\n", + " | >>> maxima = []\n", + " | >>> for i in range(0,1000) :\n", + " | ... a = rng.normal(mu, beta, 1000)\n", + " | ... means.append(a.mean())\n", + " | ... maxima.append(a.max())\n", + " | >>> count, bins, _ = plt.hist(maxima, 30, density=True)\n", + " | >>> beta = np.std(maxima) * np.sqrt(6) / np.pi\n", + " | >>> mu = np.mean(maxima) - 0.57721*beta\n", + " | >>> plt.plot(bins, (1/beta)*np.exp(-(bins - mu)/beta)\n", + " | ... * np.exp(-np.exp(-(bins - mu)/beta)),\n", + " | ... linewidth=2, color='r')\n", + " | >>> plt.plot(bins, 1/(beta * np.sqrt(2 * np.pi))\n", + " | ... * np.exp(-(bins - mu)**2 / (2 * beta**2)),\n", + " | ... linewidth=2, color='g')\n", + " | >>> plt.show()\n", + " |\n", + " | hypergeometric(self, ngood, nbad, nsample, size=None)\n", + " | hypergeometric(ngood, nbad, nsample, size=None)\n", + " |\n", + " | Draw samples from a Hypergeometric distribution.\n", + " |\n", + " | Samples are drawn from a hypergeometric distribution with specified\n", + " | parameters, `ngood` (ways to make a good selection), `nbad` (ways to make\n", + " | a bad selection), and `nsample` (number of items sampled, which is less\n", + " | than or equal to the sum ``ngood + nbad``).\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | ngood : int or array_like of ints\n", + " | Number of ways to make a good selection. Must be nonnegative and\n", + " | less than 10**9.\n", + " | nbad : int or array_like of ints\n", + " | Number of ways to make a bad selection. Must be nonnegative and\n", + " | less than 10**9.\n", + " | nsample : int or array_like of ints\n", + " | Number of items sampled. Must be nonnegative and less than\n", + " | ``ngood + nbad``.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if `ngood`, `nbad`, and `nsample`\n", + " | are all scalars. Otherwise, ``np.broadcast(ngood, nbad, nsample).size``\n", + " | samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized hypergeometric distribution. Each\n", + " | sample is the number of good items within a randomly selected subset of\n", + " | size `nsample` taken from a set of `ngood` good items and `nbad` bad items.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | multivariate_hypergeometric : Draw samples from the multivariate\n", + " | hypergeometric distribution.\n", + " | scipy.stats.hypergeom : probability density function, distribution or\n", + " | cumulative density function, etc.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability mass function (PMF) for the Hypergeometric distribution is\n", + " |\n", + " | .. math:: P(x) = \\frac{\\binom{g}{x}\\binom{b}{n-x}}{\\binom{g+b}{n}},\n", + " |\n", + " | where :math:`0 \\le x \\le n` and :math:`n-b \\le x \\le g`\n", + " |\n", + " | for P(x) the probability of ``x`` good results in the drawn sample,\n", + " | g = `ngood`, b = `nbad`, and n = `nsample`.\n", + " |\n", + " | Consider an urn with black and white marbles in it, `ngood` of them\n", + " | are black and `nbad` are white. If you draw `nsample` balls without\n", + " | replacement, then the hypergeometric distribution describes the\n", + " | distribution of black balls in the drawn sample.\n", + " |\n", + " | Note that this distribution is very similar to the binomial\n", + " | distribution, except that in this case, samples are drawn without\n", + " | replacement, whereas in the Binomial case samples are drawn with\n", + " | replacement (or the sample space is infinite). As the sample space\n", + " | becomes large, this distribution approaches the binomial.\n", + " |\n", + " | The arguments `ngood` and `nbad` each must be less than `10**9`. For\n", + " | extremely large arguments, the algorithm that is used to compute the\n", + " | samples [4]_ breaks down because of loss of precision in floating point\n", + " | calculations. For such large values, if `nsample` is not also large,\n", + " | the distribution can be approximated with the binomial distribution,\n", + " | `binomial(n=nsample, p=ngood/(ngood + nbad))`.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Lentner, Marvin, \"Elementary Applied Statistics\", Bogden\n", + " | and Quigley, 1972.\n", + " | .. [2] Weisstein, Eric W. \"Hypergeometric Distribution.\" From\n", + " | MathWorld--A Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/HypergeometricDistribution.html\n", + " | .. [3] Wikipedia, \"Hypergeometric distribution\",\n", + " | https://en.wikipedia.org/wiki/Hypergeometric_distribution\n", + " | .. [4] Stadlober, Ernst, \"The ratio of uniforms approach for generating\n", + " | discrete random variates\", Journal of Computational and Applied\n", + " | Mathematics, 31, pp. 181-189 (1990).\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> ngood, nbad, nsamp = 100, 2, 10\n", + " | # number of good, number of bad, and number of samples\n", + " | >>> s = rng.hypergeometric(ngood, nbad, nsamp, 1000)\n", + " | >>> from matplotlib.pyplot import hist\n", + " | >>> hist(s)\n", + " | # note that it is very unlikely to grab both bad items\n", + " |\n", + " | Suppose you have an urn with 15 white and 15 black marbles.\n", + " | If you pull 15 marbles at random, how likely is it that\n", + " | 12 or more of them are one color?\n", + " |\n", + " | >>> s = rng.hypergeometric(15, 15, 15, 100000)\n", + " | >>> sum(s>=12)/100000. + sum(s<=3)/100000.\n", + " | # answer = 0.003 ... pretty unlikely!\n", + " |\n", + " | integers(self, low, high=None, size=None, dtype=, endpoint=False)\n", + " | integers(low, high=None, size=None, dtype=np.int64, endpoint=False)\n", + " |\n", + " | Return random integers from `low` (inclusive) to `high` (exclusive), or\n", + " | if endpoint=True, `low` (inclusive) to `high` (inclusive). Replaces\n", + " | `RandomState.randint` (with endpoint=False) and\n", + " | `RandomState.random_integers` (with endpoint=True)\n", + " |\n", + " | Return random integers from the \"discrete uniform\" distribution of\n", + " | the specified dtype. If `high` is None (the default), then results are\n", + " | from 0 to `low`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | low : int or array-like of ints\n", + " | Lowest (signed) integers to be drawn from the distribution (unless\n", + " | ``high=None``, in which case this parameter is 0 and this value is\n", + " | used for `high`).\n", + " | high : int or array-like of ints, optional\n", + " | If provided, one above the largest (signed) integer to be drawn\n", + " | from the distribution (see above for behavior if ``high=None``).\n", + " | If array-like, must contain integer values\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " | dtype : dtype, optional\n", + " | Desired dtype of the result. Byteorder must be native.\n", + " | The default value is np.int64.\n", + " | endpoint : bool, optional\n", + " | If true, sample from the interval [low, high] instead of the\n", + " | default [low, high)\n", + " | Defaults to False\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : int or ndarray of ints\n", + " | `size`-shaped array of random integers from the appropriate\n", + " | distribution, or a single such random int if `size` not provided.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | When using broadcasting with uint64 dtypes, the maximum value (2**64)\n", + " | cannot be represented as a standard integer type. The high array (or\n", + " | low if high is None) must have object dtype, e.g., array([2**64]).\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> rng.integers(2, size=10)\n", + " | array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0]) # random\n", + " | >>> rng.integers(1, size=10)\n", + " | array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n", + " |\n", + " | Generate a 2 x 4 array of ints between 0 and 4, inclusive:\n", + " |\n", + " | >>> rng.integers(5, size=(2, 4))\n", + " | array([[4, 0, 2, 1],\n", + " | [3, 2, 2, 0]]) # random\n", + " |\n", + " | Generate a 1 x 3 array with 3 different upper bounds\n", + " |\n", + " | >>> rng.integers(1, [3, 5, 10])\n", + " | array([2, 2, 9]) # random\n", + " |\n", + " | Generate a 1 by 3 array with 3 different lower bounds\n", + " |\n", + " | >>> rng.integers([1, 5, 7], 10)\n", + " | array([9, 8, 7]) # random\n", + " |\n", + " | Generate a 2 by 4 array using broadcasting with dtype of uint8\n", + " |\n", + " | >>> rng.integers([1, 3, 5, 7], [[10], [20]], dtype=np.uint8)\n", + " | array([[ 8, 6, 9, 7],\n", + " | [ 1, 16, 9, 12]], dtype=uint8) # random\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Daniel Lemire., \"Fast Random Integer Generation in an Interval\",\n", + " | ACM Transactions on Modeling and Computer Simulation 29 (1), 2019,\n", + " | https://arxiv.org/abs/1805.10941.\n", + " |\n", + " | laplace(self, loc=0.0, scale=1.0, size=None)\n", + " | laplace(loc=0.0, scale=1.0, size=None)\n", + " |\n", + " | Draw samples from the Laplace or double exponential distribution with\n", + " | specified location (or mean) and scale (decay).\n", + " |\n", + " | The Laplace distribution is similar to the Gaussian/normal distribution,\n", + " | but is sharper at the peak and has fatter tails. It represents the\n", + " | difference between two independent, identically distributed exponential\n", + " | random variables.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | loc : float or array_like of floats, optional\n", + " | The position, :math:`\\mu`, of the distribution peak. Default is 0.\n", + " | scale : float or array_like of floats, optional\n", + " | :math:`\\lambda`, the exponential decay. Default is 1. Must be non-\n", + " | negative.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``loc`` and ``scale`` are both scalars.\n", + " | Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized Laplace distribution.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | It has the probability density function\n", + " |\n", + " | .. math:: f(x; \\mu, \\lambda) = \\frac{1}{2\\lambda}\n", + " | \\exp\\left(-\\frac{|x - \\mu|}{\\lambda}\\right).\n", + " |\n", + " | The first law of Laplace, from 1774, states that the frequency\n", + " | of an error can be expressed as an exponential function of the\n", + " | absolute magnitude of the error, which leads to the Laplace\n", + " | distribution. For many problems in economics and health\n", + " | sciences, this distribution seems to model the data better\n", + " | than the standard Gaussian distribution.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Abramowitz, M. and Stegun, I. A. (Eds.). \"Handbook of\n", + " | Mathematical Functions with Formulas, Graphs, and Mathematical\n", + " | Tables, 9th printing,\" New York: Dover, 1972.\n", + " | .. [2] Kotz, Samuel, et. al. \"The Laplace Distribution and\n", + " | Generalizations, \" Birkhauser, 2001.\n", + " | .. [3] Weisstein, Eric W. \"Laplace Distribution.\"\n", + " | From MathWorld--A Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/LaplaceDistribution.html\n", + " | .. [4] Wikipedia, \"Laplace distribution\",\n", + " | https://en.wikipedia.org/wiki/Laplace_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution\n", + " |\n", + " | >>> loc, scale = 0., 1.\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> s = rng.laplace(loc, scale, 1000)\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, _ = plt.hist(s, 30, density=True)\n", + " | >>> x = np.arange(-8., 8., .01)\n", + " | >>> pdf = np.exp(-abs(x-loc)/scale)/(2.*scale)\n", + " | >>> plt.plot(x, pdf)\n", + " |\n", + " | Plot Gaussian for comparison:\n", + " |\n", + " | >>> g = (1/(scale * np.sqrt(2 * np.pi)) *\n", + " | ... np.exp(-(x - loc)**2 / (2 * scale**2)))\n", + " | >>> plt.plot(x,g)\n", + " |\n", + " | logistic(self, loc=0.0, scale=1.0, size=None)\n", + " | logistic(loc=0.0, scale=1.0, size=None)\n", + " |\n", + " | Draw samples from a logistic distribution.\n", + " |\n", + " | Samples are drawn from a logistic distribution with specified\n", + " | parameters, loc (location or mean, also median), and scale (>0).\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | loc : float or array_like of floats, optional\n", + " | Parameter of the distribution. Default is 0.\n", + " | scale : float or array_like of floats, optional\n", + " | Parameter of the distribution. Must be non-negative.\n", + " | Default is 1.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``loc`` and ``scale`` are both scalars.\n", + " | Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized logistic distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.logistic : probability density function, distribution or\n", + " | cumulative density function, etc.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density for the Logistic distribution is\n", + " |\n", + " | .. math:: P(x) = \\frac{e^{-(x-\\mu)/s}}{s(1+e^{-(x-\\mu)/s})^2},\n", + " |\n", + " | where :math:`\\mu` = location and :math:`s` = scale.\n", + " |\n", + " | The Logistic distribution is used in Extreme Value problems where it\n", + " | can act as a mixture of Gumbel distributions, in Epidemiology, and by\n", + " | the World Chess Federation (FIDE) where it is used in the Elo ranking\n", + " | system, assuming the performance of each player is a logistically\n", + " | distributed random variable.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Reiss, R.-D. and Thomas M. (2001), \"Statistical Analysis of\n", + " | Extreme Values, from Insurance, Finance, Hydrology and Other\n", + " | Fields,\" Birkhauser Verlag, Basel, pp 132-133.\n", + " | .. [2] Weisstein, Eric W. \"Logistic Distribution.\" From\n", + " | MathWorld--A Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/LogisticDistribution.html\n", + " | .. [3] Wikipedia, \"Logistic-distribution\",\n", + " | https://en.wikipedia.org/wiki/Logistic_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> loc, scale = 10, 1\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> s = rng.logistic(loc, scale, 10000)\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, _ = plt.hist(s, bins=50, label='Sampled data')\n", + " |\n", + " | # plot sampled data against the exact distribution\n", + " |\n", + " | >>> def logistic(x, loc, scale):\n", + " | ... return np.exp((loc-x)/scale)/(scale*(1+np.exp((loc-x)/scale))**2)\n", + " | >>> logistic_values = logistic(bins, loc, scale)\n", + " | >>> bin_spacing = np.mean(np.diff(bins))\n", + " | >>> plt.plot(bins, logistic_values * bin_spacing * s.size, label='Logistic PDF')\n", + " | >>> plt.legend()\n", + " | >>> plt.show()\n", + " |\n", + " | lognormal(self, mean=0.0, sigma=1.0, size=None)\n", + " | lognormal(mean=0.0, sigma=1.0, size=None)\n", + " |\n", + " | Draw samples from a log-normal distribution.\n", + " |\n", + " | Draw samples from a log-normal distribution with specified mean,\n", + " | standard deviation, and array shape. Note that the mean and standard\n", + " | deviation are not the values for the distribution itself, but of the\n", + " | underlying normal distribution it is derived from.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | mean : float or array_like of floats, optional\n", + " | Mean value of the underlying normal distribution. Default is 0.\n", + " | sigma : float or array_like of floats, optional\n", + " | Standard deviation of the underlying normal distribution. Must be\n", + " | non-negative. Default is 1.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``mean`` and ``sigma`` are both scalars.\n", + " | Otherwise, ``np.broadcast(mean, sigma).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized log-normal distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.lognorm : probability density function, distribution,\n", + " | cumulative density function, etc.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | A variable `x` has a log-normal distribution if `log(x)` is normally\n", + " | distributed. The probability density function for the log-normal\n", + " | distribution is:\n", + " |\n", + " | .. math:: p(x) = \\frac{1}{\\sigma x \\sqrt{2\\pi}}\n", + " | e^{(-\\frac{(ln(x)-\\mu)^2}{2\\sigma^2})}\n", + " |\n", + " | where :math:`\\mu` is the mean and :math:`\\sigma` is the standard\n", + " | deviation of the normally distributed logarithm of the variable.\n", + " | A log-normal distribution results if a random variable is the *product*\n", + " | of a large number of independent, identically-distributed variables in\n", + " | the same way that a normal distribution results if the variable is the\n", + " | *sum* of a large number of independent, identically-distributed\n", + " | variables.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Limpert, E., Stahel, W. A., and Abbt, M., \"Log-normal\n", + " | Distributions across the Sciences: Keys and Clues,\"\n", + " | BioScience, Vol. 51, No. 5, May, 2001.\n", + " | https://stat.ethz.ch/~stahel/lognormal/bioscience.pdf\n", + " | .. [2] Reiss, R.D. and Thomas, M., \"Statistical Analysis of Extreme\n", + " | Values,\" Basel: Birkhauser Verlag, 2001, pp. 31-32.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> mu, sigma = 3., 1. # mean and standard deviation\n", + " | >>> s = rng.lognormal(mu, sigma, 1000)\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, _ = plt.hist(s, 100, density=True, align='mid')\n", + " |\n", + " | >>> x = np.linspace(min(bins), max(bins), 10000)\n", + " | >>> pdf = (np.exp(-(np.log(x) - mu)**2 / (2 * sigma**2))\n", + " | ... / (x * sigma * np.sqrt(2 * np.pi)))\n", + " |\n", + " | >>> plt.plot(x, pdf, linewidth=2, color='r')\n", + " | >>> plt.axis('tight')\n", + " | >>> plt.show()\n", + " |\n", + " | Demonstrate that taking the products of random samples from a uniform\n", + " | distribution can be fit well by a log-normal probability density\n", + " | function.\n", + " |\n", + " | >>> # Generate a thousand samples: each is the product of 100 random\n", + " | >>> # values, drawn from a normal distribution.\n", + " | >>> rng = rng\n", + " | >>> b = []\n", + " | >>> for i in range(1000):\n", + " | ... a = 10. + rng.standard_normal(100)\n", + " | ... b.append(np.prod(a))\n", + " |\n", + " | >>> b = np.array(b) / np.min(b) # scale values to be positive\n", + " | >>> count, bins, _ = plt.hist(b, 100, density=True, align='mid')\n", + " | >>> sigma = np.std(np.log(b))\n", + " | >>> mu = np.mean(np.log(b))\n", + " |\n", + " | >>> x = np.linspace(min(bins), max(bins), 10000)\n", + " | >>> pdf = (np.exp(-(np.log(x) - mu)**2 / (2 * sigma**2))\n", + " | ... / (x * sigma * np.sqrt(2 * np.pi)))\n", + " |\n", + " | >>> plt.plot(x, pdf, color='r', linewidth=2)\n", + " | >>> plt.show()\n", + " |\n", + " | logseries(self, p, size=None)\n", + " | logseries(p, size=None)\n", + " |\n", + " | Draw samples from a logarithmic series distribution.\n", + " |\n", + " | Samples are drawn from a log series distribution with specified\n", + " | shape parameter, 0 <= ``p`` < 1.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | p : float or array_like of floats\n", + " | Shape parameter for the distribution. Must be in the range [0, 1).\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``p`` is a scalar. Otherwise,\n", + " | ``np.array(p).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized logarithmic series distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.logser : probability density function, distribution or\n", + " | cumulative density function, etc.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability mass function for the Log Series distribution is\n", + " |\n", + " | .. math:: P(k) = \\frac{-p^k}{k \\ln(1-p)},\n", + " |\n", + " | where p = probability.\n", + " |\n", + " | The log series distribution is frequently used to represent species\n", + " | richness and occurrence, first proposed by Fisher, Corbet, and\n", + " | Williams in 1943 [2]. It may also be used to model the numbers of\n", + " | occupants seen in cars [3].\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Buzas, Martin A.; Culver, Stephen J., Understanding regional\n", + " | species diversity through the log series distribution of\n", + " | occurrences: BIODIVERSITY RESEARCH Diversity & Distributions,\n", + " | Volume 5, Number 5, September 1999 , pp. 187-195(9).\n", + " | .. [2] Fisher, R.A,, A.S. Corbet, and C.B. Williams. 1943. The\n", + " | relation between the number of species and the number of\n", + " | individuals in a random sample of an animal population.\n", + " | Journal of Animal Ecology, 12:42-58.\n", + " | .. [3] D. J. Hand, F. Daly, D. Lunn, E. Ostrowski, A Handbook of Small\n", + " | Data Sets, CRC Press, 1994.\n", + " | .. [4] Wikipedia, \"Logarithmic distribution\",\n", + " | https://en.wikipedia.org/wiki/Logarithmic_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> a = .6\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> s = rng.logseries(a, 10000)\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> bins = np.arange(-.5, max(s) + .5 )\n", + " | >>> count, bins, _ = plt.hist(s, bins=bins, label='Sample count')\n", + " |\n", + " | # plot against distribution\n", + " |\n", + " | >>> def logseries(k, p):\n", + " | ... return -p**k/(k*np.log(1-p))\n", + " | >>> centres = np.arange(1, max(s) + 1)\n", + " | >>> plt.plot(centres, logseries(centres, a) * s.size, 'r', label='logseries PMF')\n", + " | >>> plt.legend()\n", + " | >>> plt.show()\n", + " |\n", + " | multinomial(self, n, pvals, size=None)\n", + " | multinomial(n, pvals, size=None)\n", + " |\n", + " | Draw samples from a multinomial distribution.\n", + " |\n", + " | The multinomial distribution is a multivariate generalization of the\n", + " | binomial distribution. Take an experiment with one of ``p``\n", + " | possible outcomes. An example of such an experiment is throwing a dice,\n", + " | where the outcome can be 1 through 6. Each sample drawn from the\n", + " | distribution represents `n` such experiments. Its values,\n", + " | ``X_i = [X_0, X_1, ..., X_p]``, represent the number of times the\n", + " | outcome was ``i``.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | n : int or array-like of ints\n", + " | Number of experiments.\n", + " | pvals : array-like of floats\n", + " | Probabilities of each of the ``p`` different outcomes with shape\n", + " | ``(k0, k1, ..., kn, p)``. Each element ``pvals[i,j,...,:]`` must\n", + " | sum to 1 (however, the last element is always assumed to account\n", + " | for the remaining probability, as long as\n", + " | ``sum(pvals[..., :-1], axis=-1) <= 1.0``. Must have at least 1\n", + " | dimension where pvals.shape[-1] > 0.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn each with ``p`` elements. Default\n", + " | is None where the output size is determined by the broadcast shape\n", + " | of ``n`` and all by the final dimension of ``pvals``, which is\n", + " | denoted as ``b=(b0, b1, ..., bq)``. If size is not None, then it\n", + " | must be compatible with the broadcast shape ``b``. Specifically,\n", + " | size must have ``q`` or more elements and size[-(q-j):] must equal\n", + " | ``bj``.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray\n", + " | The drawn samples, of shape size, if provided. When size is\n", + " | provided, the output shape is size + (p,) If not specified,\n", + " | the shape is determined by the broadcast shape of ``n`` and\n", + " | ``pvals``, ``(b0, b1, ..., bq)`` augmented with the dimension of\n", + " | the multinomial, ``p``, so that that output shape is\n", + " | ``(b0, b1, ..., bq, p)``.\n", + " |\n", + " | Each entry ``out[i,j,...,:]`` is a ``p``-dimensional value drawn\n", + " | from the distribution.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Throw a dice 20 times:\n", + " |\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> rng.multinomial(20, [1/6.]*6, size=1)\n", + " | array([[4, 1, 7, 5, 2, 1]]) # random\n", + " |\n", + " | It landed 4 times on 1, once on 2, etc.\n", + " |\n", + " | Now, throw the dice 20 times, and 20 times again:\n", + " |\n", + " | >>> rng.multinomial(20, [1/6.]*6, size=2)\n", + " | array([[3, 4, 3, 3, 4, 3],\n", + " | [2, 4, 3, 4, 0, 7]]) # random\n", + " |\n", + " | For the first run, we threw 3 times 1, 4 times 2, etc. For the second,\n", + " | we threw 2 times 1, 4 times 2, etc.\n", + " |\n", + " | Now, do one experiment throwing the dice 10 time, and 10 times again,\n", + " | and another throwing the dice 20 times, and 20 times again:\n", + " |\n", + " | >>> rng.multinomial([[10], [20]], [1/6.]*6, size=(2, 2))\n", + " | array([[[2, 4, 0, 1, 2, 1],\n", + " | [1, 3, 0, 3, 1, 2]],\n", + " | [[1, 4, 4, 4, 4, 3],\n", + " | [3, 3, 2, 5, 5, 2]]]) # random\n", + " |\n", + " | The first array shows the outcomes of throwing the dice 10 times, and\n", + " | the second shows the outcomes from throwing the dice 20 times.\n", + " |\n", + " | A loaded die is more likely to land on number 6:\n", + " |\n", + " | >>> rng.multinomial(100, [1/7.]*5 + [2/7.])\n", + " | array([11, 16, 14, 17, 16, 26]) # random\n", + " |\n", + " | Simulate 10 throws of a 4-sided die and 20 throws of a 6-sided die\n", + " |\n", + " | >>> rng.multinomial([10, 20],[[1/4]*4 + [0]*2, [1/6]*6])\n", + " | array([[2, 1, 4, 3, 0, 0],\n", + " | [3, 3, 3, 6, 1, 4]], dtype=int64) # random\n", + " |\n", + " | Generate categorical random variates from two categories where the\n", + " | first has 3 outcomes and the second has 2.\n", + " |\n", + " | >>> rng.multinomial(1, [[.1, .5, .4 ], [.3, .7, .0]])\n", + " | array([[0, 0, 1],\n", + " | [0, 1, 0]], dtype=int64) # random\n", + " |\n", + " | ``argmax(axis=-1)`` is then used to return the categories.\n", + " |\n", + " | >>> pvals = [[.1, .5, .4 ], [.3, .7, .0]]\n", + " | >>> rvs = rng.multinomial(1, pvals, size=(4,2))\n", + " | >>> rvs.argmax(axis=-1)\n", + " | array([[0, 1],\n", + " | [2, 0],\n", + " | [2, 1],\n", + " | [2, 0]], dtype=int64) # random\n", + " |\n", + " | The same output dimension can be produced using broadcasting.\n", + " |\n", + " | >>> rvs = rng.multinomial([[1]] * 4, pvals)\n", + " | >>> rvs.argmax(axis=-1)\n", + " | array([[0, 1],\n", + " | [2, 0],\n", + " | [2, 1],\n", + " | [2, 0]], dtype=int64) # random\n", + " |\n", + " | The probability inputs should be normalized. As an implementation\n", + " | detail, the value of the last entry is ignored and assumed to take\n", + " | up any leftover probability mass, but this should not be relied on.\n", + " | A biased coin which has twice as much weight on one side as on the\n", + " | other should be sampled like so:\n", + " |\n", + " | >>> rng.multinomial(100, [1.0 / 3, 2.0 / 3]) # RIGHT\n", + " | array([38, 62]) # random\n", + " |\n", + " | not like:\n", + " |\n", + " | >>> rng.multinomial(100, [1.0, 2.0]) # WRONG\n", + " | Traceback (most recent call last):\n", + " | ValueError: pvals < 0, pvals > 1 or pvals contains NaNs\n", + " |\n", + " | multivariate_hypergeometric(self, colors, nsample, size=None, method='marginals')\n", + " | multivariate_hypergeometric(colors, nsample, size=None,\n", + " | method='marginals')\n", + " |\n", + " | Generate variates from a multivariate hypergeometric distribution.\n", + " |\n", + " | The multivariate hypergeometric distribution is a generalization\n", + " | of the hypergeometric distribution.\n", + " |\n", + " | Choose ``nsample`` items at random without replacement from a\n", + " | collection with ``N`` distinct types. ``N`` is the length of\n", + " | ``colors``, and the values in ``colors`` are the number of occurrences\n", + " | of that type in the collection. The total number of items in the\n", + " | collection is ``sum(colors)``. Each random variate generated by this\n", + " | function is a vector of length ``N`` holding the counts of the\n", + " | different types that occurred in the ``nsample`` items.\n", + " |\n", + " | The name ``colors`` comes from a common description of the\n", + " | distribution: it is the probability distribution of the number of\n", + " | marbles of each color selected without replacement from an urn\n", + " | containing marbles of different colors; ``colors[i]`` is the number\n", + " | of marbles in the urn with color ``i``.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | colors : sequence of integers\n", + " | The number of each type of item in the collection from which\n", + " | a sample is drawn. The values in ``colors`` must be nonnegative.\n", + " | To avoid loss of precision in the algorithm, ``sum(colors)``\n", + " | must be less than ``10**9`` when `method` is \"marginals\".\n", + " | nsample : int\n", + " | The number of items selected. ``nsample`` must not be greater\n", + " | than ``sum(colors)``.\n", + " | size : int or tuple of ints, optional\n", + " | The number of variates to generate, either an integer or a tuple\n", + " | holding the shape of the array of variates. If the given size is,\n", + " | e.g., ``(k, m)``, then ``k * m`` variates are drawn, where one\n", + " | variate is a vector of length ``len(colors)``, and the return value\n", + " | has shape ``(k, m, len(colors))``. If `size` is an integer, the\n", + " | output has shape ``(size, len(colors))``. Default is None, in\n", + " | which case a single variate is returned as an array with shape\n", + " | ``(len(colors),)``.\n", + " | method : string, optional\n", + " | Specify the algorithm that is used to generate the variates.\n", + " | Must be 'count' or 'marginals' (the default). See the Notes\n", + " | for a description of the methods.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | variates : ndarray\n", + " | Array of variates drawn from the multivariate hypergeometric\n", + " | distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | hypergeometric : Draw samples from the (univariate) hypergeometric\n", + " | distribution.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The two methods do not return the same sequence of variates.\n", + " |\n", + " | The \"count\" algorithm is roughly equivalent to the following numpy\n", + " | code::\n", + " |\n", + " | choices = np.repeat(np.arange(len(colors)), colors)\n", + " | selection = np.random.choice(choices, nsample, replace=False)\n", + " | variate = np.bincount(selection, minlength=len(colors))\n", + " |\n", + " | The \"count\" algorithm uses a temporary array of integers with length\n", + " | ``sum(colors)``.\n", + " |\n", + " | The \"marginals\" algorithm generates a variate by using repeated\n", + " | calls to the univariate hypergeometric sampler. It is roughly\n", + " | equivalent to::\n", + " |\n", + " | variate = np.zeros(len(colors), dtype=np.int64)\n", + " | # `remaining` is the cumulative sum of `colors` from the last\n", + " | # element to the first; e.g. if `colors` is [3, 1, 5], then\n", + " | # `remaining` is [9, 6, 5].\n", + " | remaining = np.cumsum(colors[::-1])[::-1]\n", + " | for i in range(len(colors)-1):\n", + " | if nsample < 1:\n", + " | break\n", + " | variate[i] = hypergeometric(colors[i], remaining[i+1],\n", + " | nsample)\n", + " | nsample -= variate[i]\n", + " | variate[-1] = nsample\n", + " |\n", + " | The default method is \"marginals\". For some cases (e.g. when\n", + " | `colors` contains relatively small integers), the \"count\" method\n", + " | can be significantly faster than the \"marginals\" method. If\n", + " | performance of the algorithm is important, test the two methods\n", + " | with typical inputs to decide which works best.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> colors = [16, 8, 4]\n", + " | >>> seed = 4861946401452\n", + " | >>> gen = np.random.Generator(np.random.PCG64(seed))\n", + " | >>> gen.multivariate_hypergeometric(colors, 6)\n", + " | array([5, 0, 1])\n", + " | >>> gen.multivariate_hypergeometric(colors, 6, size=3)\n", + " | array([[5, 0, 1],\n", + " | [2, 2, 2],\n", + " | [3, 3, 0]])\n", + " | >>> gen.multivariate_hypergeometric(colors, 6, size=(2, 2))\n", + " | array([[[3, 2, 1],\n", + " | [3, 2, 1]],\n", + " | [[4, 1, 1],\n", + " | [3, 2, 1]]])\n", + " |\n", + " | multivariate_normal(self, mean, cov, size=None, check_valid='warn', tol=1e-08, *, method='svd')\n", + " | multivariate_normal(mean, cov, size=None, check_valid='warn',\n", + " | tol=1e-8, *, method='svd')\n", + " |\n", + " | Draw random samples from a multivariate normal distribution.\n", + " |\n", + " | The multivariate normal, multinormal or Gaussian distribution is a\n", + " | generalization of the one-dimensional normal distribution to higher\n", + " | dimensions. Such a distribution is specified by its mean and\n", + " | covariance matrix. These parameters are analogous to the mean\n", + " | (average or \"center\") and variance (the squared standard deviation,\n", + " | or \"width\") of the one-dimensional normal distribution.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | mean : 1-D array_like, of length N\n", + " | Mean of the N-dimensional distribution.\n", + " | cov : 2-D array_like, of shape (N, N)\n", + " | Covariance matrix of the distribution. It must be symmetric and\n", + " | positive-semidefinite for proper sampling.\n", + " | size : int or tuple of ints, optional\n", + " | Given a shape of, for example, ``(m,n,k)``, ``m*n*k`` samples are\n", + " | generated, and packed in an `m`-by-`n`-by-`k` arrangement. Because\n", + " | each sample is `N`-dimensional, the output shape is ``(m,n,k,N)``.\n", + " | If no shape is specified, a single (`N`-D) sample is returned.\n", + " | check_valid : { 'warn', 'raise', 'ignore' }, optional\n", + " | Behavior when the covariance matrix is not positive semidefinite.\n", + " | tol : float, optional\n", + " | Tolerance when checking the singular values in covariance matrix.\n", + " | cov is cast to double before the check.\n", + " | method : { 'svd', 'eigh', 'cholesky'}, optional\n", + " | The cov input is used to compute a factor matrix A such that\n", + " | ``A @ A.T = cov``. This argument is used to select the method\n", + " | used to compute the factor matrix A. The default method 'svd' is\n", + " | the slowest, while 'cholesky' is the fastest but less robust than\n", + " | the slowest method. The method `eigh` uses eigen decomposition to\n", + " | compute A and is faster than svd but slower than cholesky.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray\n", + " | The drawn samples, of shape *size*, if that was provided. If not,\n", + " | the shape is ``(N,)``.\n", + " |\n", + " | In other words, each entry ``out[i,j,...,:]`` is an N-dimensional\n", + " | value drawn from the distribution.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The mean is a coordinate in N-dimensional space, which represents the\n", + " | location where samples are most likely to be generated. This is\n", + " | analogous to the peak of the bell curve for the one-dimensional or\n", + " | univariate normal distribution.\n", + " |\n", + " | Covariance indicates the level to which two variables vary together.\n", + " | From the multivariate normal distribution, we draw N-dimensional\n", + " | samples, :math:`X = [x_1, x_2, ... x_N]`. The covariance matrix\n", + " | element :math:`C_{ij}` is the covariance of :math:`x_i` and :math:`x_j`.\n", + " | The element :math:`C_{ii}` is the variance of :math:`x_i` (i.e. its\n", + " | \"spread\").\n", + " |\n", + " | Instead of specifying the full covariance matrix, popular\n", + " | approximations include:\n", + " |\n", + " | - Spherical covariance (`cov` is a multiple of the identity matrix)\n", + " | - Diagonal covariance (`cov` has non-negative elements, and only on\n", + " | the diagonal)\n", + " |\n", + " | This geometrical property can be seen in two dimensions by plotting\n", + " | generated data-points:\n", + " |\n", + " | >>> mean = [0, 0]\n", + " | >>> cov = [[1, 0], [0, 100]] # diagonal covariance\n", + " |\n", + " | Diagonal covariance means that points are oriented along x or y-axis:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> x, y = rng.multivariate_normal(mean, cov, 5000).T\n", + " | >>> plt.plot(x, y, 'x')\n", + " | >>> plt.axis('equal')\n", + " | >>> plt.show()\n", + " |\n", + " | Note that the covariance matrix must be positive semidefinite (a.k.a.\n", + " | nonnegative-definite). Otherwise, the behavior of this method is\n", + " | undefined and backwards compatibility is not guaranteed.\n", + " |\n", + " | This function internally uses linear algebra routines, and thus results\n", + " | may not be identical (even up to precision) across architectures, OSes,\n", + " | or even builds. For example, this is likely if ``cov`` has multiple equal\n", + " | singular values and ``method`` is ``'svd'`` (default). In this case,\n", + " | ``method='cholesky'`` may be more robust.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Papoulis, A., \"Probability, Random Variables, and Stochastic\n", + " | Processes,\" 3rd ed., New York: McGraw-Hill, 1991.\n", + " | .. [2] Duda, R. O., Hart, P. E., and Stork, D. G., \"Pattern\n", + " | Classification,\" 2nd ed., New York: Wiley, 2001.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> mean = (1, 2)\n", + " | >>> cov = [[1, 0], [0, 1]]\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> x = rng.multivariate_normal(mean, cov, (3, 3))\n", + " | >>> x.shape\n", + " | (3, 3, 2)\n", + " |\n", + " | We can use a different method other than the default to factorize cov:\n", + " |\n", + " | >>> y = rng.multivariate_normal(mean, cov, (3, 3), method='cholesky')\n", + " | >>> y.shape\n", + " | (3, 3, 2)\n", + " |\n", + " | Here we generate 800 samples from the bivariate normal distribution\n", + " | with mean [0, 0] and covariance matrix [[6, -3], [-3, 3.5]]. The\n", + " | expected variances of the first and second components of the sample\n", + " | are 6 and 3.5, respectively, and the expected correlation\n", + " | coefficient is -3/sqrt(6*3.5) ≈ -0.65465.\n", + " |\n", + " | >>> cov = np.array([[6, -3], [-3, 3.5]])\n", + " | >>> pts = rng.multivariate_normal([0, 0], cov, size=800)\n", + " |\n", + " | Check that the mean, covariance, and correlation coefficient of the\n", + " | sample are close to the expected values:\n", + " |\n", + " | >>> pts.mean(axis=0)\n", + " | array([ 0.0326911 , -0.01280782]) # may vary\n", + " | >>> np.cov(pts.T)\n", + " | array([[ 5.96202397, -2.85602287],\n", + " | [-2.85602287, 3.47613949]]) # may vary\n", + " | >>> np.corrcoef(pts.T)[0, 1]\n", + " | -0.6273591314603949 # may vary\n", + " |\n", + " | We can visualize this data with a scatter plot. The orientation\n", + " | of the point cloud illustrates the negative correlation of the\n", + " | components of this sample.\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> plt.plot(pts[:, 0], pts[:, 1], '.', alpha=0.5)\n", + " | >>> plt.axis('equal')\n", + " | >>> plt.grid()\n", + " | >>> plt.show()\n", + " |\n", + " | negative_binomial(self, n, p, size=None)\n", + " | negative_binomial(n, p, size=None)\n", + " |\n", + " | Draw samples from a negative binomial distribution.\n", + " |\n", + " | Samples are drawn from a negative binomial distribution with specified\n", + " | parameters, `n` successes and `p` probability of success where `n`\n", + " | is > 0 and `p` is in the interval (0, 1].\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | n : float or array_like of floats\n", + " | Parameter of the distribution, > 0.\n", + " | p : float or array_like of floats\n", + " | Parameter of the distribution. Must satisfy 0 < p <= 1.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``n`` and ``p`` are both scalars.\n", + " | Otherwise, ``np.broadcast(n, p).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized negative binomial distribution,\n", + " | where each sample is equal to N, the number of failures that\n", + " | occurred before a total of n successes was reached.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability mass function of the negative binomial distribution is\n", + " |\n", + " | .. math:: P(N;n,p) = \\frac{\\Gamma(N+n)}{N!\\Gamma(n)}p^{n}(1-p)^{N},\n", + " |\n", + " | where :math:`n` is the number of successes, :math:`p` is the\n", + " | probability of success, :math:`N+n` is the number of trials, and\n", + " | :math:`\\Gamma` is the gamma function. When :math:`n` is an integer,\n", + " | :math:`\\frac{\\Gamma(N+n)}{N!\\Gamma(n)} = \\binom{N+n-1}{N}`, which is\n", + " | the more common form of this term in the pmf. The negative\n", + " | binomial distribution gives the probability of N failures given n\n", + " | successes, with a success on the last trial.\n", + " |\n", + " | If one throws a die repeatedly until the third time a \"1\" appears,\n", + " | then the probability distribution of the number of non-\"1\"s that\n", + " | appear before the third \"1\" is a negative binomial distribution.\n", + " |\n", + " | Because this method internally calls ``Generator.poisson`` with an\n", + " | intermediate random value, a ValueError is raised when the choice of\n", + " | :math:`n` and :math:`p` would result in the mean + 10 sigma of the sampled\n", + " | intermediate distribution exceeding the max acceptable value of the\n", + " | ``Generator.poisson`` method. This happens when :math:`p` is too low\n", + " | (a lot of failures happen for every success) and :math:`n` is too big (\n", + " | a lot of successes are allowed).\n", + " | Therefore, the :math:`n` and :math:`p` values must satisfy the constraint:\n", + " |\n", + " | .. math:: n\\frac{1-p}{p}+10n\\sqrt{n}\\frac{1-p}{p}<2^{63}-1-10\\sqrt{2^{63}-1},\n", + " |\n", + " | Where the left side of the equation is the derived mean + 10 sigma of\n", + " | a sample from the gamma distribution internally used as the :math:`lam`\n", + " | parameter of a poisson sample, and the right side of the equation is\n", + " | the constraint for maximum value of :math:`lam` in ``Generator.poisson``.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Weisstein, Eric W. \"Negative Binomial Distribution.\" From\n", + " | MathWorld--A Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/NegativeBinomialDistribution.html\n", + " | .. [2] Wikipedia, \"Negative binomial distribution\",\n", + " | https://en.wikipedia.org/wiki/Negative_binomial_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | A real world example. A company drills wild-cat oil\n", + " | exploration wells, each with an estimated probability of\n", + " | success of 0.1. What is the probability of having one success\n", + " | for each successive well, that is what is the probability of a\n", + " | single success after drilling 5 wells, after 6 wells, etc.?\n", + " |\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> s = rng.negative_binomial(1, 0.1, 100000)\n", + " | >>> for i in range(1, 11): # doctest: +SKIP\n", + " | ... probability = sum(s 0.\n", + " | nonc : float or array_like of floats\n", + " | Non-centrality, must be non-negative.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``df`` and ``nonc`` are both scalars.\n", + " | Otherwise, ``np.broadcast(df, nonc).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized noncentral chi-square distribution.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density function for the noncentral Chi-square\n", + " | distribution is\n", + " |\n", + " | .. math:: P(x;df,nonc) = \\sum^{\\infty}_{i=0}\n", + " | \\frac{e^{-nonc/2}(nonc/2)^{i}}{i!}\n", + " | P_{Y_{df+2i}}(x),\n", + " |\n", + " | where :math:`Y_{q}` is the Chi-square with q degrees of freedom.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Wikipedia, \"Noncentral chi-squared distribution\"\n", + " | https://en.wikipedia.org/wiki/Noncentral_chi-squared_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw values from the distribution and plot the histogram\n", + " |\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> values = plt.hist(rng.noncentral_chisquare(3, 20, 100000),\n", + " | ... bins=200, density=True)\n", + " | >>> plt.show()\n", + " |\n", + " | Draw values from a noncentral chisquare with very small noncentrality,\n", + " | and compare to a chisquare.\n", + " |\n", + " | >>> plt.figure()\n", + " | >>> values = plt.hist(rng.noncentral_chisquare(3, .0000001, 100000),\n", + " | ... bins=np.arange(0., 25, .1), density=True)\n", + " | >>> values2 = plt.hist(rng.chisquare(3, 100000),\n", + " | ... bins=np.arange(0., 25, .1), density=True)\n", + " | >>> plt.plot(values[1][0:-1], values[0]-values2[0], 'ob')\n", + " | >>> plt.show()\n", + " |\n", + " | Demonstrate how large values of non-centrality lead to a more symmetric\n", + " | distribution.\n", + " |\n", + " | >>> plt.figure()\n", + " | >>> values = plt.hist(rng.noncentral_chisquare(3, 20, 100000),\n", + " | ... bins=200, density=True)\n", + " | >>> plt.show()\n", + " |\n", + " | noncentral_f(self, dfnum, dfden, nonc, size=None)\n", + " | noncentral_f(dfnum, dfden, nonc, size=None)\n", + " |\n", + " | Draw samples from the noncentral F distribution.\n", + " |\n", + " | Samples are drawn from an F distribution with specified parameters,\n", + " | `dfnum` (degrees of freedom in numerator) and `dfden` (degrees of\n", + " | freedom in denominator), where both parameters > 1.\n", + " | `nonc` is the non-centrality parameter.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | dfnum : float or array_like of floats\n", + " | Numerator degrees of freedom, must be > 0.\n", + " | dfden : float or array_like of floats\n", + " | Denominator degrees of freedom, must be > 0.\n", + " | nonc : float or array_like of floats\n", + " | Non-centrality parameter, the sum of the squares of the numerator\n", + " | means, must be >= 0.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``dfnum``, ``dfden``, and ``nonc``\n", + " | are all scalars. Otherwise, ``np.broadcast(dfnum, dfden, nonc).size``\n", + " | samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized noncentral Fisher distribution.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | When calculating the power of an experiment (power = probability of\n", + " | rejecting the null hypothesis when a specific alternative is true) the\n", + " | non-central F statistic becomes important. When the null hypothesis is\n", + " | true, the F statistic follows a central F distribution. When the null\n", + " | hypothesis is not true, then it follows a non-central F statistic.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Weisstein, Eric W. \"Noncentral F-Distribution.\"\n", + " | From MathWorld--A Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/NoncentralF-Distribution.html\n", + " | .. [2] Wikipedia, \"Noncentral F-distribution\",\n", + " | https://en.wikipedia.org/wiki/Noncentral_F-distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | In a study, testing for a specific alternative to the null hypothesis\n", + " | requires use of the Noncentral F distribution. We need to calculate the\n", + " | area in the tail of the distribution that exceeds the value of the F\n", + " | distribution for the null hypothesis. We'll plot the two probability\n", + " | distributions for comparison.\n", + " |\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> dfnum = 3 # between group deg of freedom\n", + " | >>> dfden = 20 # within groups degrees of freedom\n", + " | >>> nonc = 3.0\n", + " | >>> nc_vals = rng.noncentral_f(dfnum, dfden, nonc, 1000000)\n", + " | >>> NF = np.histogram(nc_vals, bins=50, density=True)\n", + " | >>> c_vals = rng.f(dfnum, dfden, 1000000)\n", + " | >>> F = np.histogram(c_vals, bins=50, density=True)\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> plt.plot(F[1][1:], F[0])\n", + " | >>> plt.plot(NF[1][1:], NF[0])\n", + " | >>> plt.show()\n", + " |\n", + " | normal(self, loc=0.0, scale=1.0, size=None)\n", + " | normal(loc=0.0, scale=1.0, size=None)\n", + " |\n", + " | Draw random samples from a normal (Gaussian) distribution.\n", + " |\n", + " | The probability density function of the normal distribution, first\n", + " | derived by De Moivre and 200 years later by both Gauss and Laplace\n", + " | independently [2]_, is often called the bell curve because of\n", + " | its characteristic shape (see the example below).\n", + " |\n", + " | The normal distributions occurs often in nature. For example, it\n", + " | describes the commonly occurring distribution of samples influenced\n", + " | by a large number of tiny, random disturbances, each with its own\n", + " | unique distribution [2]_.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | loc : float or array_like of floats\n", + " | Mean (\"centre\") of the distribution.\n", + " | scale : float or array_like of floats\n", + " | Standard deviation (spread or \"width\") of the distribution. Must be\n", + " | non-negative.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``loc`` and ``scale`` are both scalars.\n", + " | Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized normal distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.norm : probability density function, distribution or\n", + " | cumulative density function, etc.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density for the Gaussian distribution is\n", + " |\n", + " | .. math:: p(x) = \\frac{1}{\\sqrt{ 2 \\pi \\sigma^2 }}\n", + " | e^{ - \\frac{ (x - \\mu)^2 } {2 \\sigma^2} },\n", + " |\n", + " | where :math:`\\mu` is the mean and :math:`\\sigma` the standard\n", + " | deviation. The square of the standard deviation, :math:`\\sigma^2`,\n", + " | is called the variance.\n", + " |\n", + " | The function has its peak at the mean, and its \"spread\" increases with\n", + " | the standard deviation (the function reaches 0.607 times its maximum at\n", + " | :math:`x + \\sigma` and :math:`x - \\sigma` [2]_). This implies that\n", + " | :meth:`normal` is more likely to return samples lying close to the\n", + " | mean, rather than those far away.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Wikipedia, \"Normal distribution\",\n", + " | https://en.wikipedia.org/wiki/Normal_distribution\n", + " | .. [2] P. R. Peebles Jr., \"Central Limit Theorem\" in \"Probability,\n", + " | Random Variables and Random Signal Principles\", 4th ed., 2001,\n", + " | pp. 51, 51, 125.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> mu, sigma = 0, 0.1 # mean and standard deviation\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> s = rng.normal(mu, sigma, 1000)\n", + " |\n", + " | Verify the mean and the standard deviation:\n", + " |\n", + " | >>> abs(mu - np.mean(s))\n", + " | 0.0 # may vary\n", + " |\n", + " | >>> abs(sigma - np.std(s, ddof=1))\n", + " | 0.0 # may vary\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, _ = plt.hist(s, 30, density=True)\n", + " | >>> plt.plot(bins, 1/(sigma * np.sqrt(2 * np.pi)) *\n", + " | ... np.exp( - (bins - mu)**2 / (2 * sigma**2) ),\n", + " | ... linewidth=2, color='r')\n", + " | >>> plt.show()\n", + " |\n", + " | Two-by-four array of samples from the normal distribution with\n", + " | mean 3 and standard deviation 2.5:\n", + " |\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> rng.normal(3, 2.5, size=(2, 4))\n", + " | array([[-4.49401501, 4.00950034, -1.81814867, 7.29718677], # random\n", + " | [ 0.39924804, 4.68456316, 4.99394529, 4.84057254]]) # random\n", + " |\n", + " | pareto(self, a, size=None)\n", + " | pareto(a, size=None)\n", + " |\n", + " | Draw samples from a Pareto II (AKA Lomax) distribution with\n", + " | specified shape.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | a : float or array_like of floats\n", + " | Shape of the distribution. Must be positive.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``a`` is a scalar. Otherwise,\n", + " | ``np.array(a).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the Pareto II distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.pareto : Pareto I distribution\n", + " | scipy.stats.lomax : Lomax (Pareto II) distribution\n", + " | scipy.stats.genpareto : Generalized Pareto distribution\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density for the Pareto II distribution is\n", + " |\n", + " | .. math:: p(x) = \\frac{a}{{x+1}^{a+1}} , x \\ge 0\n", + " |\n", + " | where :math:`a > 0` is the shape.\n", + " |\n", + " | The Pareto II distribution is a shifted and scaled version of the\n", + " | Pareto I distribution, which can be found in `scipy.stats.pareto`.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Francis Hunt and Paul Johnson, On the Pareto Distribution of\n", + " | Sourceforge projects.\n", + " | .. [2] Pareto, V. (1896). Course of Political Economy. Lausanne.\n", + " | .. [3] Reiss, R.D., Thomas, M.(2001), Statistical Analysis of Extreme\n", + " | Values, Birkhauser Verlag, Basel, pp 23-30.\n", + " | .. [4] Wikipedia, \"Pareto distribution\",\n", + " | https://en.wikipedia.org/wiki/Pareto_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> a = 3.\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> s = rng.pareto(a, 10000)\n", + " |\n", + " | Display the histogram of the samples, along with the probability\n", + " | density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> x = np.linspace(0, 3, 50)\n", + " | >>> pdf = a / (x+1)**(a+1)\n", + " | >>> plt.hist(s, bins=x, density=True, label='histogram')\n", + " | >>> plt.plot(x, pdf, linewidth=2, color='r', label='pdf')\n", + " | >>> plt.xlim(x.min(), x.max())\n", + " | >>> plt.legend()\n", + " | >>> plt.show()\n", + " |\n", + " | permutation(self, x, axis=0)\n", + " | permutation(x, axis=0)\n", + " |\n", + " | Randomly permute a sequence, or return a permuted range.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | x : int or array_like\n", + " | If `x` is an integer, randomly permute ``np.arange(x)``.\n", + " | If `x` is an array, make a copy and shuffle the elements\n", + " | randomly.\n", + " | axis : int, optional\n", + " | The axis which `x` is shuffled along. Default is 0.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray\n", + " | Permuted sequence or array range.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> rng.permutation(10)\n", + " | array([1, 7, 4, 3, 0, 9, 2, 5, 8, 6]) # random\n", + " |\n", + " | >>> rng.permutation([1, 4, 9, 12, 15])\n", + " | array([15, 1, 9, 4, 12]) # random\n", + " |\n", + " | >>> arr = np.arange(9).reshape((3, 3))\n", + " | >>> rng.permutation(arr)\n", + " | array([[6, 7, 8], # random\n", + " | [0, 1, 2],\n", + " | [3, 4, 5]])\n", + " |\n", + " | >>> rng.permutation(\"abc\")\n", + " | Traceback (most recent call last):\n", + " | ...\n", + " | numpy.exceptions.AxisError: axis 0 is out of bounds for array of dimension 0\n", + " |\n", + " | >>> arr = np.arange(9).reshape((3, 3))\n", + " | >>> rng.permutation(arr, axis=1)\n", + " | array([[0, 2, 1], # random\n", + " | [3, 5, 4],\n", + " | [6, 8, 7]])\n", + " |\n", + " | permuted(self, x, *, axis=None, out=None)\n", + " | permuted(x, axis=None, out=None)\n", + " |\n", + " | Randomly permute `x` along axis `axis`.\n", + " |\n", + " | Unlike `shuffle`, each slice along the given axis is shuffled\n", + " | independently of the others.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | x : array_like, at least one-dimensional\n", + " | Array to be shuffled.\n", + " | axis : int, optional\n", + " | Slices of `x` in this axis are shuffled. Each slice\n", + " | is shuffled independently of the others. If `axis` is\n", + " | None, the flattened array is shuffled.\n", + " | out : ndarray, optional\n", + " | If given, this is the destination of the shuffled array.\n", + " | If `out` is None, a shuffled copy of the array is returned.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | ndarray\n", + " | If `out` is None, a shuffled copy of `x` is returned.\n", + " | Otherwise, the shuffled array is stored in `out`,\n", + " | and `out` is returned\n", + " |\n", + " | See Also\n", + " | --------\n", + " | shuffle\n", + " | permutation\n", + " |\n", + " | Notes\n", + " | -----\n", + " | An important distinction between methods ``shuffle`` and ``permuted`` is\n", + " | how they both treat the ``axis`` parameter which can be found at\n", + " | :ref:`generator-handling-axis-parameter`.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Create a `numpy.random.Generator` instance:\n", + " |\n", + " | >>> rng = np.random.default_rng()\n", + " |\n", + " | Create a test array:\n", + " |\n", + " | >>> x = np.arange(24).reshape(3, 8)\n", + " | >>> x\n", + " | array([[ 0, 1, 2, 3, 4, 5, 6, 7],\n", + " | [ 8, 9, 10, 11, 12, 13, 14, 15],\n", + " | [16, 17, 18, 19, 20, 21, 22, 23]])\n", + " |\n", + " | Shuffle the rows of `x`:\n", + " |\n", + " | >>> y = rng.permuted(x, axis=1)\n", + " | >>> y\n", + " | array([[ 4, 3, 6, 7, 1, 2, 5, 0], # random\n", + " | [15, 10, 14, 9, 12, 11, 8, 13],\n", + " | [17, 16, 20, 21, 18, 22, 23, 19]])\n", + " |\n", + " | `x` has not been modified:\n", + " |\n", + " | >>> x\n", + " | array([[ 0, 1, 2, 3, 4, 5, 6, 7],\n", + " | [ 8, 9, 10, 11, 12, 13, 14, 15],\n", + " | [16, 17, 18, 19, 20, 21, 22, 23]])\n", + " |\n", + " | To shuffle the rows of `x` in-place, pass `x` as the `out`\n", + " | parameter:\n", + " |\n", + " | >>> y = rng.permuted(x, axis=1, out=x)\n", + " | >>> x\n", + " | array([[ 3, 0, 4, 7, 1, 6, 2, 5], # random\n", + " | [ 8, 14, 13, 9, 12, 11, 15, 10],\n", + " | [17, 18, 16, 22, 19, 23, 20, 21]])\n", + " |\n", + " | Note that when the ``out`` parameter is given, the return\n", + " | value is ``out``:\n", + " |\n", + " | >>> y is x\n", + " | True\n", + " |\n", + " | poisson(self, lam=1.0, size=None)\n", + " | poisson(lam=1.0, size=None)\n", + " |\n", + " | Draw samples from a Poisson distribution.\n", + " |\n", + " | The Poisson distribution is the limit of the binomial distribution\n", + " | for large N.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | lam : float or array_like of floats\n", + " | Expected number of events occurring in a fixed-time interval,\n", + " | must be >= 0. A sequence must be broadcastable over the requested\n", + " | size.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``lam`` is a scalar. Otherwise,\n", + " | ``np.array(lam).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized Poisson distribution.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability mass function (PMF) of Poisson distribution is\n", + " |\n", + " | .. math:: f(k; \\lambda)=\\frac{\\lambda^k e^{-\\lambda}}{k!}\n", + " |\n", + " | For events with an expected separation :math:`\\lambda` the Poisson\n", + " | distribution :math:`f(k; \\lambda)` describes the probability of\n", + " | :math:`k` events occurring within the observed\n", + " | interval :math:`\\lambda`.\n", + " |\n", + " | Because the output is limited to the range of the C int64 type, a\n", + " | ValueError is raised when `lam` is within 10 sigma of the maximum\n", + " | representable value.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Weisstein, Eric W. \"Poisson Distribution.\"\n", + " | From MathWorld--A Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/PoissonDistribution.html\n", + " | .. [2] Wikipedia, \"Poisson distribution\",\n", + " | https://en.wikipedia.org/wiki/Poisson_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> lam, size = 5, 10000\n", + " | >>> s = rng.poisson(lam=lam, size=size)\n", + " |\n", + " | Verify the mean and variance, which should be approximately ``lam``:\n", + " |\n", + " | >>> s.mean(), s.var()\n", + " | (4.9917 5.1088311) # may vary\n", + " |\n", + " | Display the histogram and probability mass function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> from scipy import stats\n", + " | >>> x = np.arange(0, 21)\n", + " | >>> pmf = stats.poisson.pmf(x, mu=lam)\n", + " | >>> plt.hist(s, bins=x, density=True, width=0.5)\n", + " | >>> plt.stem(x, pmf, 'C1-')\n", + " | >>> plt.show()\n", + " |\n", + " | Draw each 100 values for lambda 100 and 500:\n", + " |\n", + " | >>> s = rng.poisson(lam=(100., 500.), size=(100, 2))\n", + " |\n", + " | power(self, a, size=None)\n", + " | power(a, size=None)\n", + " |\n", + " | Draws samples in [0, 1] from a power distribution with positive\n", + " | exponent a - 1.\n", + " |\n", + " | Also known as the power function distribution.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | a : float or array_like of floats\n", + " | Parameter of the distribution. Must be non-negative.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``a`` is a scalar. Otherwise,\n", + " | ``np.array(a).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized power distribution.\n", + " |\n", + " | Raises\n", + " | ------\n", + " | ValueError\n", + " | If a <= 0.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density function is\n", + " |\n", + " | .. math:: P(x; a) = ax^{a-1}, 0 \\le x \\le 1, a>0.\n", + " |\n", + " | The power function distribution is just the inverse of the Pareto\n", + " | distribution. It may also be seen as a special case of the Beta\n", + " | distribution.\n", + " |\n", + " | It is used, for example, in modeling the over-reporting of insurance\n", + " | claims.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Christian Kleiber, Samuel Kotz, \"Statistical size distributions\n", + " | in economics and actuarial sciences\", Wiley, 2003.\n", + " | .. [2] Heckert, N. A. and Filliben, James J. \"NIST Handbook 148:\n", + " | Dataplot Reference Manual, Volume 2: Let Subcommands and Library\n", + " | Functions\", National Institute of Standards and Technology\n", + " | Handbook Series, June 2003.\n", + " | https://www.itl.nist.gov/div898/software/dataplot/refman2/auxillar/powpdf.pdf\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> a = 5. # shape\n", + " | >>> samples = 1000\n", + " | >>> s = rng.power(a, samples)\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, _ = plt.hist(s, bins=30)\n", + " | >>> x = np.linspace(0, 1, 100)\n", + " | >>> y = a*x**(a-1.)\n", + " | >>> normed_y = samples*np.diff(bins)[0]*y\n", + " | >>> plt.plot(x, normed_y)\n", + " | >>> plt.show()\n", + " |\n", + " | Compare the power function distribution to the inverse of the Pareto.\n", + " |\n", + " | >>> from scipy import stats # doctest: +SKIP\n", + " | >>> rvs = rng.power(5, 1000000)\n", + " | >>> rvsp = rng.pareto(5, 1000000)\n", + " | >>> xx = np.linspace(0,1,100)\n", + " | >>> powpdf = stats.powerlaw.pdf(xx,5) # doctest: +SKIP\n", + " |\n", + " | >>> plt.figure()\n", + " | >>> plt.hist(rvs, bins=50, density=True)\n", + " | >>> plt.plot(xx,powpdf,'r-') # doctest: +SKIP\n", + " | >>> plt.title('power(5)')\n", + " |\n", + " | >>> plt.figure()\n", + " | >>> plt.hist(1./(1.+rvsp), bins=50, density=True)\n", + " | >>> plt.plot(xx,powpdf,'r-') # doctest: +SKIP\n", + " | >>> plt.title('inverse of 1 + Generator.pareto(5)')\n", + " |\n", + " | >>> plt.figure()\n", + " | >>> plt.hist(1./(1.+rvsp), bins=50, density=True)\n", + " | >>> plt.plot(xx,powpdf,'r-') # doctest: +SKIP\n", + " | >>> plt.title('inverse of stats.pareto(5)')\n", + " |\n", + " | random(self, size=None, dtype=, out=None)\n", + " | random(size=None, dtype=np.float64, out=None)\n", + " |\n", + " | Return random floats in the half-open interval [0.0, 1.0).\n", + " |\n", + " | Results are from the \"continuous uniform\" distribution over the\n", + " | stated interval. To sample :math:`Unif[a, b), b > a` use `uniform`\n", + " | or multiply the output of `random` by ``(b - a)`` and add ``a``::\n", + " |\n", + " | (b - a) * random() + a\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " | dtype : dtype, optional\n", + " | Desired dtype of the result, only `float64` and `float32` are supported.\n", + " | Byteorder must be native. The default value is np.float64.\n", + " | out : ndarray, optional\n", + " | Alternative output array in which to place the result. If size is not None,\n", + " | it must have the same shape as the provided size and must match the type of\n", + " | the output values.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : float or ndarray of floats\n", + " | Array of random floats of shape `size` (unless ``size=None``, in which\n", + " | case a single float is returned).\n", + " |\n", + " | See Also\n", + " | --------\n", + " | uniform : Draw samples from the parameterized uniform distribution.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> rng.random()\n", + " | 0.47108547995356098 # random\n", + " | >>> type(rng.random())\n", + " | \n", + " | >>> rng.random((5,))\n", + " | array([ 0.30220482, 0.86820401, 0.1654503 , 0.11659149, 0.54323428]) # random\n", + " |\n", + " | Three-by-two array of random numbers from [-5, 0):\n", + " |\n", + " | >>> 5 * rng.random((3, 2)) - 5\n", + " | array([[-3.99149989, -0.52338984], # random\n", + " | [-2.99091858, -0.79479508],\n", + " | [-1.23204345, -1.75224494]])\n", + " |\n", + " | rayleigh(self, scale=1.0, size=None)\n", + " | rayleigh(scale=1.0, size=None)\n", + " |\n", + " | Draw samples from a Rayleigh distribution.\n", + " |\n", + " | The :math:`\\chi` and Weibull distributions are generalizations of the\n", + " | Rayleigh.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | scale : float or array_like of floats, optional\n", + " | Scale, also equals the mode. Must be non-negative. Default is 1.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``scale`` is a scalar. Otherwise,\n", + " | ``np.array(scale).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized Rayleigh distribution.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density function for the Rayleigh distribution is\n", + " |\n", + " | .. math:: P(x;scale) = \\frac{x}{scale^2}e^{\\frac{-x^2}{2 \\cdotp scale^2}}\n", + " |\n", + " | The Rayleigh distribution would arise, for example, if the East\n", + " | and North components of the wind velocity had identical zero-mean\n", + " | Gaussian distributions. Then the wind speed would have a Rayleigh\n", + " | distribution.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Brighton Webs Ltd., \"Rayleigh Distribution,\"\n", + " | https://web.archive.org/web/20090514091424/http://brighton-webs.co.uk:80/distributions/rayleigh.asp\n", + " | .. [2] Wikipedia, \"Rayleigh distribution\"\n", + " | https://en.wikipedia.org/wiki/Rayleigh_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw values from the distribution and plot the histogram\n", + " |\n", + " | >>> from matplotlib.pyplot import hist\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> values = hist(rng.rayleigh(3, 100000), bins=200, density=True)\n", + " |\n", + " | Wave heights tend to follow a Rayleigh distribution. If the mean wave\n", + " | height is 1 meter, what fraction of waves are likely to be larger than 3\n", + " | meters?\n", + " |\n", + " | >>> meanvalue = 1\n", + " | >>> modevalue = np.sqrt(2 / np.pi) * meanvalue\n", + " | >>> s = rng.rayleigh(modevalue, 1000000)\n", + " |\n", + " | The percentage of waves larger than 3 meters is:\n", + " |\n", + " | >>> 100.*sum(s>3)/1000000.\n", + " | 0.087300000000000003 # random\n", + " |\n", + " | shuffle(self, x, axis=0)\n", + " | shuffle(x, axis=0)\n", + " |\n", + " | Modify an array or sequence in-place by shuffling its contents.\n", + " |\n", + " | The order of sub-arrays is changed but their contents remains the same.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | x : ndarray or MutableSequence\n", + " | The array, list or mutable sequence to be shuffled.\n", + " | axis : int, optional\n", + " | The axis which `x` is shuffled along. Default is 0.\n", + " | It is only supported on `ndarray` objects.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | None\n", + " |\n", + " | See Also\n", + " | --------\n", + " | permuted\n", + " | permutation\n", + " |\n", + " | Notes\n", + " | -----\n", + " | An important distinction between methods ``shuffle`` and ``permuted`` is\n", + " | how they both treat the ``axis`` parameter which can be found at\n", + " | :ref:`generator-handling-axis-parameter`.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> arr = np.arange(10)\n", + " | >>> arr\n", + " | array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n", + " | >>> rng.shuffle(arr)\n", + " | >>> arr\n", + " | array([2, 0, 7, 5, 1, 4, 8, 9, 3, 6]) # random\n", + " |\n", + " | >>> arr = np.arange(9).reshape((3, 3))\n", + " | >>> arr\n", + " | array([[0, 1, 2],\n", + " | [3, 4, 5],\n", + " | [6, 7, 8]])\n", + " | >>> rng.shuffle(arr)\n", + " | >>> arr\n", + " | array([[3, 4, 5], # random\n", + " | [6, 7, 8],\n", + " | [0, 1, 2]])\n", + " |\n", + " | >>> arr = np.arange(9).reshape((3, 3))\n", + " | >>> arr\n", + " | array([[0, 1, 2],\n", + " | [3, 4, 5],\n", + " | [6, 7, 8]])\n", + " | >>> rng.shuffle(arr, axis=1)\n", + " | >>> arr\n", + " | array([[2, 0, 1], # random\n", + " | [5, 3, 4],\n", + " | [8, 6, 7]])\n", + " |\n", + " | spawn(self, n_children)\n", + " | spawn(n_children)\n", + " |\n", + " | Create new independent child generators.\n", + " |\n", + " | See :ref:`seedsequence-spawn` for additional notes on spawning\n", + " | children.\n", + " |\n", + " | .. versionadded:: 1.25.0\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | n_children : int\n", + " |\n", + " | Returns\n", + " | -------\n", + " | child_generators : list of Generators\n", + " |\n", + " | Raises\n", + " | ------\n", + " | TypeError\n", + " | When the underlying SeedSequence does not implement spawning.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.BitGenerator.spawn, random.SeedSequence.spawn :\n", + " | Equivalent method on the bit generator and seed sequence.\n", + " | bit_generator :\n", + " | The bit generator instance used by the generator.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Starting from a seeded default generator:\n", + " |\n", + " | >>> # High quality entropy created with: f\"0x{secrets.randbits(128):x}\"\n", + " | >>> entropy = 0x3034c61a9ae04ff8cb62ab8ec2c4b501\n", + " | >>> rng = np.random.default_rng(entropy)\n", + " |\n", + " | Create two new generators for example for parallel execution:\n", + " |\n", + " | >>> child_rng1, child_rng2 = rng.spawn(2)\n", + " |\n", + " | Drawn numbers from each are independent but derived from the initial\n", + " | seeding entropy:\n", + " |\n", + " | >>> rng.uniform(), child_rng1.uniform(), child_rng2.uniform()\n", + " | (0.19029263503854454, 0.9475673279178444, 0.4702687338396767)\n", + " |\n", + " | It is safe to spawn additional children from the original ``rng`` or\n", + " | the children:\n", + " |\n", + " | >>> more_child_rngs = rng.spawn(20)\n", + " | >>> nested_spawn = child_rng1.spawn(20)\n", + " |\n", + " | standard_cauchy(self, size=None)\n", + " | standard_cauchy(size=None)\n", + " |\n", + " | Draw samples from a standard Cauchy distribution with mode = 0.\n", + " |\n", + " | Also known as the Lorentz distribution.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | samples : ndarray or scalar\n", + " | The drawn samples.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density function for the full Cauchy distribution is\n", + " |\n", + " | .. math:: P(x; x_0, \\gamma) = \\frac{1}{\\pi \\gamma \\bigl[ 1+\n", + " | (\\frac{x-x_0}{\\gamma})^2 \\bigr] }\n", + " |\n", + " | and the Standard Cauchy distribution just sets :math:`x_0=0` and\n", + " | :math:`\\gamma=1`\n", + " |\n", + " | The Cauchy distribution arises in the solution to the driven harmonic\n", + " | oscillator problem, and also describes spectral line broadening. It\n", + " | also describes the distribution of values at which a line tilted at\n", + " | a random angle will cut the x axis.\n", + " |\n", + " | When studying hypothesis tests that assume normality, seeing how the\n", + " | tests perform on data from a Cauchy distribution is a good indicator of\n", + " | their sensitivity to a heavy-tailed distribution, since the Cauchy looks\n", + " | very much like a Gaussian distribution, but with heavier tails.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] NIST/SEMATECH e-Handbook of Statistical Methods, \"Cauchy\n", + " | Distribution\",\n", + " | https://www.itl.nist.gov/div898/handbook/eda/section3/eda3663.htm\n", + " | .. [2] Weisstein, Eric W. \"Cauchy Distribution.\" From MathWorld--A\n", + " | Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/CauchyDistribution.html\n", + " | .. [3] Wikipedia, \"Cauchy distribution\"\n", + " | https://en.wikipedia.org/wiki/Cauchy_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples and plot the distribution:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> s = rng.standard_cauchy(1000000)\n", + " | >>> s = s[(s>-25) & (s<25)] # truncate distribution so it plots well\n", + " | >>> plt.hist(s, bins=100)\n", + " | >>> plt.show()\n", + " |\n", + " | standard_exponential(self, size=None, dtype=, method='zig', out=None)\n", + " | standard_exponential(size=None, dtype=np.float64, method='zig', out=None)\n", + " |\n", + " | Draw samples from the standard exponential distribution.\n", + " |\n", + " | `standard_exponential` is identical to the exponential distribution\n", + " | with a scale parameter of 1.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " | dtype : dtype, optional\n", + " | Desired dtype of the result, only `float64` and `float32` are supported.\n", + " | Byteorder must be native. The default value is np.float64.\n", + " | method : str, optional\n", + " | Either 'inv' or 'zig'. 'inv' uses the default inverse CDF method.\n", + " | 'zig' uses the much faster Ziggurat method of Marsaglia and Tsang.\n", + " | out : ndarray, optional\n", + " | Alternative output array in which to place the result. If size is not None,\n", + " | it must have the same shape as the provided size and must match the type of\n", + " | the output values.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : float or ndarray\n", + " | Drawn samples.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Output a 3x8000 array:\n", + " |\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> n = rng.standard_exponential((3, 8000))\n", + " |\n", + " | standard_gamma(self, shape, size=None, dtype=, out=None)\n", + " | standard_gamma(shape, size=None, dtype=np.float64, out=None)\n", + " |\n", + " | Draw samples from a standard Gamma distribution.\n", + " |\n", + " | Samples are drawn from a Gamma distribution with specified parameters,\n", + " | shape (sometimes designated \"k\") and scale=1.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | shape : float or array_like of floats\n", + " | Parameter, must be non-negative.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``shape`` is a scalar. Otherwise,\n", + " | ``np.array(shape).size`` samples are drawn.\n", + " | dtype : dtype, optional\n", + " | Desired dtype of the result, only `float64` and `float32` are supported.\n", + " | Byteorder must be native. The default value is np.float64.\n", + " | out : ndarray, optional\n", + " | Alternative output array in which to place the result. If size is\n", + " | not None, it must have the same shape as the provided size and\n", + " | must match the type of the output values.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized standard gamma distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.gamma : probability density function, distribution or\n", + " | cumulative density function, etc.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density for the Gamma distribution is\n", + " |\n", + " | .. math:: p(x) = x^{k-1}\\frac{e^{-x/\\theta}}{\\theta^k\\Gamma(k)},\n", + " |\n", + " | where :math:`k` is the shape and :math:`\\theta` the scale,\n", + " | and :math:`\\Gamma` is the Gamma function.\n", + " |\n", + " | The Gamma distribution is often used to model the times to failure of\n", + " | electronic components, and arises naturally in processes for which the\n", + " | waiting times between Poisson distributed events are relevant.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Weisstein, Eric W. \"Gamma Distribution.\" From MathWorld--A\n", + " | Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/GammaDistribution.html\n", + " | .. [2] Wikipedia, \"Gamma distribution\",\n", + " | https://en.wikipedia.org/wiki/Gamma_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> shape, scale = 2., 1. # mean and width\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> s = rng.standard_gamma(shape, 1000000)\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> import scipy.special as sps # doctest: +SKIP\n", + " | >>> count, bins, _ = plt.hist(s, 50, density=True)\n", + " | >>> y = bins**(shape-1) * ((np.exp(-bins/scale))/ # doctest: +SKIP\n", + " | ... (sps.gamma(shape) * scale**shape))\n", + " | >>> plt.plot(bins, y, linewidth=2, color='r') # doctest: +SKIP\n", + " | >>> plt.show()\n", + " |\n", + " | standard_normal(self, size=None, dtype=, out=None)\n", + " | standard_normal(size=None, dtype=np.float64, out=None)\n", + " |\n", + " | Draw samples from a standard Normal distribution (mean=0, stdev=1).\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " | dtype : dtype, optional\n", + " | Desired dtype of the result, only `float64` and `float32` are supported.\n", + " | Byteorder must be native. The default value is np.float64.\n", + " | out : ndarray, optional\n", + " | Alternative output array in which to place the result. If size is not None,\n", + " | it must have the same shape as the provided size and must match the type of\n", + " | the output values.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : float or ndarray\n", + " | A floating-point array of shape ``size`` of drawn samples, or a\n", + " | single sample if ``size`` was not specified.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | normal :\n", + " | Equivalent function with additional ``loc`` and ``scale`` arguments\n", + " | for setting the mean and standard deviation.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | For random samples from the normal distribution with mean ``mu`` and\n", + " | standard deviation ``sigma``, use one of::\n", + " |\n", + " | mu + sigma * rng.standard_normal(size=...)\n", + " | rng.normal(mu, sigma, size=...)\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> rng.standard_normal()\n", + " | 2.1923875335537315 # random\n", + " |\n", + " | >>> s = rng.standard_normal(8000)\n", + " | >>> s\n", + " | array([ 0.6888893 , 0.78096262, -0.89086505, ..., 0.49876311, # random\n", + " | -0.38672696, -0.4685006 ]) # random\n", + " | >>> s.shape\n", + " | (8000,)\n", + " | >>> s = rng.standard_normal(size=(3, 4, 2))\n", + " | >>> s.shape\n", + " | (3, 4, 2)\n", + " |\n", + " | Two-by-four array of samples from the normal distribution with\n", + " | mean 3 and standard deviation 2.5:\n", + " |\n", + " | >>> 3 + 2.5 * rng.standard_normal(size=(2, 4))\n", + " | array([[-4.49401501, 4.00950034, -1.81814867, 7.29718677], # random\n", + " | [ 0.39924804, 4.68456316, 4.99394529, 4.84057254]]) # random\n", + " |\n", + " | standard_t(self, df, size=None)\n", + " | standard_t(df, size=None)\n", + " |\n", + " | Draw samples from a standard Student's t distribution with `df` degrees\n", + " | of freedom.\n", + " |\n", + " | A special case of the hyperbolic distribution. As `df` gets\n", + " | large, the result resembles that of the standard normal\n", + " | distribution (`standard_normal`).\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | df : float or array_like of floats\n", + " | Degrees of freedom, must be > 0.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``df`` is a scalar. Otherwise,\n", + " | ``np.array(df).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized standard Student's t distribution.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density function for the t distribution is\n", + " |\n", + " | .. math:: P(x, df) = \\frac{\\Gamma(\\frac{df+1}{2})}{\\sqrt{\\pi df}\n", + " | \\Gamma(\\frac{df}{2})}\\Bigl( 1+\\frac{x^2}{df} \\Bigr)^{-(df+1)/2}\n", + " |\n", + " | The t test is based on an assumption that the data come from a\n", + " | Normal distribution. The t test provides a way to test whether\n", + " | the sample mean (that is the mean calculated from the data) is\n", + " | a good estimate of the true mean.\n", + " |\n", + " | The derivation of the t-distribution was first published in\n", + " | 1908 by William Gosset while working for the Guinness Brewery\n", + " | in Dublin. Due to proprietary issues, he had to publish under\n", + " | a pseudonym, and so he used the name Student.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Dalgaard, Peter, \"Introductory Statistics With R\",\n", + " | Springer, 2002.\n", + " | .. [2] Wikipedia, \"Student's t-distribution\"\n", + " | https://en.wikipedia.org/wiki/Student's_t-distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | From Dalgaard page 83 [1]_, suppose the daily energy intake for 11\n", + " | women in kilojoules (kJ) is:\n", + " |\n", + " | >>> intake = np.array([5260., 5470, 5640, 6180, 6390, 6515, 6805, 7515, \\\n", + " | ... 7515, 8230, 8770])\n", + " |\n", + " | Does their energy intake deviate systematically from the recommended\n", + " | value of 7725 kJ? Our null hypothesis will be the absence of deviation,\n", + " | and the alternate hypothesis will be the presence of an effect that could be\n", + " | either positive or negative, hence making our test 2-tailed.\n", + " |\n", + " | Because we are estimating the mean and we have N=11 values in our sample,\n", + " | we have N-1=10 degrees of freedom. We set our significance level to 95% and\n", + " | compute the t statistic using the empirical mean and empirical standard\n", + " | deviation of our intake. We use a ddof of 1 to base the computation of our\n", + " | empirical standard deviation on an unbiased estimate of the variance (note:\n", + " | the final estimate is not unbiased due to the concave nature of the square\n", + " | root).\n", + " |\n", + " | >>> np.mean(intake)\n", + " | 6753.636363636364\n", + " | >>> intake.std(ddof=1)\n", + " | 1142.1232221373727\n", + " | >>> t = (np.mean(intake)-7725)/(intake.std(ddof=1)/np.sqrt(len(intake)))\n", + " | >>> t\n", + " | -2.8207540608310198\n", + " |\n", + " | We draw 1000000 samples from Student's t distribution with the adequate\n", + " | degrees of freedom.\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> s = rng.standard_t(10, size=1000000)\n", + " | >>> h = plt.hist(s, bins=100, density=True)\n", + " |\n", + " | Does our t statistic land in one of the two critical regions found at\n", + " | both tails of the distribution?\n", + " |\n", + " | >>> np.sum(np.abs(t) < np.abs(s)) / float(len(s))\n", + " | 0.018318 #random < 0.05, statistic is in critical region\n", + " |\n", + " | The probability value for this 2-tailed test is about 1.83%, which is\n", + " | lower than the 5% pre-determined significance threshold.\n", + " |\n", + " | Therefore, the probability of observing values as extreme as our intake\n", + " | conditionally on the null hypothesis being true is too low, and we reject\n", + " | the null hypothesis of no deviation.\n", + " |\n", + " | triangular(self, left, mode, right, size=None)\n", + " | triangular(left, mode, right, size=None)\n", + " |\n", + " | Draw samples from the triangular distribution over the\n", + " | interval ``[left, right]``.\n", + " |\n", + " | The triangular distribution is a continuous probability\n", + " | distribution with lower limit left, peak at mode, and upper\n", + " | limit right. Unlike the other distributions, these parameters\n", + " | directly define the shape of the pdf.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | left : float or array_like of floats\n", + " | Lower limit.\n", + " | mode : float or array_like of floats\n", + " | The value where the peak of the distribution occurs.\n", + " | The value must fulfill the condition ``left <= mode <= right``.\n", + " | right : float or array_like of floats\n", + " | Upper limit, must be larger than `left`.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``left``, ``mode``, and ``right``\n", + " | are all scalars. Otherwise, ``np.broadcast(left, mode, right).size``\n", + " | samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized triangular distribution.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density function for the triangular distribution is\n", + " |\n", + " | .. math:: P(x;l, m, r) = \\begin{cases}\n", + " | \\frac{2(x-l)}{(r-l)(m-l)}& \\text{for $l \\leq x \\leq m$},\\\\\n", + " | \\frac{2(r-x)}{(r-l)(r-m)}& \\text{for $m \\leq x \\leq r$},\\\\\n", + " | 0& \\text{otherwise}.\n", + " | \\end{cases}\n", + " |\n", + " | The triangular distribution is often used in ill-defined\n", + " | problems where the underlying distribution is not known, but\n", + " | some knowledge of the limits and mode exists. Often it is used\n", + " | in simulations.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Wikipedia, \"Triangular distribution\"\n", + " | https://en.wikipedia.org/wiki/Triangular_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw values from the distribution and plot the histogram:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> h = plt.hist(rng.triangular(-3, 0, 8, 100000), bins=200,\n", + " | ... density=True)\n", + " | >>> plt.show()\n", + " |\n", + " | uniform(self, low=0.0, high=1.0, size=None)\n", + " | uniform(low=0.0, high=1.0, size=None)\n", + " |\n", + " | Draw samples from a uniform distribution.\n", + " |\n", + " | Samples are uniformly distributed over the half-open interval\n", + " | ``[low, high)`` (includes low, but excludes high). In other words,\n", + " | any value within the given interval is equally likely to be drawn\n", + " | by `uniform`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | low : float or array_like of floats, optional\n", + " | Lower boundary of the output interval. All values generated will be\n", + " | greater than or equal to low. The default value is 0.\n", + " | high : float or array_like of floats\n", + " | Upper boundary of the output interval. All values generated will be\n", + " | less than high. The high limit may be included in the returned array of\n", + " | floats due to floating-point rounding in the equation\n", + " | ``low + (high-low) * random_sample()``. high - low must be\n", + " | non-negative. The default value is 1.0.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``low`` and ``high`` are both scalars.\n", + " | Otherwise, ``np.broadcast(low, high).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized uniform distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | integers : Discrete uniform distribution, yielding integers.\n", + " | random : Floats uniformly distributed over ``[0, 1)``.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density function of the uniform distribution is\n", + " |\n", + " | .. math:: p(x) = \\frac{1}{b - a}\n", + " |\n", + " | anywhere within the interval ``[a, b)``, and zero elsewhere.\n", + " |\n", + " | When ``high`` == ``low``, values of ``low`` will be returned.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> s = rng.uniform(-1,0,1000)\n", + " |\n", + " | All values are within the given interval:\n", + " |\n", + " | >>> np.all(s >= -1)\n", + " | True\n", + " | >>> np.all(s < 0)\n", + " | True\n", + " |\n", + " | Display the histogram of the samples, along with the\n", + " | probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, _ = plt.hist(s, 15, density=True)\n", + " | >>> plt.plot(bins, np.ones_like(bins), linewidth=2, color='r')\n", + " | >>> plt.show()\n", + " |\n", + " | vonmises(self, mu, kappa, size=None)\n", + " | vonmises(mu, kappa, size=None)\n", + " |\n", + " | Draw samples from a von Mises distribution.\n", + " |\n", + " | Samples are drawn from a von Mises distribution with specified mode\n", + " | (mu) and concentration (kappa), on the interval [-pi, pi].\n", + " |\n", + " | The von Mises distribution (also known as the circular normal\n", + " | distribution) is a continuous probability distribution on the unit\n", + " | circle. It may be thought of as the circular analogue of the normal\n", + " | distribution.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | mu : float or array_like of floats\n", + " | Mode (\"center\") of the distribution.\n", + " | kappa : float or array_like of floats\n", + " | Concentration of the distribution, has to be >=0.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``mu`` and ``kappa`` are both scalars.\n", + " | Otherwise, ``np.broadcast(mu, kappa).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized von Mises distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.vonmises : probability density function, distribution, or\n", + " | cumulative density function, etc.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density for the von Mises distribution is\n", + " |\n", + " | .. math:: p(x) = \\frac{e^{\\kappa cos(x-\\mu)}}{2\\pi I_0(\\kappa)},\n", + " |\n", + " | where :math:`\\mu` is the mode and :math:`\\kappa` the concentration,\n", + " | and :math:`I_0(\\kappa)` is the modified Bessel function of order 0.\n", + " |\n", + " | The von Mises is named for Richard Edler von Mises, who was born in\n", + " | Austria-Hungary, in what is now the Ukraine. He fled to the United\n", + " | States in 1939 and became a professor at Harvard. He worked in\n", + " | probability theory, aerodynamics, fluid mechanics, and philosophy of\n", + " | science.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Abramowitz, M. and Stegun, I. A. (Eds.). \"Handbook of\n", + " | Mathematical Functions with Formulas, Graphs, and Mathematical\n", + " | Tables, 9th printing,\" New York: Dover, 1972.\n", + " | .. [2] von Mises, R., \"Mathematical Theory of Probability\n", + " | and Statistics\", New York: Academic Press, 1964.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> mu, kappa = 0.0, 4.0 # mean and concentration\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> s = rng.vonmises(mu, kappa, 1000)\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> from scipy.special import i0 # doctest: +SKIP\n", + " | >>> plt.hist(s, 50, density=True)\n", + " | >>> x = np.linspace(-np.pi, np.pi, num=51)\n", + " | >>> y = np.exp(kappa*np.cos(x-mu))/(2*np.pi*i0(kappa)) # doctest: +SKIP\n", + " | >>> plt.plot(x, y, linewidth=2, color='r') # doctest: +SKIP\n", + " | >>> plt.show()\n", + " |\n", + " | wald(self, mean, scale, size=None)\n", + " | wald(mean, scale, size=None)\n", + " |\n", + " | Draw samples from a Wald, or inverse Gaussian, distribution.\n", + " |\n", + " | As the scale approaches infinity, the distribution becomes more like a\n", + " | Gaussian. Some references claim that the Wald is an inverse Gaussian\n", + " | with mean equal to 1, but this is by no means universal.\n", + " |\n", + " | The inverse Gaussian distribution was first studied in relationship to\n", + " | Brownian motion. In 1956 M.C.K. Tweedie used the name inverse Gaussian\n", + " | because there is an inverse relationship between the time to cover a\n", + " | unit distance and distance covered in unit time.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | mean : float or array_like of floats\n", + " | Distribution mean, must be > 0.\n", + " | scale : float or array_like of floats\n", + " | Scale parameter, must be > 0.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``mean`` and ``scale`` are both scalars.\n", + " | Otherwise, ``np.broadcast(mean, scale).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized Wald distribution.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density function for the Wald distribution is\n", + " |\n", + " | .. math:: P(x;mean,scale) = \\sqrt{\\frac{scale}{2\\pi x^3}}e^\n", + " | \\frac{-scale(x-mean)^2}{2\\cdotp mean^2x}\n", + " |\n", + " | As noted above the inverse Gaussian distribution first arise\n", + " | from attempts to model Brownian motion. It is also a\n", + " | competitor to the Weibull for use in reliability modeling and\n", + " | modeling stock returns and interest rate processes.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Brighton Webs Ltd., Wald Distribution,\n", + " | https://web.archive.org/web/20090423014010/http://www.brighton-webs.co.uk:80/distributions/wald.asp\n", + " | .. [2] Chhikara, Raj S., and Folks, J. Leroy, \"The Inverse Gaussian\n", + " | Distribution: Theory : Methodology, and Applications\", CRC Press,\n", + " | 1988.\n", + " | .. [3] Wikipedia, \"Inverse Gaussian distribution\"\n", + " | https://en.wikipedia.org/wiki/Inverse_Gaussian_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw values from the distribution and plot the histogram:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> h = plt.hist(rng.wald(3, 2, 100000), bins=200, density=True)\n", + " | >>> plt.show()\n", + " |\n", + " | weibull(self, a, size=None)\n", + " | weibull(a, size=None)\n", + " |\n", + " | Draw samples from a Weibull distribution.\n", + " |\n", + " | Draw samples from a 1-parameter Weibull distribution with the given\n", + " | shape parameter `a`.\n", + " |\n", + " | .. math:: X = (-ln(U))^{1/a}\n", + " |\n", + " | Here, U is drawn from the uniform distribution over (0,1].\n", + " |\n", + " | The more common 2-parameter Weibull, including a scale parameter\n", + " | :math:`\\lambda` is just :math:`X = \\lambda(-ln(U))^{1/a}`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | a : float or array_like of floats\n", + " | Shape parameter of the distribution. Must be nonnegative.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``a`` is a scalar. Otherwise,\n", + " | ``np.array(a).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized Weibull distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.weibull_max\n", + " | scipy.stats.weibull_min\n", + " | scipy.stats.genextreme\n", + " | gumbel\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The Weibull (or Type III asymptotic extreme value distribution\n", + " | for smallest values, SEV Type III, or Rosin-Rammler\n", + " | distribution) is one of a class of Generalized Extreme Value\n", + " | (GEV) distributions used in modeling extreme value problems.\n", + " | This class includes the Gumbel and Frechet distributions.\n", + " |\n", + " | The probability density for the Weibull distribution is\n", + " |\n", + " | .. math:: p(x) = \\frac{a}\n", + " | {\\lambda}(\\frac{x}{\\lambda})^{a-1}e^{-(x/\\lambda)^a},\n", + " |\n", + " | where :math:`a` is the shape and :math:`\\lambda` the scale.\n", + " |\n", + " | The function has its peak (the mode) at\n", + " | :math:`\\lambda(\\frac{a-1}{a})^{1/a}`.\n", + " |\n", + " | When ``a = 1``, the Weibull distribution reduces to the exponential\n", + " | distribution.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Waloddi Weibull, Royal Technical University, Stockholm,\n", + " | 1939 \"A Statistical Theory Of The Strength Of Materials\",\n", + " | Ingeniorsvetenskapsakademiens Handlingar Nr 151, 1939,\n", + " | Generalstabens Litografiska Anstalts Forlag, Stockholm.\n", + " | .. [2] Waloddi Weibull, \"A Statistical Distribution Function of\n", + " | Wide Applicability\", Journal Of Applied Mechanics ASME Paper\n", + " | 1951.\n", + " | .. [3] Wikipedia, \"Weibull distribution\",\n", + " | https://en.wikipedia.org/wiki/Weibull_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> a = 5. # shape\n", + " | >>> s = rng.weibull(a, 1000)\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> def weibull(x, n, a):\n", + " | ... return (a / n) * (x / n)**(a - 1) * np.exp(-(x / n)**a)\n", + " | >>> count, bins, _ = plt.hist(rng.weibull(5., 1000))\n", + " | >>> x = np.linspace(0, 2, 1000)\n", + " | >>> bin_spacing = np.mean(np.diff(bins))\n", + " | >>> plt.plot(x, weibull(x, 1., 5.) * bin_spacing * s.size, label='Weibull PDF')\n", + " | >>> plt.legend()\n", + " | >>> plt.show()\n", + " |\n", + " | zipf(self, a, size=None)\n", + " | zipf(a, size=None)\n", + " |\n", + " | Draw samples from a Zipf distribution.\n", + " |\n", + " | Samples are drawn from a Zipf distribution with specified parameter\n", + " | `a` > 1.\n", + " |\n", + " | The Zipf distribution (also known as the zeta distribution) is a\n", + " | discrete probability distribution that satisfies Zipf's law: the\n", + " | frequency of an item is inversely proportional to its rank in a\n", + " | frequency table.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | a : float or array_like of floats\n", + " | Distribution parameter. Must be greater than 1.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``a`` is a scalar. Otherwise,\n", + " | ``np.array(a).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized Zipf distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.zipf : probability density function, distribution, or\n", + " | cumulative density function, etc.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability mass function (PMF) for the Zipf distribution is\n", + " |\n", + " | .. math:: p(k) = \\frac{k^{-a}}{\\zeta(a)},\n", + " |\n", + " | for integers :math:`k \\geq 1`, where :math:`\\zeta` is the Riemann Zeta\n", + " | function.\n", + " |\n", + " | It is named for the American linguist George Kingsley Zipf, who noted\n", + " | that the frequency of any word in a sample of a language is inversely\n", + " | proportional to its rank in the frequency table.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Zipf, G. K., \"Selected Studies of the Principle of Relative\n", + " | Frequency in Language,\" Cambridge, MA: Harvard Univ. Press,\n", + " | 1932.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> a = 4.0\n", + " | >>> n = 20000\n", + " | >>> rng = np.random.default_rng()\n", + " | >>> s = rng.zipf(a, size=n)\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the expected histogram based on the probability\n", + " | density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> from scipy.special import zeta # doctest: +SKIP\n", + " |\n", + " | `bincount` provides a fast histogram for small integers.\n", + " |\n", + " | >>> count = np.bincount(s)\n", + " | >>> k = np.arange(1, s.max() + 1)\n", + " |\n", + " | >>> plt.bar(k, count[1:], alpha=0.5, label='sample count')\n", + " | >>> plt.plot(k, n*(k**-a)/zeta(a), 'k.-', alpha=0.5,\n", + " | ... label='expected count') # doctest: +SKIP\n", + " | >>> plt.semilogy()\n", + " | >>> plt.grid(alpha=0.4)\n", + " | >>> plt.legend()\n", + " | >>> plt.title(f'Zipf sample, a={a}, size={n}')\n", + " | >>> plt.show()\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Static methods defined here:\n", + " |\n", + " | __new__(*args, **kwargs)\n", + " | Create and return a new object. See help(type) for accurate signature.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors defined here:\n", + " |\n", + " | bit_generator\n", + " | Gets the bit generator instance used by the generator\n", + " |\n", + " | Returns\n", + " | -------\n", + " | bit_generator : BitGenerator\n", + " | The bit generator instance used by the generator\n", + "\n", + " class MT19937(numpy.random.bit_generator.BitGenerator)\n", + " | MT19937(seed=None)\n", + " |\n", + " | Container for the Mersenne Twister pseudo-random number generator.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | seed : {None, int, array_like[ints], SeedSequence}, optional\n", + " | A seed to initialize the `BitGenerator`. If None, then fresh,\n", + " | unpredictable entropy will be pulled from the OS. If an ``int`` or\n", + " | ``array_like[ints]`` is passed, then it will be passed to\n", + " | `SeedSequence` to derive the initial `BitGenerator` state. One may also\n", + " | pass in a `SeedSequence` instance.\n", + " |\n", + " | Attributes\n", + " | ----------\n", + " | lock: threading.Lock\n", + " | Lock instance that is shared so that the same bit git generator can\n", + " | be used in multiple Generators without corrupting the state. Code that\n", + " | generates values from a bit generator should hold the bit generator's\n", + " | lock.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | `MT19937` provides a capsule containing function pointers that produce\n", + " | doubles, and unsigned 32 and 64- bit integers [1]_. These are not\n", + " | directly consumable in Python and must be consumed by a `Generator`\n", + " | or similar object that supports low-level access.\n", + " |\n", + " | The Python stdlib module \"random\" also contains a Mersenne Twister\n", + " | pseudo-random number generator.\n", + " |\n", + " | **State and Seeding**\n", + " |\n", + " | The `MT19937` state vector consists of a 624-element array of\n", + " | 32-bit unsigned integers plus a single integer value between 0 and 624\n", + " | that indexes the current position within the main array.\n", + " |\n", + " | The input seed is processed by `SeedSequence` to fill the whole state. The\n", + " | first element is reset such that only its most significant bit is set.\n", + " |\n", + " | **Parallel Features**\n", + " |\n", + " | The preferred way to use a BitGenerator in parallel applications is to use\n", + " | the `SeedSequence.spawn` method to obtain entropy values, and to use these\n", + " | to generate new BitGenerators:\n", + " |\n", + " | >>> from numpy.random import Generator, MT19937, SeedSequence\n", + " | >>> sg = SeedSequence(1234)\n", + " | >>> rg = [Generator(MT19937(s)) for s in sg.spawn(10)]\n", + " |\n", + " | Another method is to use `MT19937.jumped` which advances the state as-if\n", + " | :math:`2^{128}` random numbers have been generated ([1]_, [2]_). This\n", + " | allows the original sequence to be split so that distinct segments can be\n", + " | used in each worker process. All generators should be chained to ensure\n", + " | that the segments come from the same sequence.\n", + " |\n", + " | >>> from numpy.random import Generator, MT19937, SeedSequence\n", + " | >>> sg = SeedSequence(1234)\n", + " | >>> bit_generator = MT19937(sg)\n", + " | >>> rg = []\n", + " | >>> for _ in range(10):\n", + " | ... rg.append(Generator(bit_generator))\n", + " | ... # Chain the BitGenerators\n", + " | ... bit_generator = bit_generator.jumped()\n", + " |\n", + " | **Compatibility Guarantee**\n", + " |\n", + " | `MT19937` makes a guarantee that a fixed seed will always produce\n", + " | the same random integer stream.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Hiroshi Haramoto, Makoto Matsumoto, and Pierre L'Ecuyer, \"A Fast\n", + " | Jump Ahead Algorithm for Linear Recurrences in a Polynomial Space\",\n", + " | Sequences and Their Applications - SETA, 290--298, 2008.\n", + " | .. [2] Hiroshi Haramoto, Makoto Matsumoto, Takuji Nishimura, François\n", + " | Panneton, Pierre L'Ecuyer, \"Efficient Jump Ahead for F2-Linear\n", + " | Random Number Generators\", INFORMS JOURNAL ON COMPUTING, Vol. 20,\n", + " | No. 3, Summer 2008, pp. 385-390.\n", + " |\n", + " | Method resolution order:\n", + " | MT19937\n", + " | numpy.random.bit_generator.BitGenerator\n", + " | builtins.object\n", + " |\n", + " | Methods defined here:\n", + " |\n", + " | __init__(self, /, *args, **kwargs)\n", + " | Initialize self. See help(type(self)) for accurate signature.\n", + " |\n", + " | __reduce_cython__(...)\n", + " |\n", + " | __setstate_cython__(...)\n", + " |\n", + " | jumped(self, jumps=1)\n", + " | jumped(jumps=1)\n", + " |\n", + " | Returns a new bit generator with the state jumped\n", + " |\n", + " | The state of the returned bit generator is jumped as-if\n", + " | 2**(128 * jumps) random numbers have been generated.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | jumps : integer, positive\n", + " | Number of times to jump the state of the bit generator returned\n", + " |\n", + " | Returns\n", + " | -------\n", + " | bit_generator : MT19937\n", + " | New instance of generator jumped iter times\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The jump step is computed using a modified version of Matsumoto's\n", + " | implementation of Horner's method. The step polynomial is precomputed\n", + " | to perform 2**128 steps. The jumped state has been verified to match\n", + " | the state produced using Matsumoto's original code.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Matsumoto, M, Generating multiple disjoint streams of\n", + " | pseudorandom number sequences. Accessed on: May 6, 2020.\n", + " | http://www.math.sci.hiroshima-u.ac.jp/m-mat/MT/JUMP/\n", + " | .. [2] Hiroshi Haramoto, Makoto Matsumoto, Takuji Nishimura, François\n", + " | Panneton, Pierre L'Ecuyer, \"Efficient Jump Ahead for F2-Linear\n", + " | Random Number Generators\", INFORMS JOURNAL ON COMPUTING, Vol. 20,\n", + " | No. 3, Summer 2008, pp. 385-390.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Static methods defined here:\n", + " |\n", + " | __new__(*args, **kwargs)\n", + " | Create and return a new object. See help(type) for accurate signature.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors defined here:\n", + " |\n", + " | state\n", + " | Get or set the PRNG state\n", + " |\n", + " | Returns\n", + " | -------\n", + " | state : dict\n", + " | Dictionary containing the information required to describe the\n", + " | state of the PRNG\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data and other attributes defined here:\n", + " |\n", + " | __pyx_vtable__ = \n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Methods inherited from numpy.random.bit_generator.BitGenerator:\n", + " |\n", + " | __getstate__(self)\n", + " |\n", + " | __reduce__(self)\n", + " |\n", + " | __setstate__(self, state_seed_seq)\n", + " |\n", + " | random_raw(self, size=None, output=True)\n", + " | random_raw(self, size=None)\n", + " |\n", + " | Return randoms as generated by the underlying BitGenerator\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " | output : bool, optional\n", + " | Output values. Used for performance testing since the generated\n", + " | values are not returned.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : uint or ndarray\n", + " | Drawn samples.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | This method directly exposes the raw underlying pseudo-random\n", + " | number generator. All values are returned as unsigned 64-bit\n", + " | values irrespective of the number of bits produced by the PRNG.\n", + " |\n", + " | See the class docstring for the number of bits returned.\n", + " |\n", + " | spawn(self, n_children)\n", + " | spawn(n_children)\n", + " |\n", + " | Create new independent child bit generators.\n", + " |\n", + " | See :ref:`seedsequence-spawn` for additional notes on spawning\n", + " | children. Some bit generators also implement ``jumped``\n", + " | as a different approach for creating independent streams.\n", + " |\n", + " | .. versionadded:: 1.25.0\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | n_children : int\n", + " |\n", + " | Returns\n", + " | -------\n", + " | child_bit_generators : list of BitGenerators\n", + " |\n", + " | Raises\n", + " | ------\n", + " | TypeError\n", + " | When the underlying SeedSequence does not implement spawning.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.spawn, random.SeedSequence.spawn :\n", + " | Equivalent method on the generator and seed sequence.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors inherited from numpy.random.bit_generator.BitGenerator:\n", + " |\n", + " | capsule\n", + " |\n", + " | cffi\n", + " | CFFI interface\n", + " |\n", + " | Returns\n", + " | -------\n", + " | interface : namedtuple\n", + " | Named tuple containing CFFI wrapper\n", + " |\n", + " | * state_address - Memory address of the state struct\n", + " | * state - pointer to the state struct\n", + " | * next_uint64 - function pointer to produce 64 bit integers\n", + " | * next_uint32 - function pointer to produce 32 bit integers\n", + " | * next_double - function pointer to produce doubles\n", + " | * bitgen - pointer to the bit generator struct\n", + " |\n", + " | ctypes\n", + " | ctypes interface\n", + " |\n", + " | Returns\n", + " | -------\n", + " | interface : namedtuple\n", + " | Named tuple containing ctypes wrapper\n", + " |\n", + " | * state_address - Memory address of the state struct\n", + " | * state - pointer to the state struct\n", + " | * next_uint64 - function pointer to produce 64 bit integers\n", + " | * next_uint32 - function pointer to produce 32 bit integers\n", + " | * next_double - function pointer to produce doubles\n", + " | * bitgen - pointer to the bit generator struct\n", + " |\n", + " | lock\n", + " |\n", + " | seed_seq\n", + " | Get the seed sequence used to initialize the bit generator.\n", + " |\n", + " | .. versionadded:: 1.25.0\n", + " |\n", + " | Returns\n", + " | -------\n", + " | seed_seq : ISeedSequence\n", + " | The SeedSequence object used to initialize the BitGenerator.\n", + " | This is normally a `np.random.SeedSequence` instance.\n", + "\n", + " class PCG64(numpy.random.bit_generator.BitGenerator)\n", + " | PCG64(seed=None)\n", + " |\n", + " | BitGenerator for the PCG-64 pseudo-random number generator.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | seed : {None, int, array_like[ints], SeedSequence}, optional\n", + " | A seed to initialize the `BitGenerator`. If None, then fresh,\n", + " | unpredictable entropy will be pulled from the OS. If an ``int`` or\n", + " | ``array_like[ints]`` is passed, then it will be passed to\n", + " | `SeedSequence` to derive the initial `BitGenerator` state. One may also\n", + " | pass in a `SeedSequence` instance.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | PCG-64 is a 128-bit implementation of O'Neill's permutation congruential\n", + " | generator ([1]_, [2]_). PCG-64 has a period of :math:`2^{128}` and supports\n", + " | advancing an arbitrary number of steps as well as :math:`2^{127}` streams.\n", + " | The specific member of the PCG family that we use is PCG XSL RR 128/64\n", + " | as described in the paper ([2]_).\n", + " |\n", + " | `PCG64` provides a capsule containing function pointers that produce\n", + " | doubles, and unsigned 32 and 64- bit integers. These are not\n", + " | directly consumable in Python and must be consumed by a `Generator`\n", + " | or similar object that supports low-level access.\n", + " |\n", + " | Supports the method :meth:`advance` to advance the RNG an arbitrary number of\n", + " | steps. The state of the PCG-64 RNG is represented by 2 128-bit unsigned\n", + " | integers.\n", + " |\n", + " | **State and Seeding**\n", + " |\n", + " | The `PCG64` state vector consists of 2 unsigned 128-bit values,\n", + " | which are represented externally as Python ints. One is the state of the\n", + " | PRNG, which is advanced by a linear congruential generator (LCG). The\n", + " | second is a fixed odd increment used in the LCG.\n", + " |\n", + " | The input seed is processed by `SeedSequence` to generate both values. The\n", + " | increment is not independently settable.\n", + " |\n", + " | **Parallel Features**\n", + " |\n", + " | The preferred way to use a BitGenerator in parallel applications is to use\n", + " | the `SeedSequence.spawn` method to obtain entropy values, and to use these\n", + " | to generate new BitGenerators:\n", + " |\n", + " | >>> from numpy.random import Generator, PCG64, SeedSequence\n", + " | >>> sg = SeedSequence(1234)\n", + " | >>> rg = [Generator(PCG64(s)) for s in sg.spawn(10)]\n", + " |\n", + " | **Compatibility Guarantee**\n", + " |\n", + " | `PCG64` makes a guarantee that a fixed seed will always produce\n", + " | the same random integer stream.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] `\"PCG, A Family of Better Random Number Generators\"\n", + " | `_\n", + " | .. [2] O'Neill, Melissa E. `\"PCG: A Family of Simple Fast Space-Efficient\n", + " | Statistically Good Algorithms for Random Number Generation\"\n", + " | `_\n", + " |\n", + " | Method resolution order:\n", + " | PCG64\n", + " | numpy.random.bit_generator.BitGenerator\n", + " | builtins.object\n", + " |\n", + " | Methods defined here:\n", + " |\n", + " | __init__(self, /, *args, **kwargs)\n", + " | Initialize self. See help(type(self)) for accurate signature.\n", + " |\n", + " | __reduce_cython__(...)\n", + " |\n", + " | __setstate_cython__(...)\n", + " |\n", + " | advance(self, delta)\n", + " | advance(delta)\n", + " |\n", + " | Advance the underlying RNG as-if delta draws have occurred.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | delta : integer, positive\n", + " | Number of draws to advance the RNG. Must be less than the\n", + " | size state variable in the underlying RNG.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | self : PCG64\n", + " | RNG advanced delta steps\n", + " |\n", + " | Notes\n", + " | -----\n", + " | Advancing a RNG updates the underlying RNG state as-if a given\n", + " | number of calls to the underlying RNG have been made. In general\n", + " | there is not a one-to-one relationship between the number output\n", + " | random values from a particular distribution and the number of\n", + " | draws from the core RNG. This occurs for two reasons:\n", + " |\n", + " | * The random values are simulated using a rejection-based method\n", + " | and so, on average, more than one value from the underlying\n", + " | RNG is required to generate an single draw.\n", + " | * The number of bits required to generate a simulated value\n", + " | differs from the number of bits generated by the underlying\n", + " | RNG. For example, two 16-bit integer values can be simulated\n", + " | from a single draw of a 32-bit RNG.\n", + " |\n", + " | Advancing the RNG state resets any pre-computed random numbers.\n", + " | This is required to ensure exact reproducibility.\n", + " |\n", + " | jumped(self, jumps=1)\n", + " | jumped(jumps=1)\n", + " |\n", + " | Returns a new bit generator with the state jumped.\n", + " |\n", + " | Jumps the state as-if jumps * 210306068529402873165736369884012333109\n", + " | random numbers have been generated.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | jumps : integer, positive\n", + " | Number of times to jump the state of the bit generator returned\n", + " |\n", + " | Returns\n", + " | -------\n", + " | bit_generator : PCG64\n", + " | New instance of generator jumped iter times\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The step size is phi-1 when multiplied by 2**128 where phi is the\n", + " | golden ratio.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Static methods defined here:\n", + " |\n", + " | __new__(*args, **kwargs)\n", + " | Create and return a new object. See help(type) for accurate signature.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors defined here:\n", + " |\n", + " | state\n", + " | Get or set the PRNG state\n", + " |\n", + " | Returns\n", + " | -------\n", + " | state : dict\n", + " | Dictionary containing the information required to describe the\n", + " | state of the PRNG\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data and other attributes defined here:\n", + " |\n", + " | __pyx_vtable__ = \n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Methods inherited from numpy.random.bit_generator.BitGenerator:\n", + " |\n", + " | __getstate__(self)\n", + " |\n", + " | __reduce__(self)\n", + " |\n", + " | __setstate__(self, state_seed_seq)\n", + " |\n", + " | random_raw(self, size=None, output=True)\n", + " | random_raw(self, size=None)\n", + " |\n", + " | Return randoms as generated by the underlying BitGenerator\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " | output : bool, optional\n", + " | Output values. Used for performance testing since the generated\n", + " | values are not returned.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : uint or ndarray\n", + " | Drawn samples.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | This method directly exposes the raw underlying pseudo-random\n", + " | number generator. All values are returned as unsigned 64-bit\n", + " | values irrespective of the number of bits produced by the PRNG.\n", + " |\n", + " | See the class docstring for the number of bits returned.\n", + " |\n", + " | spawn(self, n_children)\n", + " | spawn(n_children)\n", + " |\n", + " | Create new independent child bit generators.\n", + " |\n", + " | See :ref:`seedsequence-spawn` for additional notes on spawning\n", + " | children. Some bit generators also implement ``jumped``\n", + " | as a different approach for creating independent streams.\n", + " |\n", + " | .. versionadded:: 1.25.0\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | n_children : int\n", + " |\n", + " | Returns\n", + " | -------\n", + " | child_bit_generators : list of BitGenerators\n", + " |\n", + " | Raises\n", + " | ------\n", + " | TypeError\n", + " | When the underlying SeedSequence does not implement spawning.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.spawn, random.SeedSequence.spawn :\n", + " | Equivalent method on the generator and seed sequence.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors inherited from numpy.random.bit_generator.BitGenerator:\n", + " |\n", + " | capsule\n", + " |\n", + " | cffi\n", + " | CFFI interface\n", + " |\n", + " | Returns\n", + " | -------\n", + " | interface : namedtuple\n", + " | Named tuple containing CFFI wrapper\n", + " |\n", + " | * state_address - Memory address of the state struct\n", + " | * state - pointer to the state struct\n", + " | * next_uint64 - function pointer to produce 64 bit integers\n", + " | * next_uint32 - function pointer to produce 32 bit integers\n", + " | * next_double - function pointer to produce doubles\n", + " | * bitgen - pointer to the bit generator struct\n", + " |\n", + " | ctypes\n", + " | ctypes interface\n", + " |\n", + " | Returns\n", + " | -------\n", + " | interface : namedtuple\n", + " | Named tuple containing ctypes wrapper\n", + " |\n", + " | * state_address - Memory address of the state struct\n", + " | * state - pointer to the state struct\n", + " | * next_uint64 - function pointer to produce 64 bit integers\n", + " | * next_uint32 - function pointer to produce 32 bit integers\n", + " | * next_double - function pointer to produce doubles\n", + " | * bitgen - pointer to the bit generator struct\n", + " |\n", + " | lock\n", + " |\n", + " | seed_seq\n", + " | Get the seed sequence used to initialize the bit generator.\n", + " |\n", + " | .. versionadded:: 1.25.0\n", + " |\n", + " | Returns\n", + " | -------\n", + " | seed_seq : ISeedSequence\n", + " | The SeedSequence object used to initialize the BitGenerator.\n", + " | This is normally a `np.random.SeedSequence` instance.\n", + "\n", + " class PCG64DXSM(numpy.random.bit_generator.BitGenerator)\n", + " | PCG64DXSM(seed=None)\n", + " |\n", + " | BitGenerator for the PCG-64 DXSM pseudo-random number generator.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | seed : {None, int, array_like[ints], SeedSequence}, optional\n", + " | A seed to initialize the `BitGenerator`. If None, then fresh,\n", + " | unpredictable entropy will be pulled from the OS. If an ``int`` or\n", + " | ``array_like[ints]`` is passed, then it will be passed to\n", + " | `SeedSequence` to derive the initial `BitGenerator` state. One may also\n", + " | pass in a `SeedSequence` instance.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | PCG-64 DXSM is a 128-bit implementation of O'Neill's permutation congruential\n", + " | generator ([1]_, [2]_). PCG-64 DXSM has a period of :math:`2^{128}` and supports\n", + " | advancing an arbitrary number of steps as well as :math:`2^{127}` streams.\n", + " | The specific member of the PCG family that we use is PCG CM DXSM 128/64. It\n", + " | differs from `PCG64` in that it uses the stronger DXSM output function,\n", + " | a 64-bit \"cheap multiplier\" in the LCG, and outputs from the state before\n", + " | advancing it rather than advance-then-output.\n", + " |\n", + " | `PCG64DXSM` provides a capsule containing function pointers that produce\n", + " | doubles, and unsigned 32 and 64- bit integers. These are not\n", + " | directly consumable in Python and must be consumed by a `Generator`\n", + " | or similar object that supports low-level access.\n", + " |\n", + " | Supports the method :meth:`advance` to advance the RNG an arbitrary number of\n", + " | steps. The state of the PCG-64 DXSM RNG is represented by 2 128-bit unsigned\n", + " | integers.\n", + " |\n", + " | **State and Seeding**\n", + " |\n", + " | The `PCG64DXSM` state vector consists of 2 unsigned 128-bit values,\n", + " | which are represented externally as Python ints. One is the state of the\n", + " | PRNG, which is advanced by a linear congruential generator (LCG). The\n", + " | second is a fixed odd increment used in the LCG.\n", + " |\n", + " | The input seed is processed by `SeedSequence` to generate both values. The\n", + " | increment is not independently settable.\n", + " |\n", + " | **Parallel Features**\n", + " |\n", + " | The preferred way to use a BitGenerator in parallel applications is to use\n", + " | the `SeedSequence.spawn` method to obtain entropy values, and to use these\n", + " | to generate new BitGenerators:\n", + " |\n", + " | >>> from numpy.random import Generator, PCG64DXSM, SeedSequence\n", + " | >>> sg = SeedSequence(1234)\n", + " | >>> rg = [Generator(PCG64DXSM(s)) for s in sg.spawn(10)]\n", + " |\n", + " | **Compatibility Guarantee**\n", + " |\n", + " | `PCG64DXSM` makes a guarantee that a fixed seed will always produce\n", + " | the same random integer stream.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] `\"PCG, A Family of Better Random Number Generators\"\n", + " | `_\n", + " | .. [2] O'Neill, Melissa E. `\"PCG: A Family of Simple Fast Space-Efficient\n", + " | Statistically Good Algorithms for Random Number Generation\"\n", + " | `_\n", + " |\n", + " | Method resolution order:\n", + " | PCG64DXSM\n", + " | numpy.random.bit_generator.BitGenerator\n", + " | builtins.object\n", + " |\n", + " | Methods defined here:\n", + " |\n", + " | __init__(self, /, *args, **kwargs)\n", + " | Initialize self. See help(type(self)) for accurate signature.\n", + " |\n", + " | __reduce_cython__(...)\n", + " |\n", + " | __setstate_cython__(...)\n", + " |\n", + " | advance(self, delta)\n", + " | advance(delta)\n", + " |\n", + " | Advance the underlying RNG as-if delta draws have occurred.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | delta : integer, positive\n", + " | Number of draws to advance the RNG. Must be less than the\n", + " | size state variable in the underlying RNG.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | self : PCG64\n", + " | RNG advanced delta steps\n", + " |\n", + " | Notes\n", + " | -----\n", + " | Advancing a RNG updates the underlying RNG state as-if a given\n", + " | number of calls to the underlying RNG have been made. In general\n", + " | there is not a one-to-one relationship between the number output\n", + " | random values from a particular distribution and the number of\n", + " | draws from the core RNG. This occurs for two reasons:\n", + " |\n", + " | * The random values are simulated using a rejection-based method\n", + " | and so, on average, more than one value from the underlying\n", + " | RNG is required to generate an single draw.\n", + " | * The number of bits required to generate a simulated value\n", + " | differs from the number of bits generated by the underlying\n", + " | RNG. For example, two 16-bit integer values can be simulated\n", + " | from a single draw of a 32-bit RNG.\n", + " |\n", + " | Advancing the RNG state resets any pre-computed random numbers.\n", + " | This is required to ensure exact reproducibility.\n", + " |\n", + " | jumped(self, jumps=1)\n", + " | jumped(jumps=1)\n", + " |\n", + " | Returns a new bit generator with the state jumped.\n", + " |\n", + " | Jumps the state as-if jumps * 210306068529402873165736369884012333109\n", + " | random numbers have been generated.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | jumps : integer, positive\n", + " | Number of times to jump the state of the bit generator returned\n", + " |\n", + " | Returns\n", + " | -------\n", + " | bit_generator : PCG64DXSM\n", + " | New instance of generator jumped iter times\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The step size is phi-1 when multiplied by 2**128 where phi is the\n", + " | golden ratio.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Static methods defined here:\n", + " |\n", + " | __new__(*args, **kwargs)\n", + " | Create and return a new object. See help(type) for accurate signature.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors defined here:\n", + " |\n", + " | state\n", + " | Get or set the PRNG state\n", + " |\n", + " | Returns\n", + " | -------\n", + " | state : dict\n", + " | Dictionary containing the information required to describe the\n", + " | state of the PRNG\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data and other attributes defined here:\n", + " |\n", + " | __pyx_vtable__ = \n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Methods inherited from numpy.random.bit_generator.BitGenerator:\n", + " |\n", + " | __getstate__(self)\n", + " |\n", + " | __reduce__(self)\n", + " |\n", + " | __setstate__(self, state_seed_seq)\n", + " |\n", + " | random_raw(self, size=None, output=True)\n", + " | random_raw(self, size=None)\n", + " |\n", + " | Return randoms as generated by the underlying BitGenerator\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " | output : bool, optional\n", + " | Output values. Used for performance testing since the generated\n", + " | values are not returned.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : uint or ndarray\n", + " | Drawn samples.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | This method directly exposes the raw underlying pseudo-random\n", + " | number generator. All values are returned as unsigned 64-bit\n", + " | values irrespective of the number of bits produced by the PRNG.\n", + " |\n", + " | See the class docstring for the number of bits returned.\n", + " |\n", + " | spawn(self, n_children)\n", + " | spawn(n_children)\n", + " |\n", + " | Create new independent child bit generators.\n", + " |\n", + " | See :ref:`seedsequence-spawn` for additional notes on spawning\n", + " | children. Some bit generators also implement ``jumped``\n", + " | as a different approach for creating independent streams.\n", + " |\n", + " | .. versionadded:: 1.25.0\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | n_children : int\n", + " |\n", + " | Returns\n", + " | -------\n", + " | child_bit_generators : list of BitGenerators\n", + " |\n", + " | Raises\n", + " | ------\n", + " | TypeError\n", + " | When the underlying SeedSequence does not implement spawning.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.spawn, random.SeedSequence.spawn :\n", + " | Equivalent method on the generator and seed sequence.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors inherited from numpy.random.bit_generator.BitGenerator:\n", + " |\n", + " | capsule\n", + " |\n", + " | cffi\n", + " | CFFI interface\n", + " |\n", + " | Returns\n", + " | -------\n", + " | interface : namedtuple\n", + " | Named tuple containing CFFI wrapper\n", + " |\n", + " | * state_address - Memory address of the state struct\n", + " | * state - pointer to the state struct\n", + " | * next_uint64 - function pointer to produce 64 bit integers\n", + " | * next_uint32 - function pointer to produce 32 bit integers\n", + " | * next_double - function pointer to produce doubles\n", + " | * bitgen - pointer to the bit generator struct\n", + " |\n", + " | ctypes\n", + " | ctypes interface\n", + " |\n", + " | Returns\n", + " | -------\n", + " | interface : namedtuple\n", + " | Named tuple containing ctypes wrapper\n", + " |\n", + " | * state_address - Memory address of the state struct\n", + " | * state - pointer to the state struct\n", + " | * next_uint64 - function pointer to produce 64 bit integers\n", + " | * next_uint32 - function pointer to produce 32 bit integers\n", + " | * next_double - function pointer to produce doubles\n", + " | * bitgen - pointer to the bit generator struct\n", + " |\n", + " | lock\n", + " |\n", + " | seed_seq\n", + " | Get the seed sequence used to initialize the bit generator.\n", + " |\n", + " | .. versionadded:: 1.25.0\n", + " |\n", + " | Returns\n", + " | -------\n", + " | seed_seq : ISeedSequence\n", + " | The SeedSequence object used to initialize the BitGenerator.\n", + " | This is normally a `np.random.SeedSequence` instance.\n", + "\n", + " class Philox(numpy.random.bit_generator.BitGenerator)\n", + " | Philox(seed=None, counter=None, key=None)\n", + " |\n", + " | Container for the Philox (4x64) pseudo-random number generator.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | seed : {None, int, array_like[ints], SeedSequence}, optional\n", + " | A seed to initialize the `BitGenerator`. If None, then fresh,\n", + " | unpredictable entropy will be pulled from the OS. If an ``int`` or\n", + " | ``array_like[ints]`` is passed, then it will be passed to\n", + " | `SeedSequence` to derive the initial `BitGenerator` state. One may also\n", + " | pass in a `SeedSequence` instance.\n", + " | counter : {None, int, array_like}, optional\n", + " | Counter to use in the Philox state. Can be either\n", + " | a Python int (long in 2.x) in [0, 2**256) or a 4-element uint64 array.\n", + " | If not provided, the RNG is initialized at 0.\n", + " | key : {None, int, array_like}, optional\n", + " | Key to use in the Philox state. Unlike ``seed``, the value in key is\n", + " | directly set. Can be either a Python int in [0, 2**128) or a 2-element\n", + " | uint64 array. `key` and ``seed`` cannot both be used.\n", + " |\n", + " | Attributes\n", + " | ----------\n", + " | lock: threading.Lock\n", + " | Lock instance that is shared so that the same bit git generator can\n", + " | be used in multiple Generators without corrupting the state. Code that\n", + " | generates values from a bit generator should hold the bit generator's\n", + " | lock.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | Philox is a 64-bit PRNG that uses a counter-based design based on weaker\n", + " | (and faster) versions of cryptographic functions [1]_. Instances using\n", + " | different values of the key produce independent sequences. Philox has a\n", + " | period of :math:`2^{256} - 1` and supports arbitrary advancing and jumping\n", + " | the sequence in increments of :math:`2^{128}`. These features allow\n", + " | multiple non-overlapping sequences to be generated.\n", + " |\n", + " | `Philox` provides a capsule containing function pointers that produce\n", + " | doubles, and unsigned 32 and 64- bit integers. These are not\n", + " | directly consumable in Python and must be consumed by a `Generator`\n", + " | or similar object that supports low-level access.\n", + " |\n", + " | **State and Seeding**\n", + " |\n", + " | The `Philox` state vector consists of a 256-bit value encoded as\n", + " | a 4-element uint64 array and a 128-bit value encoded as a 2-element uint64\n", + " | array. The former is a counter which is incremented by 1 for every 4 64-bit\n", + " | randoms produced. The second is a key which determined the sequence\n", + " | produced. Using different keys produces independent sequences.\n", + " |\n", + " | The input ``seed`` is processed by `SeedSequence` to generate the key. The\n", + " | counter is set to 0.\n", + " |\n", + " | Alternately, one can omit the ``seed`` parameter and set the ``key`` and\n", + " | ``counter`` directly.\n", + " |\n", + " | **Parallel Features**\n", + " |\n", + " | The preferred way to use a BitGenerator in parallel applications is to use\n", + " | the `SeedSequence.spawn` method to obtain entropy values, and to use these\n", + " | to generate new BitGenerators:\n", + " |\n", + " | >>> from numpy.random import Generator, Philox, SeedSequence\n", + " | >>> sg = SeedSequence(1234)\n", + " | >>> rg = [Generator(Philox(s)) for s in sg.spawn(10)]\n", + " |\n", + " | `Philox` can be used in parallel applications by calling the :meth:`jumped`\n", + " | method to advance the state as-if :math:`2^{128}` random numbers have\n", + " | been generated. Alternatively, :meth:`advance` can be used to advance the\n", + " | counter for any positive step in [0, 2**256). When using :meth:`jumped`, all\n", + " | generators should be chained to ensure that the segments come from the same\n", + " | sequence.\n", + " |\n", + " | >>> from numpy.random import Generator, Philox\n", + " | >>> bit_generator = Philox(1234)\n", + " | >>> rg = []\n", + " | >>> for _ in range(10):\n", + " | ... rg.append(Generator(bit_generator))\n", + " | ... bit_generator = bit_generator.jumped()\n", + " |\n", + " | Alternatively, `Philox` can be used in parallel applications by using\n", + " | a sequence of distinct keys where each instance uses different key.\n", + " |\n", + " | >>> key = 2**96 + 2**33 + 2**17 + 2**9\n", + " | >>> rg = [Generator(Philox(key=key+i)) for i in range(10)]\n", + " |\n", + " | **Compatibility Guarantee**\n", + " |\n", + " | `Philox` makes a guarantee that a fixed ``seed`` will always produce\n", + " | the same random integer stream.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> from numpy.random import Generator, Philox\n", + " | >>> rg = Generator(Philox(1234))\n", + " | >>> rg.standard_normal()\n", + " | 0.123 # random\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] John K. Salmon, Mark A. Moraes, Ron O. Dror, and David E. Shaw,\n", + " | \"Parallel Random Numbers: As Easy as 1, 2, 3,\" Proceedings of\n", + " | the International Conference for High Performance Computing,\n", + " | Networking, Storage and Analysis (SC11), New York, NY: ACM, 2011.\n", + " |\n", + " | Method resolution order:\n", + " | Philox\n", + " | numpy.random.bit_generator.BitGenerator\n", + " | builtins.object\n", + " |\n", + " | Methods defined here:\n", + " |\n", + " | __init__(self, /, *args, **kwargs)\n", + " | Initialize self. See help(type(self)) for accurate signature.\n", + " |\n", + " | __reduce_cython__(...)\n", + " |\n", + " | __setstate_cython__(...)\n", + " |\n", + " | advance(self, delta)\n", + " | advance(delta)\n", + " |\n", + " | Advance the underlying RNG as-if delta draws have occurred.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | delta : integer, positive\n", + " | Number of draws to advance the RNG. Must be less than the\n", + " | size state variable in the underlying RNG.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | self : Philox\n", + " | RNG advanced delta steps\n", + " |\n", + " | Notes\n", + " | -----\n", + " | Advancing a RNG updates the underlying RNG state as-if a given\n", + " | number of calls to the underlying RNG have been made. In general\n", + " | there is not a one-to-one relationship between the number output\n", + " | random values from a particular distribution and the number of\n", + " | draws from the core RNG. This occurs for two reasons:\n", + " |\n", + " | * The random values are simulated using a rejection-based method\n", + " | and so, on average, more than one value from the underlying\n", + " | RNG is required to generate an single draw.\n", + " | * The number of bits required to generate a simulated value\n", + " | differs from the number of bits generated by the underlying\n", + " | RNG. For example, two 16-bit integer values can be simulated\n", + " | from a single draw of a 32-bit RNG.\n", + " |\n", + " | Advancing the RNG state resets any pre-computed random numbers.\n", + " | This is required to ensure exact reproducibility.\n", + " |\n", + " | jumped(self, jumps=1)\n", + " | jumped(jumps=1)\n", + " |\n", + " | Returns a new bit generator with the state jumped\n", + " |\n", + " | The state of the returned bit generator is jumped as-if\n", + " | (2**128) * jumps random numbers have been generated.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | jumps : integer, positive\n", + " | Number of times to jump the state of the bit generator returned\n", + " |\n", + " | Returns\n", + " | -------\n", + " | bit_generator : Philox\n", + " | New instance of generator jumped iter times\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Static methods defined here:\n", + " |\n", + " | __new__(*args, **kwargs)\n", + " | Create and return a new object. See help(type) for accurate signature.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors defined here:\n", + " |\n", + " | state\n", + " | Get or set the PRNG state\n", + " |\n", + " | Returns\n", + " | -------\n", + " | state : dict\n", + " | Dictionary containing the information required to describe the\n", + " | state of the PRNG\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data and other attributes defined here:\n", + " |\n", + " | __pyx_vtable__ = \n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Methods inherited from numpy.random.bit_generator.BitGenerator:\n", + " |\n", + " | __getstate__(self)\n", + " |\n", + " | __reduce__(self)\n", + " |\n", + " | __setstate__(self, state_seed_seq)\n", + " |\n", + " | random_raw(self, size=None, output=True)\n", + " | random_raw(self, size=None)\n", + " |\n", + " | Return randoms as generated by the underlying BitGenerator\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " | output : bool, optional\n", + " | Output values. Used for performance testing since the generated\n", + " | values are not returned.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : uint or ndarray\n", + " | Drawn samples.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | This method directly exposes the raw underlying pseudo-random\n", + " | number generator. All values are returned as unsigned 64-bit\n", + " | values irrespective of the number of bits produced by the PRNG.\n", + " |\n", + " | See the class docstring for the number of bits returned.\n", + " |\n", + " | spawn(self, n_children)\n", + " | spawn(n_children)\n", + " |\n", + " | Create new independent child bit generators.\n", + " |\n", + " | See :ref:`seedsequence-spawn` for additional notes on spawning\n", + " | children. Some bit generators also implement ``jumped``\n", + " | as a different approach for creating independent streams.\n", + " |\n", + " | .. versionadded:: 1.25.0\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | n_children : int\n", + " |\n", + " | Returns\n", + " | -------\n", + " | child_bit_generators : list of BitGenerators\n", + " |\n", + " | Raises\n", + " | ------\n", + " | TypeError\n", + " | When the underlying SeedSequence does not implement spawning.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.spawn, random.SeedSequence.spawn :\n", + " | Equivalent method on the generator and seed sequence.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors inherited from numpy.random.bit_generator.BitGenerator:\n", + " |\n", + " | capsule\n", + " |\n", + " | cffi\n", + " | CFFI interface\n", + " |\n", + " | Returns\n", + " | -------\n", + " | interface : namedtuple\n", + " | Named tuple containing CFFI wrapper\n", + " |\n", + " | * state_address - Memory address of the state struct\n", + " | * state - pointer to the state struct\n", + " | * next_uint64 - function pointer to produce 64 bit integers\n", + " | * next_uint32 - function pointer to produce 32 bit integers\n", + " | * next_double - function pointer to produce doubles\n", + " | * bitgen - pointer to the bit generator struct\n", + " |\n", + " | ctypes\n", + " | ctypes interface\n", + " |\n", + " | Returns\n", + " | -------\n", + " | interface : namedtuple\n", + " | Named tuple containing ctypes wrapper\n", + " |\n", + " | * state_address - Memory address of the state struct\n", + " | * state - pointer to the state struct\n", + " | * next_uint64 - function pointer to produce 64 bit integers\n", + " | * next_uint32 - function pointer to produce 32 bit integers\n", + " | * next_double - function pointer to produce doubles\n", + " | * bitgen - pointer to the bit generator struct\n", + " |\n", + " | lock\n", + " |\n", + " | seed_seq\n", + " | Get the seed sequence used to initialize the bit generator.\n", + " |\n", + " | .. versionadded:: 1.25.0\n", + " |\n", + " | Returns\n", + " | -------\n", + " | seed_seq : ISeedSequence\n", + " | The SeedSequence object used to initialize the BitGenerator.\n", + " | This is normally a `np.random.SeedSequence` instance.\n", + "\n", + " class RandomState(builtins.object)\n", + " | RandomState(seed=None)\n", + " |\n", + " | Container for the slow Mersenne Twister pseudo-random number generator.\n", + " | Consider using a different BitGenerator with the Generator container\n", + " | instead.\n", + " |\n", + " | `RandomState` and `Generator` expose a number of methods for generating\n", + " | random numbers drawn from a variety of probability distributions. In\n", + " | addition to the distribution-specific arguments, each method takes a\n", + " | keyword argument `size` that defaults to ``None``. If `size` is ``None``,\n", + " | then a single value is generated and returned. If `size` is an integer,\n", + " | then a 1-D array filled with generated values is returned. If `size` is a\n", + " | tuple, then an array with that shape is filled and returned.\n", + " |\n", + " | **Compatibility Guarantee**\n", + " |\n", + " | A fixed bit generator using a fixed seed and a fixed series of calls to\n", + " | 'RandomState' methods using the same parameters will always produce the\n", + " | same results up to roundoff error except when the values were incorrect.\n", + " | `RandomState` is effectively frozen and will only receive updates that\n", + " | are required by changes in the internals of Numpy. More substantial\n", + " | changes, including algorithmic improvements, are reserved for\n", + " | `Generator`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | seed : {None, int, array_like, BitGenerator}, optional\n", + " | Random seed used to initialize the pseudo-random number generator or\n", + " | an instantized BitGenerator. If an integer or array, used as a seed for\n", + " | the MT19937 BitGenerator. Values can be any integer between 0 and\n", + " | 2**32 - 1 inclusive, an array (or other sequence) of such integers,\n", + " | or ``None`` (the default). If `seed` is ``None``, then the `MT19937`\n", + " | BitGenerator is initialized by reading data from ``/dev/urandom``\n", + " | (or the Windows analogue) if available or seed from the clock\n", + " | otherwise.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The Python stdlib module \"random\" also contains a Mersenne Twister\n", + " | pseudo-random number generator with a number of methods that are similar\n", + " | to the ones available in `RandomState`. `RandomState`, besides being\n", + " | NumPy-aware, has the advantage that it provides a much larger number\n", + " | of probability distributions to choose from.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | Generator\n", + " | MT19937\n", + " | numpy.random.BitGenerator\n", + " |\n", + " | Methods defined here:\n", + " |\n", + " | __getstate__(self)\n", + " |\n", + " | __init__(self, /, *args, **kwargs)\n", + " | Initialize self. See help(type(self)) for accurate signature.\n", + " |\n", + " | __reduce__(self)\n", + " |\n", + " | __repr__(...)\n", + " | Return repr(self).\n", + " |\n", + " | __setstate__(self, state)\n", + " |\n", + " | __str__(self, /)\n", + " | Return str(self).\n", + " |\n", + " | beta(self, a, b, size=None)\n", + " | beta(a, b, size=None)\n", + " |\n", + " | Draw samples from a Beta distribution.\n", + " |\n", + " | The Beta distribution is a special case of the Dirichlet distribution,\n", + " | and is related to the Gamma distribution. It has the probability\n", + " | distribution function\n", + " |\n", + " | .. math:: f(x; a,b) = \\frac{1}{B(\\alpha, \\beta)} x^{\\alpha - 1}\n", + " | (1 - x)^{\\beta - 1},\n", + " |\n", + " | where the normalization, B, is the beta function,\n", + " |\n", + " | .. math:: B(\\alpha, \\beta) = \\int_0^1 t^{\\alpha - 1}\n", + " | (1 - t)^{\\beta - 1} dt.\n", + " |\n", + " | It is often seen in Bayesian inference and order statistics.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.beta`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | a : float or array_like of floats\n", + " | Alpha, positive (>0).\n", + " | b : float or array_like of floats\n", + " | Beta, positive (>0).\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``a`` and ``b`` are both scalars.\n", + " | Otherwise, ``np.broadcast(a, b).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized beta distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.beta: which should be used for new code.\n", + " |\n", + " | binomial(self, n, p, size=None)\n", + " | binomial(n, p, size=None)\n", + " |\n", + " | Draw samples from a binomial distribution.\n", + " |\n", + " | Samples are drawn from a binomial distribution with specified\n", + " | parameters, n trials and p probability of success where\n", + " | n an integer >= 0 and p is in the interval [0,1]. (n may be\n", + " | input as a float, but it is truncated to an integer in use)\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.binomial`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | n : int or array_like of ints\n", + " | Parameter of the distribution, >= 0. Floats are also accepted,\n", + " | but they will be truncated to integers.\n", + " | p : float or array_like of floats\n", + " | Parameter of the distribution, >= 0 and <=1.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``n`` and ``p`` are both scalars.\n", + " | Otherwise, ``np.broadcast(n, p).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized binomial distribution, where\n", + " | each sample is equal to the number of successes over the n trials.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.binom : probability density function, distribution or\n", + " | cumulative density function, etc.\n", + " | random.Generator.binomial: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability mass function (PMF) for the binomial distribution is\n", + " |\n", + " | .. math:: P(N) = \\binom{n}{N}p^N(1-p)^{n-N},\n", + " |\n", + " | where :math:`n` is the number of trials, :math:`p` is the probability\n", + " | of success, and :math:`N` is the number of successes.\n", + " |\n", + " | When estimating the standard error of a proportion in a population by\n", + " | using a random sample, the normal distribution works well unless the\n", + " | product p*n <=5, where p = population proportion estimate, and n =\n", + " | number of samples, in which case the binomial distribution is used\n", + " | instead. For example, a sample of 15 people shows 4 who are left\n", + " | handed, and 11 who are right handed. Then p = 4/15 = 27%. 0.27*15 = 4,\n", + " | so the binomial distribution should be used in this case.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Dalgaard, Peter, \"Introductory Statistics with R\",\n", + " | Springer-Verlag, 2002.\n", + " | .. [2] Glantz, Stanton A. \"Primer of Biostatistics.\", McGraw-Hill,\n", + " | Fifth Edition, 2002.\n", + " | .. [3] Lentner, Marvin, \"Elementary Applied Statistics\", Bogden\n", + " | and Quigley, 1972.\n", + " | .. [4] Weisstein, Eric W. \"Binomial Distribution.\" From MathWorld--A\n", + " | Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/BinomialDistribution.html\n", + " | .. [5] Wikipedia, \"Binomial distribution\",\n", + " | https://en.wikipedia.org/wiki/Binomial_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> n, p = 10, .5 # number of trials, probability of each trial\n", + " | >>> s = np.random.binomial(n, p, 1000)\n", + " | # result of flipping a coin 10 times, tested 1000 times.\n", + " |\n", + " | A real world example. A company drills 9 wild-cat oil exploration\n", + " | wells, each with an estimated probability of success of 0.1. All nine\n", + " | wells fail. What is the probability of that happening?\n", + " |\n", + " | Let's do 20,000 trials of the model, and count the number that\n", + " | generate zero positive results.\n", + " |\n", + " | >>> sum(np.random.binomial(9, 0.1, 20000) == 0)/20000.\n", + " | # answer = 0.38885, or 38%.\n", + " |\n", + " | bytes(self, length)\n", + " | bytes(length)\n", + " |\n", + " | Return random bytes.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.bytes`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | length : int\n", + " | Number of random bytes.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : bytes\n", + " | String of length `length`.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.bytes: which should be used for new code.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> np.random.bytes(10)\n", + " | b' eh\\x85\\x022SZ\\xbf\\xa4' #random\n", + " |\n", + " | chisquare(self, df, size=None)\n", + " | chisquare(df, size=None)\n", + " |\n", + " | Draw samples from a chi-square distribution.\n", + " |\n", + " | When `df` independent random variables, each with standard normal\n", + " | distributions (mean 0, variance 1), are squared and summed, the\n", + " | resulting distribution is chi-square (see Notes). This distribution\n", + " | is often used in hypothesis testing.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.chisquare`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | df : float or array_like of floats\n", + " | Number of degrees of freedom, must be > 0.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``df`` is a scalar. Otherwise,\n", + " | ``np.array(df).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized chi-square distribution.\n", + " |\n", + " | Raises\n", + " | ------\n", + " | ValueError\n", + " | When `df` <= 0 or when an inappropriate `size` (e.g. ``size=-1``)\n", + " | is given.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.chisquare: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The variable obtained by summing the squares of `df` independent,\n", + " | standard normally distributed random variables:\n", + " |\n", + " | .. math:: Q = \\sum_{i=1}^{\\mathtt{df}} X^2_i\n", + " |\n", + " | is chi-square distributed, denoted\n", + " |\n", + " | .. math:: Q \\sim \\chi^2_k.\n", + " |\n", + " | The probability density function of the chi-squared distribution is\n", + " |\n", + " | .. math:: p(x) = \\frac{(1/2)^{k/2}}{\\Gamma(k/2)}\n", + " | x^{k/2 - 1} e^{-x/2},\n", + " |\n", + " | where :math:`\\Gamma` is the gamma function,\n", + " |\n", + " | .. math:: \\Gamma(x) = \\int_0^{-\\infty} t^{x - 1} e^{-t} dt.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] NIST \"Engineering Statistics Handbook\"\n", + " | https://www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> np.random.chisquare(2,4)\n", + " | array([ 1.89920014, 9.00867716, 3.13710533, 5.62318272]) # random\n", + " |\n", + " | choice(self, a, size=None, replace=True, p=None)\n", + " | choice(a, size=None, replace=True, p=None)\n", + " |\n", + " | Generates a random sample from a given 1-D array\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.choice`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | .. warning::\n", + " | This function uses the C-long dtype, which is 32bit on windows\n", + " | and otherwise 64bit on 64bit platforms (and 32bit on 32bit ones).\n", + " | Since NumPy 2.0, NumPy's default integer is 32bit on 32bit platforms\n", + " | and 64bit on 64bit platforms.\n", + " |\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | a : 1-D array-like or int\n", + " | If an ndarray, a random sample is generated from its elements.\n", + " | If an int, the random sample is generated as if it were ``np.arange(a)``\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " | replace : boolean, optional\n", + " | Whether the sample is with or without replacement. Default is True,\n", + " | meaning that a value of ``a`` can be selected multiple times.\n", + " | p : 1-D array-like, optional\n", + " | The probabilities associated with each entry in a.\n", + " | If not given, the sample assumes a uniform distribution over all\n", + " | entries in ``a``.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | samples : single item or ndarray\n", + " | The generated random samples\n", + " |\n", + " | Raises\n", + " | ------\n", + " | ValueError\n", + " | If a is an int and less than zero, if a or p are not 1-dimensional,\n", + " | if a is an array-like of size 0, if p is not a vector of\n", + " | probabilities, if a and p have different lengths, or if\n", + " | replace=False and the sample size is greater than the population\n", + " | size\n", + " |\n", + " | See Also\n", + " | --------\n", + " | randint, shuffle, permutation\n", + " | random.Generator.choice: which should be used in new code\n", + " |\n", + " | Notes\n", + " | -----\n", + " | Setting user-specified probabilities through ``p`` uses a more general but less\n", + " | efficient sampler than the default. The general sampler produces a different sample\n", + " | than the optimized sampler even if each element of ``p`` is 1 / len(a).\n", + " |\n", + " | Sampling random rows from a 2-D array is not possible with this function,\n", + " | but is possible with `Generator.choice` through its ``axis`` keyword.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Generate a uniform random sample from np.arange(5) of size 3:\n", + " |\n", + " | >>> np.random.choice(5, 3)\n", + " | array([0, 3, 4]) # random\n", + " | >>> #This is equivalent to np.random.randint(0,5,3)\n", + " |\n", + " | Generate a non-uniform random sample from np.arange(5) of size 3:\n", + " |\n", + " | >>> np.random.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0])\n", + " | array([3, 3, 0]) # random\n", + " |\n", + " | Generate a uniform random sample from np.arange(5) of size 3 without\n", + " | replacement:\n", + " |\n", + " | >>> np.random.choice(5, 3, replace=False)\n", + " | array([3,1,0]) # random\n", + " | >>> #This is equivalent to np.random.permutation(np.arange(5))[:3]\n", + " |\n", + " | Generate a non-uniform random sample from np.arange(5) of size\n", + " | 3 without replacement:\n", + " |\n", + " | >>> np.random.choice(5, 3, replace=False, p=[0.1, 0, 0.3, 0.6, 0])\n", + " | array([2, 3, 0]) # random\n", + " |\n", + " | Any of the above can be repeated with an arbitrary array-like\n", + " | instead of just integers. For instance:\n", + " |\n", + " | >>> aa_milne_arr = ['pooh', 'rabbit', 'piglet', 'Christopher']\n", + " | >>> np.random.choice(aa_milne_arr, 5, p=[0.5, 0.1, 0.1, 0.3])\n", + " | array(['pooh', 'pooh', 'pooh', 'Christopher', 'piglet'], # random\n", + " | dtype='0` and\n", + " | :math:`\\sum_{i=1}^k x_i = 1`.\n", + " |\n", + " | The probability density function :math:`p` of a\n", + " | Dirichlet-distributed random vector :math:`X` is\n", + " | proportional to\n", + " |\n", + " | .. math:: p(x) \\propto \\prod_{i=1}^{k}{x^{\\alpha_i-1}_i},\n", + " |\n", + " | where :math:`\\alpha` is a vector containing the positive\n", + " | concentration parameters.\n", + " |\n", + " | The method uses the following property for computation: let :math:`Y`\n", + " | be a random vector which has components that follow a standard gamma\n", + " | distribution, then :math:`X = \\frac{1}{\\sum_{i=1}^k{Y_i}} Y`\n", + " | is Dirichlet-distributed\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] David McKay, \"Information Theory, Inference and Learning\n", + " | Algorithms,\" chapter 23,\n", + " | https://www.inference.org.uk/mackay/itila/\n", + " | .. [2] Wikipedia, \"Dirichlet distribution\",\n", + " | https://en.wikipedia.org/wiki/Dirichlet_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Taking an example cited in Wikipedia, this distribution can be used if\n", + " | one wanted to cut strings (each of initial length 1.0) into K pieces\n", + " | with different lengths, where each piece had, on average, a designated\n", + " | average length, but allowing some variation in the relative sizes of\n", + " | the pieces.\n", + " |\n", + " | >>> s = np.random.dirichlet((10, 5, 3), 20).transpose()\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> plt.barh(range(20), s[0])\n", + " | >>> plt.barh(range(20), s[1], left=s[0], color='g')\n", + " | >>> plt.barh(range(20), s[2], left=s[0]+s[1], color='r')\n", + " | >>> plt.title(\"Lengths of Strings\")\n", + " |\n", + " | exponential(self, scale=1.0, size=None)\n", + " | exponential(scale=1.0, size=None)\n", + " |\n", + " | Draw samples from an exponential distribution.\n", + " |\n", + " | Its probability density function is\n", + " |\n", + " | .. math:: f(x; \\frac{1}{\\beta}) = \\frac{1}{\\beta} \\exp(-\\frac{x}{\\beta}),\n", + " |\n", + " | for ``x > 0`` and 0 elsewhere. :math:`\\beta` is the scale parameter,\n", + " | which is the inverse of the rate parameter :math:`\\lambda = 1/\\beta`.\n", + " | The rate parameter is an alternative, widely used parameterization\n", + " | of the exponential distribution [3]_.\n", + " |\n", + " | The exponential distribution is a continuous analogue of the\n", + " | geometric distribution. It describes many common situations, such as\n", + " | the size of raindrops measured over many rainstorms [1]_, or the time\n", + " | between page requests to Wikipedia [2]_.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.exponential`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | scale : float or array_like of floats\n", + " | The scale parameter, :math:`\\beta = 1/\\lambda`. Must be\n", + " | non-negative.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``scale`` is a scalar. Otherwise,\n", + " | ``np.array(scale).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized exponential distribution.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | A real world example: Assume a company has 10000 customer support\n", + " | agents and the average time between customer calls is 4 minutes.\n", + " |\n", + " | >>> n = 10000\n", + " | >>> time_between_calls = np.random.default_rng().exponential(scale=4, size=n)\n", + " |\n", + " | What is the probability that a customer will call in the next\n", + " | 4 to 5 minutes?\n", + " |\n", + " | >>> x = ((time_between_calls < 5).sum())/n\n", + " | >>> y = ((time_between_calls < 4).sum())/n\n", + " | >>> x-y\n", + " | 0.08 # may vary\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.exponential: which should be used for new code.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Peyton Z. Peebles Jr., \"Probability, Random Variables and\n", + " | Random Signal Principles\", 4th ed, 2001, p. 57.\n", + " | .. [2] Wikipedia, \"Poisson process\",\n", + " | https://en.wikipedia.org/wiki/Poisson_process\n", + " | .. [3] Wikipedia, \"Exponential distribution\",\n", + " | https://en.wikipedia.org/wiki/Exponential_distribution\n", + " |\n", + " | f(self, dfnum, dfden, size=None)\n", + " | f(dfnum, dfden, size=None)\n", + " |\n", + " | Draw samples from an F distribution.\n", + " |\n", + " | Samples are drawn from an F distribution with specified parameters,\n", + " | `dfnum` (degrees of freedom in numerator) and `dfden` (degrees of\n", + " | freedom in denominator), where both parameters must be greater than\n", + " | zero.\n", + " |\n", + " | The random variate of the F distribution (also known as the\n", + " | Fisher distribution) is a continuous probability distribution\n", + " | that arises in ANOVA tests, and is the ratio of two chi-square\n", + " | variates.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.f`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | dfnum : float or array_like of floats\n", + " | Degrees of freedom in numerator, must be > 0.\n", + " | dfden : float or array_like of float\n", + " | Degrees of freedom in denominator, must be > 0.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``dfnum`` and ``dfden`` are both scalars.\n", + " | Otherwise, ``np.broadcast(dfnum, dfden).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized Fisher distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.f : probability density function, distribution or\n", + " | cumulative density function, etc.\n", + " | random.Generator.f: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The F statistic is used to compare in-group variances to between-group\n", + " | variances. Calculating the distribution depends on the sampling, and\n", + " | so it is a function of the respective degrees of freedom in the\n", + " | problem. The variable `dfnum` is the number of samples minus one, the\n", + " | between-groups degrees of freedom, while `dfden` is the within-groups\n", + " | degrees of freedom, the sum of the number of samples in each group\n", + " | minus the number of groups.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Glantz, Stanton A. \"Primer of Biostatistics.\", McGraw-Hill,\n", + " | Fifth Edition, 2002.\n", + " | .. [2] Wikipedia, \"F-distribution\",\n", + " | https://en.wikipedia.org/wiki/F-distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | An example from Glantz[1], pp 47-40:\n", + " |\n", + " | Two groups, children of diabetics (25 people) and children from people\n", + " | without diabetes (25 controls). Fasting blood glucose was measured,\n", + " | case group had a mean value of 86.1, controls had a mean value of\n", + " | 82.2. Standard deviations were 2.09 and 2.49 respectively. Are these\n", + " | data consistent with the null hypothesis that the parents diabetic\n", + " | status does not affect their children's blood glucose levels?\n", + " | Calculating the F statistic from the data gives a value of 36.01.\n", + " |\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> dfnum = 1. # between group degrees of freedom\n", + " | >>> dfden = 48. # within groups degrees of freedom\n", + " | >>> s = np.random.f(dfnum, dfden, 1000)\n", + " |\n", + " | The lower bound for the top 1% of the samples is :\n", + " |\n", + " | >>> np.sort(s)[-10]\n", + " | 7.61988120985 # random\n", + " |\n", + " | So there is about a 1% chance that the F statistic will exceed 7.62,\n", + " | the measured value is 36, so the null hypothesis is rejected at the 1%\n", + " | level.\n", + " |\n", + " | gamma(self, shape, scale=1.0, size=None)\n", + " | gamma(shape, scale=1.0, size=None)\n", + " |\n", + " | Draw samples from a Gamma distribution.\n", + " |\n", + " | Samples are drawn from a Gamma distribution with specified parameters,\n", + " | `shape` (sometimes designated \"k\") and `scale` (sometimes designated\n", + " | \"theta\"), where both parameters are > 0.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.gamma`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | shape : float or array_like of floats\n", + " | The shape of the gamma distribution. Must be non-negative.\n", + " | scale : float or array_like of floats, optional\n", + " | The scale of the gamma distribution. Must be non-negative.\n", + " | Default is equal to 1.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``shape`` and ``scale`` are both scalars.\n", + " | Otherwise, ``np.broadcast(shape, scale).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized gamma distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.gamma : probability density function, distribution or\n", + " | cumulative density function, etc.\n", + " | random.Generator.gamma: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density for the Gamma distribution is\n", + " |\n", + " | .. math:: p(x) = x^{k-1}\\frac{e^{-x/\\theta}}{\\theta^k\\Gamma(k)},\n", + " |\n", + " | where :math:`k` is the shape and :math:`\\theta` the scale,\n", + " | and :math:`\\Gamma` is the Gamma function.\n", + " |\n", + " | The Gamma distribution is often used to model the times to failure of\n", + " | electronic components, and arises naturally in processes for which the\n", + " | waiting times between Poisson distributed events are relevant.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Weisstein, Eric W. \"Gamma Distribution.\" From MathWorld--A\n", + " | Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/GammaDistribution.html\n", + " | .. [2] Wikipedia, \"Gamma distribution\",\n", + " | https://en.wikipedia.org/wiki/Gamma_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> shape, scale = 2., 2. # mean=4, std=2*sqrt(2)\n", + " | >>> s = np.random.gamma(shape, scale, 1000)\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> import scipy.special as sps # doctest: +SKIP\n", + " | >>> count, bins, ignored = plt.hist(s, 50, density=True)\n", + " | >>> y = bins**(shape-1)*(np.exp(-bins/scale) / # doctest: +SKIP\n", + " | ... (sps.gamma(shape)*scale**shape))\n", + " | >>> plt.plot(bins, y, linewidth=2, color='r') # doctest: +SKIP\n", + " | >>> plt.show()\n", + " |\n", + " | geometric(self, p, size=None)\n", + " | geometric(p, size=None)\n", + " |\n", + " | Draw samples from the geometric distribution.\n", + " |\n", + " | Bernoulli trials are experiments with one of two outcomes:\n", + " | success or failure (an example of such an experiment is flipping\n", + " | a coin). The geometric distribution models the number of trials\n", + " | that must be run in order to achieve success. It is therefore\n", + " | supported on the positive integers, ``k = 1, 2, ...``.\n", + " |\n", + " | The probability mass function of the geometric distribution is\n", + " |\n", + " | .. math:: f(k) = (1 - p)^{k - 1} p\n", + " |\n", + " | where `p` is the probability of success of an individual trial.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.geometric`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | p : float or array_like of floats\n", + " | The probability of success of an individual trial.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``p`` is a scalar. Otherwise,\n", + " | ``np.array(p).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized geometric distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.geometric: which should be used for new code.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw ten thousand values from the geometric distribution,\n", + " | with the probability of an individual success equal to 0.35:\n", + " |\n", + " | >>> z = np.random.geometric(p=0.35, size=10000)\n", + " |\n", + " | How many trials succeeded after a single run?\n", + " |\n", + " | >>> (z == 1).sum() / 10000.\n", + " | 0.34889999999999999 #random\n", + " |\n", + " | get_state(self, legacy=True)\n", + " | get_state(legacy=True)\n", + " |\n", + " | Return a tuple representing the internal state of the generator.\n", + " |\n", + " | For more details, see `set_state`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | legacy : bool, optional\n", + " | Flag indicating to return a legacy tuple state when the BitGenerator\n", + " | is MT19937, instead of a dict. Raises ValueError if the underlying\n", + " | bit generator is not an instance of MT19937.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : {tuple(str, ndarray of 624 uints, int, int, float), dict}\n", + " | If legacy is True, the returned tuple has the following items:\n", + " |\n", + " | 1. the string 'MT19937'.\n", + " | 2. a 1-D array of 624 unsigned integer keys.\n", + " | 3. an integer ``pos``.\n", + " | 4. an integer ``has_gauss``.\n", + " | 5. a float ``cached_gaussian``.\n", + " |\n", + " | If `legacy` is False, or the BitGenerator is not MT19937, then\n", + " | state is returned as a dictionary.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | set_state\n", + " |\n", + " | Notes\n", + " | -----\n", + " | `set_state` and `get_state` are not needed to work with any of the\n", + " | random distributions in NumPy. If the internal state is manually altered,\n", + " | the user should know exactly what he/she is doing.\n", + " |\n", + " | gumbel(self, loc=0.0, scale=1.0, size=None)\n", + " | gumbel(loc=0.0, scale=1.0, size=None)\n", + " |\n", + " | Draw samples from a Gumbel distribution.\n", + " |\n", + " | Draw samples from a Gumbel distribution with specified location and\n", + " | scale. For more information on the Gumbel distribution, see\n", + " | Notes and References below.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.gumbel`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | loc : float or array_like of floats, optional\n", + " | The location of the mode of the distribution. Default is 0.\n", + " | scale : float or array_like of floats, optional\n", + " | The scale parameter of the distribution. Default is 1. Must be non-\n", + " | negative.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``loc`` and ``scale`` are both scalars.\n", + " | Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized Gumbel distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.gumbel_l\n", + " | scipy.stats.gumbel_r\n", + " | scipy.stats.genextreme\n", + " | weibull\n", + " | random.Generator.gumbel: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The Gumbel (or Smallest Extreme Value (SEV) or the Smallest Extreme\n", + " | Value Type I) distribution is one of a class of Generalized Extreme\n", + " | Value (GEV) distributions used in modeling extreme value problems.\n", + " | The Gumbel is a special case of the Extreme Value Type I distribution\n", + " | for maximums from distributions with \"exponential-like\" tails.\n", + " |\n", + " | The probability density for the Gumbel distribution is\n", + " |\n", + " | .. math:: p(x) = \\frac{e^{-(x - \\mu)/ \\beta}}{\\beta} e^{ -e^{-(x - \\mu)/\n", + " | \\beta}},\n", + " |\n", + " | where :math:`\\mu` is the mode, a location parameter, and\n", + " | :math:`\\beta` is the scale parameter.\n", + " |\n", + " | The Gumbel (named for German mathematician Emil Julius Gumbel) was used\n", + " | very early in the hydrology literature, for modeling the occurrence of\n", + " | flood events. It is also used for modeling maximum wind speed and\n", + " | rainfall rates. It is a \"fat-tailed\" distribution - the probability of\n", + " | an event in the tail of the distribution is larger than if one used a\n", + " | Gaussian, hence the surprisingly frequent occurrence of 100-year\n", + " | floods. Floods were initially modeled as a Gaussian process, which\n", + " | underestimated the frequency of extreme events.\n", + " |\n", + " | It is one of a class of extreme value distributions, the Generalized\n", + " | Extreme Value (GEV) distributions, which also includes the Weibull and\n", + " | Frechet.\n", + " |\n", + " | The function has a mean of :math:`\\mu + 0.57721\\beta` and a variance\n", + " | of :math:`\\frac{\\pi^2}{6}\\beta^2`.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Gumbel, E. J., \"Statistics of Extremes,\"\n", + " | New York: Columbia University Press, 1958.\n", + " | .. [2] Reiss, R.-D. and Thomas, M., \"Statistical Analysis of Extreme\n", + " | Values from Insurance, Finance, Hydrology and Other Fields,\"\n", + " | Basel: Birkhauser Verlag, 2001.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> mu, beta = 0, 0.1 # location and scale\n", + " | >>> s = np.random.gumbel(mu, beta, 1000)\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, ignored = plt.hist(s, 30, density=True)\n", + " | >>> plt.plot(bins, (1/beta)*np.exp(-(bins - mu)/beta)\n", + " | ... * np.exp( -np.exp( -(bins - mu) /beta) ),\n", + " | ... linewidth=2, color='r')\n", + " | >>> plt.show()\n", + " |\n", + " | Show how an extreme value distribution can arise from a Gaussian process\n", + " | and compare to a Gaussian:\n", + " |\n", + " | >>> means = []\n", + " | >>> maxima = []\n", + " | >>> for i in range(0,1000) :\n", + " | ... a = np.random.normal(mu, beta, 1000)\n", + " | ... means.append(a.mean())\n", + " | ... maxima.append(a.max())\n", + " | >>> count, bins, ignored = plt.hist(maxima, 30, density=True)\n", + " | >>> beta = np.std(maxima) * np.sqrt(6) / np.pi\n", + " | >>> mu = np.mean(maxima) - 0.57721*beta\n", + " | >>> plt.plot(bins, (1/beta)*np.exp(-(bins - mu)/beta)\n", + " | ... * np.exp(-np.exp(-(bins - mu)/beta)),\n", + " | ... linewidth=2, color='r')\n", + " | >>> plt.plot(bins, 1/(beta * np.sqrt(2 * np.pi))\n", + " | ... * np.exp(-(bins - mu)**2 / (2 * beta**2)),\n", + " | ... linewidth=2, color='g')\n", + " | >>> plt.show()\n", + " |\n", + " | hypergeometric(self, ngood, nbad, nsample, size=None)\n", + " | hypergeometric(ngood, nbad, nsample, size=None)\n", + " |\n", + " | Draw samples from a Hypergeometric distribution.\n", + " |\n", + " | Samples are drawn from a hypergeometric distribution with specified\n", + " | parameters, `ngood` (ways to make a good selection), `nbad` (ways to make\n", + " | a bad selection), and `nsample` (number of items sampled, which is less\n", + " | than or equal to the sum ``ngood + nbad``).\n", + " |\n", + " | .. note::\n", + " | New code should use the\n", + " | `~numpy.random.Generator.hypergeometric`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | ngood : int or array_like of ints\n", + " | Number of ways to make a good selection. Must be nonnegative.\n", + " | nbad : int or array_like of ints\n", + " | Number of ways to make a bad selection. Must be nonnegative.\n", + " | nsample : int or array_like of ints\n", + " | Number of items sampled. Must be at least 1 and at most\n", + " | ``ngood + nbad``.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if `ngood`, `nbad`, and `nsample`\n", + " | are all scalars. Otherwise, ``np.broadcast(ngood, nbad, nsample).size``\n", + " | samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized hypergeometric distribution. Each\n", + " | sample is the number of good items within a randomly selected subset of\n", + " | size `nsample` taken from a set of `ngood` good items and `nbad` bad items.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.hypergeom : probability density function, distribution or\n", + " | cumulative density function, etc.\n", + " | random.Generator.hypergeometric: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability mass function (PMF) for the Hypergeometric distribution is\n", + " |\n", + " | .. math:: P(x) = \\frac{\\binom{g}{x}\\binom{b}{n-x}}{\\binom{g+b}{n}},\n", + " |\n", + " | where :math:`0 \\le x \\le n` and :math:`n-b \\le x \\le g`\n", + " |\n", + " | for P(x) the probability of ``x`` good results in the drawn sample,\n", + " | g = `ngood`, b = `nbad`, and n = `nsample`.\n", + " |\n", + " | Consider an urn with black and white marbles in it, `ngood` of them\n", + " | are black and `nbad` are white. If you draw `nsample` balls without\n", + " | replacement, then the hypergeometric distribution describes the\n", + " | distribution of black balls in the drawn sample.\n", + " |\n", + " | Note that this distribution is very similar to the binomial\n", + " | distribution, except that in this case, samples are drawn without\n", + " | replacement, whereas in the Binomial case samples are drawn with\n", + " | replacement (or the sample space is infinite). As the sample space\n", + " | becomes large, this distribution approaches the binomial.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Lentner, Marvin, \"Elementary Applied Statistics\", Bogden\n", + " | and Quigley, 1972.\n", + " | .. [2] Weisstein, Eric W. \"Hypergeometric Distribution.\" From\n", + " | MathWorld--A Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/HypergeometricDistribution.html\n", + " | .. [3] Wikipedia, \"Hypergeometric distribution\",\n", + " | https://en.wikipedia.org/wiki/Hypergeometric_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> ngood, nbad, nsamp = 100, 2, 10\n", + " | # number of good, number of bad, and number of samples\n", + " | >>> s = np.random.hypergeometric(ngood, nbad, nsamp, 1000)\n", + " | >>> from matplotlib.pyplot import hist\n", + " | >>> hist(s)\n", + " | # note that it is very unlikely to grab both bad items\n", + " |\n", + " | Suppose you have an urn with 15 white and 15 black marbles.\n", + " | If you pull 15 marbles at random, how likely is it that\n", + " | 12 or more of them are one color?\n", + " |\n", + " | >>> s = np.random.hypergeometric(15, 15, 15, 100000)\n", + " | >>> sum(s>=12)/100000. + sum(s<=3)/100000.\n", + " | # answer = 0.003 ... pretty unlikely!\n", + " |\n", + " | laplace(self, loc=0.0, scale=1.0, size=None)\n", + " | laplace(loc=0.0, scale=1.0, size=None)\n", + " |\n", + " | Draw samples from the Laplace or double exponential distribution with\n", + " | specified location (or mean) and scale (decay).\n", + " |\n", + " | The Laplace distribution is similar to the Gaussian/normal distribution,\n", + " | but is sharper at the peak and has fatter tails. It represents the\n", + " | difference between two independent, identically distributed exponential\n", + " | random variables.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.laplace`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | loc : float or array_like of floats, optional\n", + " | The position, :math:`\\mu`, of the distribution peak. Default is 0.\n", + " | scale : float or array_like of floats, optional\n", + " | :math:`\\lambda`, the exponential decay. Default is 1. Must be non-\n", + " | negative.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``loc`` and ``scale`` are both scalars.\n", + " | Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized Laplace distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.laplace: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | It has the probability density function\n", + " |\n", + " | .. math:: f(x; \\mu, \\lambda) = \\frac{1}{2\\lambda}\n", + " | \\exp\\left(-\\frac{|x - \\mu|}{\\lambda}\\right).\n", + " |\n", + " | The first law of Laplace, from 1774, states that the frequency\n", + " | of an error can be expressed as an exponential function of the\n", + " | absolute magnitude of the error, which leads to the Laplace\n", + " | distribution. For many problems in economics and health\n", + " | sciences, this distribution seems to model the data better\n", + " | than the standard Gaussian distribution.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Abramowitz, M. and Stegun, I. A. (Eds.). \"Handbook of\n", + " | Mathematical Functions with Formulas, Graphs, and Mathematical\n", + " | Tables, 9th printing,\" New York: Dover, 1972.\n", + " | .. [2] Kotz, Samuel, et. al. \"The Laplace Distribution and\n", + " | Generalizations, \" Birkhauser, 2001.\n", + " | .. [3] Weisstein, Eric W. \"Laplace Distribution.\"\n", + " | From MathWorld--A Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/LaplaceDistribution.html\n", + " | .. [4] Wikipedia, \"Laplace distribution\",\n", + " | https://en.wikipedia.org/wiki/Laplace_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution\n", + " |\n", + " | >>> loc, scale = 0., 1.\n", + " | >>> s = np.random.laplace(loc, scale, 1000)\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, ignored = plt.hist(s, 30, density=True)\n", + " | >>> x = np.arange(-8., 8., .01)\n", + " | >>> pdf = np.exp(-abs(x-loc)/scale)/(2.*scale)\n", + " | >>> plt.plot(x, pdf)\n", + " |\n", + " | Plot Gaussian for comparison:\n", + " |\n", + " | >>> g = (1/(scale * np.sqrt(2 * np.pi)) *\n", + " | ... np.exp(-(x - loc)**2 / (2 * scale**2)))\n", + " | >>> plt.plot(x,g)\n", + " |\n", + " | logistic(self, loc=0.0, scale=1.0, size=None)\n", + " | logistic(loc=0.0, scale=1.0, size=None)\n", + " |\n", + " | Draw samples from a logistic distribution.\n", + " |\n", + " | Samples are drawn from a logistic distribution with specified\n", + " | parameters, loc (location or mean, also median), and scale (>0).\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.logistic`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | loc : float or array_like of floats, optional\n", + " | Parameter of the distribution. Default is 0.\n", + " | scale : float or array_like of floats, optional\n", + " | Parameter of the distribution. Must be non-negative.\n", + " | Default is 1.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``loc`` and ``scale`` are both scalars.\n", + " | Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized logistic distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.logistic : probability density function, distribution or\n", + " | cumulative density function, etc.\n", + " | random.Generator.logistic: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density for the Logistic distribution is\n", + " |\n", + " | .. math:: P(x) = P(x) = \\frac{e^{-(x-\\mu)/s}}{s(1+e^{-(x-\\mu)/s})^2},\n", + " |\n", + " | where :math:`\\mu` = location and :math:`s` = scale.\n", + " |\n", + " | The Logistic distribution is used in Extreme Value problems where it\n", + " | can act as a mixture of Gumbel distributions, in Epidemiology, and by\n", + " | the World Chess Federation (FIDE) where it is used in the Elo ranking\n", + " | system, assuming the performance of each player is a logistically\n", + " | distributed random variable.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Reiss, R.-D. and Thomas M. (2001), \"Statistical Analysis of\n", + " | Extreme Values, from Insurance, Finance, Hydrology and Other\n", + " | Fields,\" Birkhauser Verlag, Basel, pp 132-133.\n", + " | .. [2] Weisstein, Eric W. \"Logistic Distribution.\" From\n", + " | MathWorld--A Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/LogisticDistribution.html\n", + " | .. [3] Wikipedia, \"Logistic-distribution\",\n", + " | https://en.wikipedia.org/wiki/Logistic_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> loc, scale = 10, 1\n", + " | >>> s = np.random.logistic(loc, scale, 10000)\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, ignored = plt.hist(s, bins=50)\n", + " |\n", + " | # plot against distribution\n", + " |\n", + " | >>> def logist(x, loc, scale):\n", + " | ... return np.exp((loc-x)/scale)/(scale*(1+np.exp((loc-x)/scale))**2)\n", + " | >>> lgst_val = logist(bins, loc, scale)\n", + " | >>> plt.plot(bins, lgst_val * count.max() / lgst_val.max())\n", + " | >>> plt.show()\n", + " |\n", + " | lognormal(self, mean=0.0, sigma=1.0, size=None)\n", + " | lognormal(mean=0.0, sigma=1.0, size=None)\n", + " |\n", + " | Draw samples from a log-normal distribution.\n", + " |\n", + " | Draw samples from a log-normal distribution with specified mean,\n", + " | standard deviation, and array shape. Note that the mean and standard\n", + " | deviation are not the values for the distribution itself, but of the\n", + " | underlying normal distribution it is derived from.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.lognormal`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | mean : float or array_like of floats, optional\n", + " | Mean value of the underlying normal distribution. Default is 0.\n", + " | sigma : float or array_like of floats, optional\n", + " | Standard deviation of the underlying normal distribution. Must be\n", + " | non-negative. Default is 1.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``mean`` and ``sigma`` are both scalars.\n", + " | Otherwise, ``np.broadcast(mean, sigma).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized log-normal distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.lognorm : probability density function, distribution,\n", + " | cumulative density function, etc.\n", + " | random.Generator.lognormal: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | A variable `x` has a log-normal distribution if `log(x)` is normally\n", + " | distributed. The probability density function for the log-normal\n", + " | distribution is:\n", + " |\n", + " | .. math:: p(x) = \\frac{1}{\\sigma x \\sqrt{2\\pi}}\n", + " | e^{(-\\frac{(ln(x)-\\mu)^2}{2\\sigma^2})}\n", + " |\n", + " | where :math:`\\mu` is the mean and :math:`\\sigma` is the standard\n", + " | deviation of the normally distributed logarithm of the variable.\n", + " | A log-normal distribution results if a random variable is the *product*\n", + " | of a large number of independent, identically-distributed variables in\n", + " | the same way that a normal distribution results if the variable is the\n", + " | *sum* of a large number of independent, identically-distributed\n", + " | variables.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Limpert, E., Stahel, W. A., and Abbt, M., \"Log-normal\n", + " | Distributions across the Sciences: Keys and Clues,\"\n", + " | BioScience, Vol. 51, No. 5, May, 2001.\n", + " | https://stat.ethz.ch/~stahel/lognormal/bioscience.pdf\n", + " | .. [2] Reiss, R.D. and Thomas, M., \"Statistical Analysis of Extreme\n", + " | Values,\" Basel: Birkhauser Verlag, 2001, pp. 31-32.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> mu, sigma = 3., 1. # mean and standard deviation\n", + " | >>> s = np.random.lognormal(mu, sigma, 1000)\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, ignored = plt.hist(s, 100, density=True, align='mid')\n", + " |\n", + " | >>> x = np.linspace(min(bins), max(bins), 10000)\n", + " | >>> pdf = (np.exp(-(np.log(x) - mu)**2 / (2 * sigma**2))\n", + " | ... / (x * sigma * np.sqrt(2 * np.pi)))\n", + " |\n", + " | >>> plt.plot(x, pdf, linewidth=2, color='r')\n", + " | >>> plt.axis('tight')\n", + " | >>> plt.show()\n", + " |\n", + " | Demonstrate that taking the products of random samples from a uniform\n", + " | distribution can be fit well by a log-normal probability density\n", + " | function.\n", + " |\n", + " | >>> # Generate a thousand samples: each is the product of 100 random\n", + " | >>> # values, drawn from a normal distribution.\n", + " | >>> b = []\n", + " | >>> for i in range(1000):\n", + " | ... a = 10. + np.random.standard_normal(100)\n", + " | ... b.append(np.prod(a))\n", + " |\n", + " | >>> b = np.array(b) / np.min(b) # scale values to be positive\n", + " | >>> count, bins, ignored = plt.hist(b, 100, density=True, align='mid')\n", + " | >>> sigma = np.std(np.log(b))\n", + " | >>> mu = np.mean(np.log(b))\n", + " |\n", + " | >>> x = np.linspace(min(bins), max(bins), 10000)\n", + " | >>> pdf = (np.exp(-(np.log(x) - mu)**2 / (2 * sigma**2))\n", + " | ... / (x * sigma * np.sqrt(2 * np.pi)))\n", + " |\n", + " | >>> plt.plot(x, pdf, color='r', linewidth=2)\n", + " | >>> plt.show()\n", + " |\n", + " | logseries(self, p, size=None)\n", + " | logseries(p, size=None)\n", + " |\n", + " | Draw samples from a logarithmic series distribution.\n", + " |\n", + " | Samples are drawn from a log series distribution with specified\n", + " | shape parameter, 0 <= ``p`` < 1.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.logseries`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | p : float or array_like of floats\n", + " | Shape parameter for the distribution. Must be in the range [0, 1).\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``p`` is a scalar. Otherwise,\n", + " | ``np.array(p).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized logarithmic series distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.logser : probability density function, distribution or\n", + " | cumulative density function, etc.\n", + " | random.Generator.logseries: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density for the Log Series distribution is\n", + " |\n", + " | .. math:: P(k) = \\frac{-p^k}{k \\ln(1-p)},\n", + " |\n", + " | where p = probability.\n", + " |\n", + " | The log series distribution is frequently used to represent species\n", + " | richness and occurrence, first proposed by Fisher, Corbet, and\n", + " | Williams in 1943 [2]. It may also be used to model the numbers of\n", + " | occupants seen in cars [3].\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Buzas, Martin A.; Culver, Stephen J., Understanding regional\n", + " | species diversity through the log series distribution of\n", + " | occurrences: BIODIVERSITY RESEARCH Diversity & Distributions,\n", + " | Volume 5, Number 5, September 1999 , pp. 187-195(9).\n", + " | .. [2] Fisher, R.A,, A.S. Corbet, and C.B. Williams. 1943. The\n", + " | relation between the number of species and the number of\n", + " | individuals in a random sample of an animal population.\n", + " | Journal of Animal Ecology, 12:42-58.\n", + " | .. [3] D. J. Hand, F. Daly, D. Lunn, E. Ostrowski, A Handbook of Small\n", + " | Data Sets, CRC Press, 1994.\n", + " | .. [4] Wikipedia, \"Logarithmic distribution\",\n", + " | https://en.wikipedia.org/wiki/Logarithmic_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> a = .6\n", + " | >>> s = np.random.logseries(a, 10000)\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, ignored = plt.hist(s)\n", + " |\n", + " | # plot against distribution\n", + " |\n", + " | >>> def logseries(k, p):\n", + " | ... return -p**k/(k*np.log(1-p))\n", + " | >>> plt.plot(bins, logseries(bins, a)*count.max()/\n", + " | ... logseries(bins, a).max(), 'r')\n", + " | >>> plt.show()\n", + " |\n", + " | multinomial(self, n, pvals, size=None)\n", + " | multinomial(n, pvals, size=None)\n", + " |\n", + " | Draw samples from a multinomial distribution.\n", + " |\n", + " | The multinomial distribution is a multivariate generalization of the\n", + " | binomial distribution. Take an experiment with one of ``p``\n", + " | possible outcomes. An example of such an experiment is throwing a dice,\n", + " | where the outcome can be 1 through 6. Each sample drawn from the\n", + " | distribution represents `n` such experiments. Its values,\n", + " | ``X_i = [X_0, X_1, ..., X_p]``, represent the number of times the\n", + " | outcome was ``i``.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.multinomial`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | .. warning::\n", + " | This function defaults to the C-long dtype, which is 32bit on windows\n", + " | and otherwise 64bit on 64bit platforms (and 32bit on 32bit ones).\n", + " | Since NumPy 2.0, NumPy's default integer is 32bit on 32bit platforms\n", + " | and 64bit on 64bit platforms.\n", + " |\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | n : int\n", + " | Number of experiments.\n", + " | pvals : sequence of floats, length p\n", + " | Probabilities of each of the ``p`` different outcomes. These\n", + " | must sum to 1 (however, the last element is always assumed to\n", + " | account for the remaining probability, as long as\n", + " | ``sum(pvals[:-1]) <= 1)``.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray\n", + " | The drawn samples, of shape *size*, if that was provided. If not,\n", + " | the shape is ``(N,)``.\n", + " |\n", + " | In other words, each entry ``out[i,j,...,:]`` is an N-dimensional\n", + " | value drawn from the distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.multinomial: which should be used for new code.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Throw a dice 20 times:\n", + " |\n", + " | >>> np.random.multinomial(20, [1/6.]*6, size=1)\n", + " | array([[4, 1, 7, 5, 2, 1]]) # random\n", + " |\n", + " | It landed 4 times on 1, once on 2, etc.\n", + " |\n", + " | Now, throw the dice 20 times, and 20 times again:\n", + " |\n", + " | >>> np.random.multinomial(20, [1/6.]*6, size=2)\n", + " | array([[3, 4, 3, 3, 4, 3], # random\n", + " | [2, 4, 3, 4, 0, 7]])\n", + " |\n", + " | For the first run, we threw 3 times 1, 4 times 2, etc. For the second,\n", + " | we threw 2 times 1, 4 times 2, etc.\n", + " |\n", + " | A loaded die is more likely to land on number 6:\n", + " |\n", + " | >>> np.random.multinomial(100, [1/7.]*5 + [2/7.])\n", + " | array([11, 16, 14, 17, 16, 26]) # random\n", + " |\n", + " | The probability inputs should be normalized. As an implementation\n", + " | detail, the value of the last entry is ignored and assumed to take\n", + " | up any leftover probability mass, but this should not be relied on.\n", + " | A biased coin which has twice as much weight on one side as on the\n", + " | other should be sampled like so:\n", + " |\n", + " | >>> np.random.multinomial(100, [1.0 / 3, 2.0 / 3]) # RIGHT\n", + " | array([38, 62]) # random\n", + " |\n", + " | not like:\n", + " |\n", + " | >>> np.random.multinomial(100, [1.0, 2.0]) # WRONG\n", + " | Traceback (most recent call last):\n", + " | ValueError: pvals < 0, pvals > 1 or pvals contains NaNs\n", + " |\n", + " | multivariate_normal(self, mean, cov, size=None, check_valid='warn', tol=1e-08)\n", + " | multivariate_normal(mean, cov, size=None, check_valid='warn', tol=1e-8)\n", + " |\n", + " | Draw random samples from a multivariate normal distribution.\n", + " |\n", + " | The multivariate normal, multinormal or Gaussian distribution is a\n", + " | generalization of the one-dimensional normal distribution to higher\n", + " | dimensions. Such a distribution is specified by its mean and\n", + " | covariance matrix. These parameters are analogous to the mean\n", + " | (average or \"center\") and variance (standard deviation, or \"width,\"\n", + " | squared) of the one-dimensional normal distribution.\n", + " |\n", + " | .. note::\n", + " | New code should use the\n", + " | `~numpy.random.Generator.multivariate_normal`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | mean : 1-D array_like, of length N\n", + " | Mean of the N-dimensional distribution.\n", + " | cov : 2-D array_like, of shape (N, N)\n", + " | Covariance matrix of the distribution. It must be symmetric and\n", + " | positive-semidefinite for proper sampling.\n", + " | size : int or tuple of ints, optional\n", + " | Given a shape of, for example, ``(m,n,k)``, ``m*n*k`` samples are\n", + " | generated, and packed in an `m`-by-`n`-by-`k` arrangement. Because\n", + " | each sample is `N`-dimensional, the output shape is ``(m,n,k,N)``.\n", + " | If no shape is specified, a single (`N`-D) sample is returned.\n", + " | check_valid : { 'warn', 'raise', 'ignore' }, optional\n", + " | Behavior when the covariance matrix is not positive semidefinite.\n", + " | tol : float, optional\n", + " | Tolerance when checking the singular values in covariance matrix.\n", + " | cov is cast to double before the check.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray\n", + " | The drawn samples, of shape *size*, if that was provided. If not,\n", + " | the shape is ``(N,)``.\n", + " |\n", + " | In other words, each entry ``out[i,j,...,:]`` is an N-dimensional\n", + " | value drawn from the distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.multivariate_normal: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The mean is a coordinate in N-dimensional space, which represents the\n", + " | location where samples are most likely to be generated. This is\n", + " | analogous to the peak of the bell curve for the one-dimensional or\n", + " | univariate normal distribution.\n", + " |\n", + " | Covariance indicates the level to which two variables vary together.\n", + " | From the multivariate normal distribution, we draw N-dimensional\n", + " | samples, :math:`X = [x_1, x_2, ... x_N]`. The covariance matrix\n", + " | element :math:`C_{ij}` is the covariance of :math:`x_i` and :math:`x_j`.\n", + " | The element :math:`C_{ii}` is the variance of :math:`x_i` (i.e. its\n", + " | \"spread\").\n", + " |\n", + " | Instead of specifying the full covariance matrix, popular\n", + " | approximations include:\n", + " |\n", + " | - Spherical covariance (`cov` is a multiple of the identity matrix)\n", + " | - Diagonal covariance (`cov` has non-negative elements, and only on\n", + " | the diagonal)\n", + " |\n", + " | This geometrical property can be seen in two dimensions by plotting\n", + " | generated data-points:\n", + " |\n", + " | >>> mean = [0, 0]\n", + " | >>> cov = [[1, 0], [0, 100]] # diagonal covariance\n", + " |\n", + " | Diagonal covariance means that points are oriented along x or y-axis:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> x, y = np.random.multivariate_normal(mean, cov, 5000).T\n", + " | >>> plt.plot(x, y, 'x')\n", + " | >>> plt.axis('equal')\n", + " | >>> plt.show()\n", + " |\n", + " | Note that the covariance matrix must be positive semidefinite (a.k.a.\n", + " | nonnegative-definite). Otherwise, the behavior of this method is\n", + " | undefined and backwards compatibility is not guaranteed.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Papoulis, A., \"Probability, Random Variables, and Stochastic\n", + " | Processes,\" 3rd ed., New York: McGraw-Hill, 1991.\n", + " | .. [2] Duda, R. O., Hart, P. E., and Stork, D. G., \"Pattern\n", + " | Classification,\" 2nd ed., New York: Wiley, 2001.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> mean = (1, 2)\n", + " | >>> cov = [[1, 0], [0, 1]]\n", + " | >>> x = np.random.multivariate_normal(mean, cov, (3, 3))\n", + " | >>> x.shape\n", + " | (3, 3, 2)\n", + " |\n", + " | Here we generate 800 samples from the bivariate normal distribution\n", + " | with mean [0, 0] and covariance matrix [[6, -3], [-3, 3.5]]. The\n", + " | expected variances of the first and second components of the sample\n", + " | are 6 and 3.5, respectively, and the expected correlation\n", + " | coefficient is -3/sqrt(6*3.5) ≈ -0.65465.\n", + " |\n", + " | >>> cov = np.array([[6, -3], [-3, 3.5]])\n", + " | >>> pts = np.random.multivariate_normal([0, 0], cov, size=800)\n", + " |\n", + " | Check that the mean, covariance, and correlation coefficient of the\n", + " | sample are close to the expected values:\n", + " |\n", + " | >>> pts.mean(axis=0)\n", + " | array([ 0.0326911 , -0.01280782]) # may vary\n", + " | >>> np.cov(pts.T)\n", + " | array([[ 5.96202397, -2.85602287],\n", + " | [-2.85602287, 3.47613949]]) # may vary\n", + " | >>> np.corrcoef(pts.T)[0, 1]\n", + " | -0.6273591314603949 # may vary\n", + " |\n", + " | We can visualize this data with a scatter plot. The orientation\n", + " | of the point cloud illustrates the negative correlation of the\n", + " | components of this sample.\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> plt.plot(pts[:, 0], pts[:, 1], '.', alpha=0.5)\n", + " | >>> plt.axis('equal')\n", + " | >>> plt.grid()\n", + " | >>> plt.show()\n", + " |\n", + " | negative_binomial(self, n, p, size=None)\n", + " | negative_binomial(n, p, size=None)\n", + " |\n", + " | Draw samples from a negative binomial distribution.\n", + " |\n", + " | Samples are drawn from a negative binomial distribution with specified\n", + " | parameters, `n` successes and `p` probability of success where `n`\n", + " | is > 0 and `p` is in the interval [0, 1].\n", + " |\n", + " | .. note::\n", + " | New code should use the\n", + " | `~numpy.random.Generator.negative_binomial`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | n : float or array_like of floats\n", + " | Parameter of the distribution, > 0.\n", + " | p : float or array_like of floats\n", + " | Parameter of the distribution, >= 0 and <=1.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``n`` and ``p`` are both scalars.\n", + " | Otherwise, ``np.broadcast(n, p).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized negative binomial distribution,\n", + " | where each sample is equal to N, the number of failures that\n", + " | occurred before a total of n successes was reached.\n", + " |\n", + " | .. warning::\n", + " | This function returns the C-long dtype, which is 32bit on windows\n", + " | and otherwise 64bit on 64bit platforms (and 32bit on 32bit ones).\n", + " | Since NumPy 2.0, NumPy's default integer is 32bit on 32bit platforms\n", + " | and 64bit on 64bit platforms.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.negative_binomial: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability mass function of the negative binomial distribution is\n", + " |\n", + " | .. math:: P(N;n,p) = \\frac{\\Gamma(N+n)}{N!\\Gamma(n)}p^{n}(1-p)^{N},\n", + " |\n", + " | where :math:`n` is the number of successes, :math:`p` is the\n", + " | probability of success, :math:`N+n` is the number of trials, and\n", + " | :math:`\\Gamma` is the gamma function. When :math:`n` is an integer,\n", + " | :math:`\\frac{\\Gamma(N+n)}{N!\\Gamma(n)} = \\binom{N+n-1}{N}`, which is\n", + " | the more common form of this term in the pmf. The negative\n", + " | binomial distribution gives the probability of N failures given n\n", + " | successes, with a success on the last trial.\n", + " |\n", + " | If one throws a die repeatedly until the third time a \"1\" appears,\n", + " | then the probability distribution of the number of non-\"1\"s that\n", + " | appear before the third \"1\" is a negative binomial distribution.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Weisstein, Eric W. \"Negative Binomial Distribution.\" From\n", + " | MathWorld--A Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/NegativeBinomialDistribution.html\n", + " | .. [2] Wikipedia, \"Negative binomial distribution\",\n", + " | https://en.wikipedia.org/wiki/Negative_binomial_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | A real world example. A company drills wild-cat oil\n", + " | exploration wells, each with an estimated probability of\n", + " | success of 0.1. What is the probability of having one success\n", + " | for each successive well, that is what is the probability of a\n", + " | single success after drilling 5 wells, after 6 wells, etc.?\n", + " |\n", + " | >>> s = np.random.negative_binomial(1, 0.1, 100000)\n", + " | >>> for i in range(1, 11): # doctest: +SKIP\n", + " | ... probability = sum(s 0.\n", + " | nonc : float or array_like of floats\n", + " | Non-centrality, must be non-negative.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``df`` and ``nonc`` are both scalars.\n", + " | Otherwise, ``np.broadcast(df, nonc).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized noncentral chi-square distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.noncentral_chisquare: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density function for the noncentral Chi-square\n", + " | distribution is\n", + " |\n", + " | .. math:: P(x;df,nonc) = \\sum^{\\infty}_{i=0}\n", + " | \\frac{e^{-nonc/2}(nonc/2)^{i}}{i!}\n", + " | P_{Y_{df+2i}}(x),\n", + " |\n", + " | where :math:`Y_{q}` is the Chi-square with q degrees of freedom.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Wikipedia, \"Noncentral chi-squared distribution\"\n", + " | https://en.wikipedia.org/wiki/Noncentral_chi-squared_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw values from the distribution and plot the histogram\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> values = plt.hist(np.random.noncentral_chisquare(3, 20, 100000),\n", + " | ... bins=200, density=True)\n", + " | >>> plt.show()\n", + " |\n", + " | Draw values from a noncentral chisquare with very small noncentrality,\n", + " | and compare to a chisquare.\n", + " |\n", + " | >>> plt.figure()\n", + " | >>> values = plt.hist(np.random.noncentral_chisquare(3, .0000001, 100000),\n", + " | ... bins=np.arange(0., 25, .1), density=True)\n", + " | >>> values2 = plt.hist(np.random.chisquare(3, 100000),\n", + " | ... bins=np.arange(0., 25, .1), density=True)\n", + " | >>> plt.plot(values[1][0:-1], values[0]-values2[0], 'ob')\n", + " | >>> plt.show()\n", + " |\n", + " | Demonstrate how large values of non-centrality lead to a more symmetric\n", + " | distribution.\n", + " |\n", + " | >>> plt.figure()\n", + " | >>> values = plt.hist(np.random.noncentral_chisquare(3, 20, 100000),\n", + " | ... bins=200, density=True)\n", + " | >>> plt.show()\n", + " |\n", + " | noncentral_f(self, dfnum, dfden, nonc, size=None)\n", + " | noncentral_f(dfnum, dfden, nonc, size=None)\n", + " |\n", + " | Draw samples from the noncentral F distribution.\n", + " |\n", + " | Samples are drawn from an F distribution with specified parameters,\n", + " | `dfnum` (degrees of freedom in numerator) and `dfden` (degrees of\n", + " | freedom in denominator), where both parameters > 1.\n", + " | `nonc` is the non-centrality parameter.\n", + " |\n", + " | .. note::\n", + " | New code should use the\n", + " | `~numpy.random.Generator.noncentral_f`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | dfnum : float or array_like of floats\n", + " | Numerator degrees of freedom, must be > 0.\n", + " | dfden : float or array_like of floats\n", + " | Denominator degrees of freedom, must be > 0.\n", + " | nonc : float or array_like of floats\n", + " | Non-centrality parameter, the sum of the squares of the numerator\n", + " | means, must be >= 0.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``dfnum``, ``dfden``, and ``nonc``\n", + " | are all scalars. Otherwise, ``np.broadcast(dfnum, dfden, nonc).size``\n", + " | samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized noncentral Fisher distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.noncentral_f: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | When calculating the power of an experiment (power = probability of\n", + " | rejecting the null hypothesis when a specific alternative is true) the\n", + " | non-central F statistic becomes important. When the null hypothesis is\n", + " | true, the F statistic follows a central F distribution. When the null\n", + " | hypothesis is not true, then it follows a non-central F statistic.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Weisstein, Eric W. \"Noncentral F-Distribution.\"\n", + " | From MathWorld--A Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/NoncentralF-Distribution.html\n", + " | .. [2] Wikipedia, \"Noncentral F-distribution\",\n", + " | https://en.wikipedia.org/wiki/Noncentral_F-distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | In a study, testing for a specific alternative to the null hypothesis\n", + " | requires use of the Noncentral F distribution. We need to calculate the\n", + " | area in the tail of the distribution that exceeds the value of the F\n", + " | distribution for the null hypothesis. We'll plot the two probability\n", + " | distributions for comparison.\n", + " |\n", + " | >>> dfnum = 3 # between group deg of freedom\n", + " | >>> dfden = 20 # within groups degrees of freedom\n", + " | >>> nonc = 3.0\n", + " | >>> nc_vals = np.random.noncentral_f(dfnum, dfden, nonc, 1000000)\n", + " | >>> NF = np.histogram(nc_vals, bins=50, density=True)\n", + " | >>> c_vals = np.random.f(dfnum, dfden, 1000000)\n", + " | >>> F = np.histogram(c_vals, bins=50, density=True)\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> plt.plot(F[1][1:], F[0])\n", + " | >>> plt.plot(NF[1][1:], NF[0])\n", + " | >>> plt.show()\n", + " |\n", + " | normal(self, loc=0.0, scale=1.0, size=None)\n", + " | normal(loc=0.0, scale=1.0, size=None)\n", + " |\n", + " | Draw random samples from a normal (Gaussian) distribution.\n", + " |\n", + " | The probability density function of the normal distribution, first\n", + " | derived by De Moivre and 200 years later by both Gauss and Laplace\n", + " | independently [2]_, is often called the bell curve because of\n", + " | its characteristic shape (see the example below).\n", + " |\n", + " | The normal distributions occurs often in nature. For example, it\n", + " | describes the commonly occurring distribution of samples influenced\n", + " | by a large number of tiny, random disturbances, each with its own\n", + " | unique distribution [2]_.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.normal`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | loc : float or array_like of floats\n", + " | Mean (\"centre\") of the distribution.\n", + " | scale : float or array_like of floats\n", + " | Standard deviation (spread or \"width\") of the distribution. Must be\n", + " | non-negative.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``loc`` and ``scale`` are both scalars.\n", + " | Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized normal distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.norm : probability density function, distribution or\n", + " | cumulative density function, etc.\n", + " | random.Generator.normal: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density for the Gaussian distribution is\n", + " |\n", + " | .. math:: p(x) = \\frac{1}{\\sqrt{ 2 \\pi \\sigma^2 }}\n", + " | e^{ - \\frac{ (x - \\mu)^2 } {2 \\sigma^2} },\n", + " |\n", + " | where :math:`\\mu` is the mean and :math:`\\sigma` the standard\n", + " | deviation. The square of the standard deviation, :math:`\\sigma^2`,\n", + " | is called the variance.\n", + " |\n", + " | The function has its peak at the mean, and its \"spread\" increases with\n", + " | the standard deviation (the function reaches 0.607 times its maximum at\n", + " | :math:`x + \\sigma` and :math:`x - \\sigma` [2]_). This implies that\n", + " | normal is more likely to return samples lying close to the mean, rather\n", + " | than those far away.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Wikipedia, \"Normal distribution\",\n", + " | https://en.wikipedia.org/wiki/Normal_distribution\n", + " | .. [2] P. R. Peebles Jr., \"Central Limit Theorem\" in \"Probability,\n", + " | Random Variables and Random Signal Principles\", 4th ed., 2001,\n", + " | pp. 51, 51, 125.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> mu, sigma = 0, 0.1 # mean and standard deviation\n", + " | >>> s = np.random.normal(mu, sigma, 1000)\n", + " |\n", + " | Verify the mean and the standard deviation:\n", + " |\n", + " | >>> abs(mu - np.mean(s))\n", + " | 0.0 # may vary\n", + " |\n", + " | >>> abs(sigma - np.std(s, ddof=1))\n", + " | 0.1 # may vary\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, ignored = plt.hist(s, 30, density=True)\n", + " | >>> plt.plot(bins, 1/(sigma * np.sqrt(2 * np.pi)) *\n", + " | ... np.exp( - (bins - mu)**2 / (2 * sigma**2) ),\n", + " | ... linewidth=2, color='r')\n", + " | >>> plt.show()\n", + " |\n", + " | Two-by-four array of samples from the normal distribution with\n", + " | mean 3 and standard deviation 2.5:\n", + " |\n", + " | >>> np.random.normal(3, 2.5, size=(2, 4))\n", + " | array([[-4.49401501, 4.00950034, -1.81814867, 7.29718677], # random\n", + " | [ 0.39924804, 4.68456316, 4.99394529, 4.84057254]]) # random\n", + " |\n", + " | pareto(self, a, size=None)\n", + " | pareto(a, size=None)\n", + " |\n", + " | Draw samples from a Pareto II or Lomax distribution with\n", + " | specified shape.\n", + " |\n", + " | The Lomax or Pareto II distribution is a shifted Pareto\n", + " | distribution. The classical Pareto distribution can be\n", + " | obtained from the Lomax distribution by adding 1 and\n", + " | multiplying by the scale parameter ``m`` (see Notes). The\n", + " | smallest value of the Lomax distribution is zero while for the\n", + " | classical Pareto distribution it is ``mu``, where the standard\n", + " | Pareto distribution has location ``mu = 1``. Lomax can also\n", + " | be considered as a simplified version of the Generalized\n", + " | Pareto distribution (available in SciPy), with the scale set\n", + " | to one and the location set to zero.\n", + " |\n", + " | The Pareto distribution must be greater than zero, and is\n", + " | unbounded above. It is also known as the \"80-20 rule\". In\n", + " | this distribution, 80 percent of the weights are in the lowest\n", + " | 20 percent of the range, while the other 20 percent fill the\n", + " | remaining 80 percent of the range.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.pareto`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | a : float or array_like of floats\n", + " | Shape of the distribution. Must be positive.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``a`` is a scalar. Otherwise,\n", + " | ``np.array(a).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized Pareto distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.lomax : probability density function, distribution or\n", + " | cumulative density function, etc.\n", + " | scipy.stats.genpareto : probability density function, distribution or\n", + " | cumulative density function, etc.\n", + " | random.Generator.pareto: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density for the Pareto distribution is\n", + " |\n", + " | .. math:: p(x) = \\frac{am^a}{x^{a+1}}\n", + " |\n", + " | where :math:`a` is the shape and :math:`m` the scale.\n", + " |\n", + " | The Pareto distribution, named after the Italian economist\n", + " | Vilfredo Pareto, is a power law probability distribution\n", + " | useful in many real world problems. Outside the field of\n", + " | economics it is generally referred to as the Bradford\n", + " | distribution. Pareto developed the distribution to describe\n", + " | the distribution of wealth in an economy. It has also found\n", + " | use in insurance, web page access statistics, oil field sizes,\n", + " | and many other problems, including the download frequency for\n", + " | projects in Sourceforge [1]_. It is one of the so-called\n", + " | \"fat-tailed\" distributions.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Francis Hunt and Paul Johnson, On the Pareto Distribution of\n", + " | Sourceforge projects.\n", + " | .. [2] Pareto, V. (1896). Course of Political Economy. Lausanne.\n", + " | .. [3] Reiss, R.D., Thomas, M.(2001), Statistical Analysis of Extreme\n", + " | Values, Birkhauser Verlag, Basel, pp 23-30.\n", + " | .. [4] Wikipedia, \"Pareto distribution\",\n", + " | https://en.wikipedia.org/wiki/Pareto_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> a, m = 3., 2. # shape and mode\n", + " | >>> s = (np.random.pareto(a, 1000) + 1) * m\n", + " |\n", + " | Display the histogram of the samples, along with the probability\n", + " | density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, _ = plt.hist(s, 100, density=True)\n", + " | >>> fit = a*m**a / bins**(a+1)\n", + " | >>> plt.plot(bins, max(count)*fit/max(fit), linewidth=2, color='r')\n", + " | >>> plt.show()\n", + " |\n", + " | permutation(self, x)\n", + " | permutation(x)\n", + " |\n", + " | Randomly permute a sequence, or return a permuted range.\n", + " |\n", + " | If `x` is a multi-dimensional array, it is only shuffled along its\n", + " | first index.\n", + " |\n", + " | .. note::\n", + " | New code should use the\n", + " | `~numpy.random.Generator.permutation`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | x : int or array_like\n", + " | If `x` is an integer, randomly permute ``np.arange(x)``.\n", + " | If `x` is an array, make a copy and shuffle the elements\n", + " | randomly.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray\n", + " | Permuted sequence or array range.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.permutation: which should be used for new code.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> np.random.permutation(10)\n", + " | array([1, 7, 4, 3, 0, 9, 2, 5, 8, 6]) # random\n", + " |\n", + " | >>> np.random.permutation([1, 4, 9, 12, 15])\n", + " | array([15, 1, 9, 4, 12]) # random\n", + " |\n", + " | >>> arr = np.arange(9).reshape((3, 3))\n", + " | >>> np.random.permutation(arr)\n", + " | array([[6, 7, 8], # random\n", + " | [0, 1, 2],\n", + " | [3, 4, 5]])\n", + " |\n", + " | poisson(self, lam=1.0, size=None)\n", + " | poisson(lam=1.0, size=None)\n", + " |\n", + " | Draw samples from a Poisson distribution.\n", + " |\n", + " | The Poisson distribution is the limit of the binomial distribution\n", + " | for large N.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.poisson`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | lam : float or array_like of floats\n", + " | Expected number of events occurring in a fixed-time interval,\n", + " | must be >= 0. A sequence must be broadcastable over the requested\n", + " | size.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``lam`` is a scalar. Otherwise,\n", + " | ``np.array(lam).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized Poisson distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.poisson: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability mass function (PMF) of Poisson distribution is\n", + " |\n", + " | .. math:: f(k; \\lambda)=\\frac{\\lambda^k e^{-\\lambda}}{k!}\n", + " |\n", + " | For events with an expected separation :math:`\\lambda` the Poisson\n", + " | distribution :math:`f(k; \\lambda)` describes the probability of\n", + " | :math:`k` events occurring within the observed\n", + " | interval :math:`\\lambda`.\n", + " |\n", + " | Because the output is limited to the range of the C int64 type, a\n", + " | ValueError is raised when `lam` is within 10 sigma of the maximum\n", + " | representable value.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Weisstein, Eric W. \"Poisson Distribution.\"\n", + " | From MathWorld--A Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/PoissonDistribution.html\n", + " | .. [2] Wikipedia, \"Poisson distribution\",\n", + " | https://en.wikipedia.org/wiki/Poisson_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> import numpy as np\n", + " | >>> s = np.random.poisson(5, 10000)\n", + " |\n", + " | Display histogram of the sample:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, ignored = plt.hist(s, 14, density=True)\n", + " | >>> plt.show()\n", + " |\n", + " | Draw each 100 values for lambda 100 and 500:\n", + " |\n", + " | >>> s = np.random.poisson(lam=(100., 500.), size=(100, 2))\n", + " |\n", + " | power(self, a, size=None)\n", + " | power(a, size=None)\n", + " |\n", + " | Draws samples in [0, 1] from a power distribution with positive\n", + " | exponent a - 1.\n", + " |\n", + " | Also known as the power function distribution.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.power`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | a : float or array_like of floats\n", + " | Parameter of the distribution. Must be non-negative.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``a`` is a scalar. Otherwise,\n", + " | ``np.array(a).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized power distribution.\n", + " |\n", + " | Raises\n", + " | ------\n", + " | ValueError\n", + " | If a <= 0.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.power: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density function is\n", + " |\n", + " | .. math:: P(x; a) = ax^{a-1}, 0 \\le x \\le 1, a>0.\n", + " |\n", + " | The power function distribution is just the inverse of the Pareto\n", + " | distribution. It may also be seen as a special case of the Beta\n", + " | distribution.\n", + " |\n", + " | It is used, for example, in modeling the over-reporting of insurance\n", + " | claims.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Christian Kleiber, Samuel Kotz, \"Statistical size distributions\n", + " | in economics and actuarial sciences\", Wiley, 2003.\n", + " | .. [2] Heckert, N. A. and Filliben, James J. \"NIST Handbook 148:\n", + " | Dataplot Reference Manual, Volume 2: Let Subcommands and Library\n", + " | Functions\", National Institute of Standards and Technology\n", + " | Handbook Series, June 2003.\n", + " | https://www.itl.nist.gov/div898/software/dataplot/refman2/auxillar/powpdf.pdf\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> a = 5. # shape\n", + " | >>> samples = 1000\n", + " | >>> s = np.random.power(a, samples)\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, ignored = plt.hist(s, bins=30)\n", + " | >>> x = np.linspace(0, 1, 100)\n", + " | >>> y = a*x**(a-1.)\n", + " | >>> normed_y = samples*np.diff(bins)[0]*y\n", + " | >>> plt.plot(x, normed_y)\n", + " | >>> plt.show()\n", + " |\n", + " | Compare the power function distribution to the inverse of the Pareto.\n", + " |\n", + " | >>> from scipy import stats # doctest: +SKIP\n", + " | >>> rvs = np.random.power(5, 1000000)\n", + " | >>> rvsp = np.random.pareto(5, 1000000)\n", + " | >>> xx = np.linspace(0,1,100)\n", + " | >>> powpdf = stats.powerlaw.pdf(xx,5) # doctest: +SKIP\n", + " |\n", + " | >>> plt.figure()\n", + " | >>> plt.hist(rvs, bins=50, density=True)\n", + " | >>> plt.plot(xx,powpdf,'r-') # doctest: +SKIP\n", + " | >>> plt.title('np.random.power(5)')\n", + " |\n", + " | >>> plt.figure()\n", + " | >>> plt.hist(1./(1.+rvsp), bins=50, density=True)\n", + " | >>> plt.plot(xx,powpdf,'r-') # doctest: +SKIP\n", + " | >>> plt.title('inverse of 1 + np.random.pareto(5)')\n", + " |\n", + " | >>> plt.figure()\n", + " | >>> plt.hist(1./(1.+rvsp), bins=50, density=True)\n", + " | >>> plt.plot(xx,powpdf,'r-') # doctest: +SKIP\n", + " | >>> plt.title('inverse of stats.pareto(5)')\n", + " |\n", + " | rand(self, *args)\n", + " | rand(d0, d1, ..., dn)\n", + " |\n", + " | Random values in a given shape.\n", + " |\n", + " | .. note::\n", + " | This is a convenience function for users porting code from Matlab,\n", + " | and wraps `random_sample`. That function takes a\n", + " | tuple to specify the size of the output, which is consistent with\n", + " | other NumPy functions like `numpy.zeros` and `numpy.ones`.\n", + " |\n", + " | Create an array of the given shape and populate it with\n", + " | random samples from a uniform distribution\n", + " | over ``[0, 1)``.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | d0, d1, ..., dn : int, optional\n", + " | The dimensions of the returned array, must be non-negative.\n", + " | If no argument is given a single Python float is returned.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray, shape ``(d0, d1, ..., dn)``\n", + " | Random values.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> np.random.rand(3,2)\n", + " | array([[ 0.14022471, 0.96360618], #random\n", + " | [ 0.37601032, 0.25528411], #random\n", + " | [ 0.49313049, 0.94909878]]) #random\n", + " |\n", + " | randint(self, low, high=None, size=None, dtype=)\n", + " | randint(low, high=None, size=None, dtype=int)\n", + " |\n", + " | Return random integers from `low` (inclusive) to `high` (exclusive).\n", + " |\n", + " | Return random integers from the \"discrete uniform\" distribution of\n", + " | the specified dtype in the \"half-open\" interval [`low`, `high`). If\n", + " | `high` is None (the default), then results are from [0, `low`).\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.integers`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | low : int or array-like of ints\n", + " | Lowest (signed) integers to be drawn from the distribution (unless\n", + " | ``high=None``, in which case this parameter is one above the\n", + " | *highest* such integer).\n", + " | high : int or array-like of ints, optional\n", + " | If provided, one above the largest (signed) integer to be drawn\n", + " | from the distribution (see above for behavior if ``high=None``).\n", + " | If array-like, must contain integer values\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " | dtype : dtype, optional\n", + " | Desired dtype of the result. Byteorder must be native.\n", + " | The default value is long.\n", + " |\n", + " | .. warning::\n", + " | This function defaults to the C-long dtype, which is 32bit on windows\n", + " | and otherwise 64bit on 64bit platforms (and 32bit on 32bit ones).\n", + " | Since NumPy 2.0, NumPy's default integer is 32bit on 32bit platforms\n", + " | and 64bit on 64bit platforms. Which corresponds to `np.intp`.\n", + " | (`dtype=int` is not the same as in most NumPy functions.)\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : int or ndarray of ints\n", + " | `size`-shaped array of random integers from the appropriate\n", + " | distribution, or a single such random int if `size` not provided.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random_integers : similar to `randint`, only for the closed\n", + " | interval [`low`, `high`], and 1 is the lowest value if `high` is\n", + " | omitted.\n", + " | random.Generator.integers: which should be used for new code.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> np.random.randint(2, size=10)\n", + " | array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0]) # random\n", + " | >>> np.random.randint(1, size=10)\n", + " | array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n", + " |\n", + " | Generate a 2 x 4 array of ints between 0 and 4, inclusive:\n", + " |\n", + " | >>> np.random.randint(5, size=(2, 4))\n", + " | array([[4, 0, 2, 1], # random\n", + " | [3, 2, 2, 0]])\n", + " |\n", + " | Generate a 1 x 3 array with 3 different upper bounds\n", + " |\n", + " | >>> np.random.randint(1, [3, 5, 10])\n", + " | array([2, 2, 9]) # random\n", + " |\n", + " | Generate a 1 by 3 array with 3 different lower bounds\n", + " |\n", + " | >>> np.random.randint([1, 5, 7], 10)\n", + " | array([9, 8, 7]) # random\n", + " |\n", + " | Generate a 2 by 4 array using broadcasting with dtype of uint8\n", + " |\n", + " | >>> np.random.randint([1, 3, 5, 7], [[10], [20]], dtype=np.uint8)\n", + " | array([[ 8, 6, 9, 7], # random\n", + " | [ 1, 16, 9, 12]], dtype=uint8)\n", + " |\n", + " | randn(self, *args)\n", + " | randn(d0, d1, ..., dn)\n", + " |\n", + " | Return a sample (or samples) from the \"standard normal\" distribution.\n", + " |\n", + " | .. note::\n", + " | This is a convenience function for users porting code from Matlab,\n", + " | and wraps `standard_normal`. That function takes a\n", + " | tuple to specify the size of the output, which is consistent with\n", + " | other NumPy functions like `numpy.zeros` and `numpy.ones`.\n", + " |\n", + " | .. note::\n", + " | New code should use the\n", + " | `~numpy.random.Generator.standard_normal`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | If positive int_like arguments are provided, `randn` generates an array\n", + " | of shape ``(d0, d1, ..., dn)``, filled\n", + " | with random floats sampled from a univariate \"normal\" (Gaussian)\n", + " | distribution of mean 0 and variance 1. A single float randomly sampled\n", + " | from the distribution is returned if no argument is provided.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | d0, d1, ..., dn : int, optional\n", + " | The dimensions of the returned array, must be non-negative.\n", + " | If no argument is given a single Python float is returned.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | Z : ndarray or float\n", + " | A ``(d0, d1, ..., dn)``-shaped array of floating-point samples from\n", + " | the standard normal distribution, or a single such float if\n", + " | no parameters were supplied.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | standard_normal : Similar, but takes a tuple as its argument.\n", + " | normal : Also accepts mu and sigma arguments.\n", + " | random.Generator.standard_normal: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | For random samples from the normal distribution with mean ``mu`` and\n", + " | standard deviation ``sigma``, use::\n", + " |\n", + " | sigma * np.random.randn(...) + mu\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> np.random.randn()\n", + " | 2.1923875335537315 # random\n", + " |\n", + " | Two-by-four array of samples from the normal distribution with\n", + " | mean 3 and standard deviation 2.5:\n", + " |\n", + " | >>> 3 + 2.5 * np.random.randn(2, 4)\n", + " | array([[-4.49401501, 4.00950034, -1.81814867, 7.29718677], # random\n", + " | [ 0.39924804, 4.68456316, 4.99394529, 4.84057254]]) # random\n", + " |\n", + " | random(self, size=None)\n", + " | random(size=None)\n", + " |\n", + " | Return random floats in the half-open interval [0.0, 1.0). Alias for\n", + " | `random_sample` to ease forward-porting to the new random API.\n", + " |\n", + " | random_integers(self, low, high=None, size=None)\n", + " | random_integers(low, high=None, size=None)\n", + " |\n", + " | Random integers of type `numpy.int_` between `low` and `high`, inclusive.\n", + " |\n", + " | Return random integers of type `numpy.int_` from the \"discrete uniform\"\n", + " | distribution in the closed interval [`low`, `high`]. If `high` is\n", + " | None (the default), then results are from [1, `low`]. The `numpy.int_`\n", + " | type translates to the C long integer type and its precision\n", + " | is platform dependent.\n", + " |\n", + " | This function has been deprecated. Use randint instead.\n", + " |\n", + " | .. deprecated:: 1.11.0\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | low : int\n", + " | Lowest (signed) integer to be drawn from the distribution (unless\n", + " | ``high=None``, in which case this parameter is the *highest* such\n", + " | integer).\n", + " | high : int, optional\n", + " | If provided, the largest (signed) integer to be drawn from the\n", + " | distribution (see above for behavior if ``high=None``).\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : int or ndarray of ints\n", + " | `size`-shaped array of random integers from the appropriate\n", + " | distribution, or a single such random int if `size` not provided.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | randint : Similar to `random_integers`, only for the half-open\n", + " | interval [`low`, `high`), and 0 is the lowest value if `high` is\n", + " | omitted.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | To sample from N evenly spaced floating-point numbers between a and b,\n", + " | use::\n", + " |\n", + " | a + (b - a) * (np.random.random_integers(N) - 1) / (N - 1.)\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> np.random.random_integers(5)\n", + " | 4 # random\n", + " | >>> type(np.random.random_integers(5))\n", + " | \n", + " | >>> np.random.random_integers(5, size=(3,2))\n", + " | array([[5, 4], # random\n", + " | [3, 3],\n", + " | [4, 5]])\n", + " |\n", + " | Choose five random numbers from the set of five evenly-spaced\n", + " | numbers between 0 and 2.5, inclusive (*i.e.*, from the set\n", + " | :math:`{0, 5/8, 10/8, 15/8, 20/8}`):\n", + " |\n", + " | >>> 2.5 * (np.random.random_integers(5, size=(5,)) - 1) / 4.\n", + " | array([ 0.625, 1.25 , 0.625, 0.625, 2.5 ]) # random\n", + " |\n", + " | Roll two six sided dice 1000 times and sum the results:\n", + " |\n", + " | >>> d1 = np.random.random_integers(1, 6, 1000)\n", + " | >>> d2 = np.random.random_integers(1, 6, 1000)\n", + " | >>> dsums = d1 + d2\n", + " |\n", + " | Display results as a histogram:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, ignored = plt.hist(dsums, 11, density=True)\n", + " | >>> plt.show()\n", + " |\n", + " | random_sample(self, size=None)\n", + " | random_sample(size=None)\n", + " |\n", + " | Return random floats in the half-open interval [0.0, 1.0).\n", + " |\n", + " | Results are from the \"continuous uniform\" distribution over the\n", + " | stated interval. To sample :math:`Unif[a, b), b > a` multiply\n", + " | the output of `random_sample` by `(b-a)` and add `a`::\n", + " |\n", + " | (b - a) * random_sample() + a\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.random`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : float or ndarray of floats\n", + " | Array of random floats of shape `size` (unless ``size=None``, in which\n", + " | case a single float is returned).\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.random: which should be used for new code.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> np.random.random_sample()\n", + " | 0.47108547995356098 # random\n", + " | >>> type(np.random.random_sample())\n", + " | \n", + " | >>> np.random.random_sample((5,))\n", + " | array([ 0.30220482, 0.86820401, 0.1654503 , 0.11659149, 0.54323428]) # random\n", + " |\n", + " | Three-by-two array of random numbers from [-5, 0):\n", + " |\n", + " | >>> 5 * np.random.random_sample((3, 2)) - 5\n", + " | array([[-3.99149989, -0.52338984], # random\n", + " | [-2.99091858, -0.79479508],\n", + " | [-1.23204345, -1.75224494]])\n", + " |\n", + " | rayleigh(self, scale=1.0, size=None)\n", + " | rayleigh(scale=1.0, size=None)\n", + " |\n", + " | Draw samples from a Rayleigh distribution.\n", + " |\n", + " | The :math:`\\chi` and Weibull distributions are generalizations of the\n", + " | Rayleigh.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.rayleigh`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | scale : float or array_like of floats, optional\n", + " | Scale, also equals the mode. Must be non-negative. Default is 1.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``scale`` is a scalar. Otherwise,\n", + " | ``np.array(scale).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized Rayleigh distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.rayleigh: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density function for the Rayleigh distribution is\n", + " |\n", + " | .. math:: P(x;scale) = \\frac{x}{scale^2}e^{\\frac{-x^2}{2 \\cdotp scale^2}}\n", + " |\n", + " | The Rayleigh distribution would arise, for example, if the East\n", + " | and North components of the wind velocity had identical zero-mean\n", + " | Gaussian distributions. Then the wind speed would have a Rayleigh\n", + " | distribution.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Brighton Webs Ltd., \"Rayleigh Distribution,\"\n", + " | https://web.archive.org/web/20090514091424/http://brighton-webs.co.uk:80/distributions/rayleigh.asp\n", + " | .. [2] Wikipedia, \"Rayleigh distribution\"\n", + " | https://en.wikipedia.org/wiki/Rayleigh_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw values from the distribution and plot the histogram\n", + " |\n", + " | >>> from matplotlib.pyplot import hist\n", + " | >>> values = hist(np.random.rayleigh(3, 100000), bins=200, density=True)\n", + " |\n", + " | Wave heights tend to follow a Rayleigh distribution. If the mean wave\n", + " | height is 1 meter, what fraction of waves are likely to be larger than 3\n", + " | meters?\n", + " |\n", + " | >>> meanvalue = 1\n", + " | >>> modevalue = np.sqrt(2 / np.pi) * meanvalue\n", + " | >>> s = np.random.rayleigh(modevalue, 1000000)\n", + " |\n", + " | The percentage of waves larger than 3 meters is:\n", + " |\n", + " | >>> 100.*sum(s>3)/1000000.\n", + " | 0.087300000000000003 # random\n", + " |\n", + " | seed(self, seed=None)\n", + " | seed(seed=None)\n", + " |\n", + " | Reseed a legacy MT19937 BitGenerator\n", + " |\n", + " | Notes\n", + " | -----\n", + " | This is a convenience, legacy function.\n", + " |\n", + " | The best practice is to **not** reseed a BitGenerator, rather to\n", + " | recreate a new one. This method is here for legacy reasons.\n", + " | This example demonstrates best practice.\n", + " |\n", + " | >>> from numpy.random import MT19937\n", + " | >>> from numpy.random import RandomState, SeedSequence\n", + " | >>> rs = RandomState(MT19937(SeedSequence(123456789)))\n", + " | # Later, you want to restart the stream\n", + " | >>> rs = RandomState(MT19937(SeedSequence(987654321)))\n", + " |\n", + " | set_state(self, state)\n", + " | set_state(state)\n", + " |\n", + " | Set the internal state of the generator from a tuple.\n", + " |\n", + " | For use if one has reason to manually (re-)set the internal state of\n", + " | the bit generator used by the RandomState instance. By default,\n", + " | RandomState uses the \"Mersenne Twister\"[1]_ pseudo-random number\n", + " | generating algorithm.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | state : {tuple(str, ndarray of 624 uints, int, int, float), dict}\n", + " | The `state` tuple has the following items:\n", + " |\n", + " | 1. the string 'MT19937', specifying the Mersenne Twister algorithm.\n", + " | 2. a 1-D array of 624 unsigned integers ``keys``.\n", + " | 3. an integer ``pos``.\n", + " | 4. an integer ``has_gauss``.\n", + " | 5. a float ``cached_gaussian``.\n", + " |\n", + " | If state is a dictionary, it is directly set using the BitGenerators\n", + " | `state` property.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : None\n", + " | Returns 'None' on success.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | get_state\n", + " |\n", + " | Notes\n", + " | -----\n", + " | `set_state` and `get_state` are not needed to work with any of the\n", + " | random distributions in NumPy. If the internal state is manually altered,\n", + " | the user should know exactly what he/she is doing.\n", + " |\n", + " | For backwards compatibility, the form (str, array of 624 uints, int) is\n", + " | also accepted although it is missing some information about the cached\n", + " | Gaussian value: ``state = ('MT19937', keys, pos)``.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] M. Matsumoto and T. Nishimura, \"Mersenne Twister: A\n", + " | 623-dimensionally equidistributed uniform pseudorandom number\n", + " | generator,\" *ACM Trans. on Modeling and Computer Simulation*,\n", + " | Vol. 8, No. 1, pp. 3-30, Jan. 1998.\n", + " |\n", + " | shuffle(self, x)\n", + " | shuffle(x)\n", + " |\n", + " | Modify a sequence in-place by shuffling its contents.\n", + " |\n", + " | This function only shuffles the array along the first axis of a\n", + " | multi-dimensional array. The order of sub-arrays is changed but\n", + " | their contents remains the same.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.shuffle`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | x : ndarray or MutableSequence\n", + " | The array, list or mutable sequence to be shuffled.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | None\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.shuffle: which should be used for new code.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> arr = np.arange(10)\n", + " | >>> np.random.shuffle(arr)\n", + " | >>> arr\n", + " | [1 7 5 2 9 4 3 6 0 8] # random\n", + " |\n", + " | Multi-dimensional arrays are only shuffled along the first axis:\n", + " |\n", + " | >>> arr = np.arange(9).reshape((3, 3))\n", + " | >>> np.random.shuffle(arr)\n", + " | >>> arr\n", + " | array([[3, 4, 5], # random\n", + " | [6, 7, 8],\n", + " | [0, 1, 2]])\n", + " |\n", + " | standard_cauchy(self, size=None)\n", + " | standard_cauchy(size=None)\n", + " |\n", + " | Draw samples from a standard Cauchy distribution with mode = 0.\n", + " |\n", + " | Also known as the Lorentz distribution.\n", + " |\n", + " | .. note::\n", + " | New code should use the\n", + " | `~numpy.random.Generator.standard_cauchy`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | samples : ndarray or scalar\n", + " | The drawn samples.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.standard_cauchy: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density function for the full Cauchy distribution is\n", + " |\n", + " | .. math:: P(x; x_0, \\gamma) = \\frac{1}{\\pi \\gamma \\bigl[ 1+\n", + " | (\\frac{x-x_0}{\\gamma})^2 \\bigr] }\n", + " |\n", + " | and the Standard Cauchy distribution just sets :math:`x_0=0` and\n", + " | :math:`\\gamma=1`\n", + " |\n", + " | The Cauchy distribution arises in the solution to the driven harmonic\n", + " | oscillator problem, and also describes spectral line broadening. It\n", + " | also describes the distribution of values at which a line tilted at\n", + " | a random angle will cut the x axis.\n", + " |\n", + " | When studying hypothesis tests that assume normality, seeing how the\n", + " | tests perform on data from a Cauchy distribution is a good indicator of\n", + " | their sensitivity to a heavy-tailed distribution, since the Cauchy looks\n", + " | very much like a Gaussian distribution, but with heavier tails.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] NIST/SEMATECH e-Handbook of Statistical Methods, \"Cauchy\n", + " | Distribution\",\n", + " | https://www.itl.nist.gov/div898/handbook/eda/section3/eda3663.htm\n", + " | .. [2] Weisstein, Eric W. \"Cauchy Distribution.\" From MathWorld--A\n", + " | Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/CauchyDistribution.html\n", + " | .. [3] Wikipedia, \"Cauchy distribution\"\n", + " | https://en.wikipedia.org/wiki/Cauchy_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples and plot the distribution:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> s = np.random.standard_cauchy(1000000)\n", + " | >>> s = s[(s>-25) & (s<25)] # truncate distribution so it plots well\n", + " | >>> plt.hist(s, bins=100)\n", + " | >>> plt.show()\n", + " |\n", + " | standard_exponential(self, size=None)\n", + " | standard_exponential(size=None)\n", + " |\n", + " | Draw samples from the standard exponential distribution.\n", + " |\n", + " | `standard_exponential` is identical to the exponential distribution\n", + " | with a scale parameter of 1.\n", + " |\n", + " | .. note::\n", + " | New code should use the\n", + " | `~numpy.random.Generator.standard_exponential`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : float or ndarray\n", + " | Drawn samples.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.standard_exponential: which should be used for new code.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Output a 3x8000 array:\n", + " |\n", + " | >>> n = np.random.standard_exponential((3, 8000))\n", + " |\n", + " | standard_gamma(self, shape, size=None)\n", + " | standard_gamma(shape, size=None)\n", + " |\n", + " | Draw samples from a standard Gamma distribution.\n", + " |\n", + " | Samples are drawn from a Gamma distribution with specified parameters,\n", + " | shape (sometimes designated \"k\") and scale=1.\n", + " |\n", + " | .. note::\n", + " | New code should use the\n", + " | `~numpy.random.Generator.standard_gamma`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | shape : float or array_like of floats\n", + " | Parameter, must be non-negative.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``shape`` is a scalar. Otherwise,\n", + " | ``np.array(shape).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized standard gamma distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.gamma : probability density function, distribution or\n", + " | cumulative density function, etc.\n", + " | random.Generator.standard_gamma: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density for the Gamma distribution is\n", + " |\n", + " | .. math:: p(x) = x^{k-1}\\frac{e^{-x/\\theta}}{\\theta^k\\Gamma(k)},\n", + " |\n", + " | where :math:`k` is the shape and :math:`\\theta` the scale,\n", + " | and :math:`\\Gamma` is the Gamma function.\n", + " |\n", + " | The Gamma distribution is often used to model the times to failure of\n", + " | electronic components, and arises naturally in processes for which the\n", + " | waiting times between Poisson distributed events are relevant.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Weisstein, Eric W. \"Gamma Distribution.\" From MathWorld--A\n", + " | Wolfram Web Resource.\n", + " | https://mathworld.wolfram.com/GammaDistribution.html\n", + " | .. [2] Wikipedia, \"Gamma distribution\",\n", + " | https://en.wikipedia.org/wiki/Gamma_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> shape, scale = 2., 1. # mean and width\n", + " | >>> s = np.random.standard_gamma(shape, 1000000)\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> import scipy.special as sps # doctest: +SKIP\n", + " | >>> count, bins, ignored = plt.hist(s, 50, density=True)\n", + " | >>> y = bins**(shape-1) * ((np.exp(-bins/scale))/ # doctest: +SKIP\n", + " | ... (sps.gamma(shape) * scale**shape))\n", + " | >>> plt.plot(bins, y, linewidth=2, color='r') # doctest: +SKIP\n", + " | >>> plt.show()\n", + " |\n", + " | standard_normal(self, size=None)\n", + " | standard_normal(size=None)\n", + " |\n", + " | Draw samples from a standard Normal distribution (mean=0, stdev=1).\n", + " |\n", + " | .. note::\n", + " | New code should use the\n", + " | `~numpy.random.Generator.standard_normal`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : float or ndarray\n", + " | A floating-point array of shape ``size`` of drawn samples, or a\n", + " | single sample if ``size`` was not specified.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | normal :\n", + " | Equivalent function with additional ``loc`` and ``scale`` arguments\n", + " | for setting the mean and standard deviation.\n", + " | random.Generator.standard_normal: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | For random samples from the normal distribution with mean ``mu`` and\n", + " | standard deviation ``sigma``, use one of::\n", + " |\n", + " | mu + sigma * np.random.standard_normal(size=...)\n", + " | np.random.normal(mu, sigma, size=...)\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> np.random.standard_normal()\n", + " | 2.1923875335537315 #random\n", + " |\n", + " | >>> s = np.random.standard_normal(8000)\n", + " | >>> s\n", + " | array([ 0.6888893 , 0.78096262, -0.89086505, ..., 0.49876311, # random\n", + " | -0.38672696, -0.4685006 ]) # random\n", + " | >>> s.shape\n", + " | (8000,)\n", + " | >>> s = np.random.standard_normal(size=(3, 4, 2))\n", + " | >>> s.shape\n", + " | (3, 4, 2)\n", + " |\n", + " | Two-by-four array of samples from the normal distribution with\n", + " | mean 3 and standard deviation 2.5:\n", + " |\n", + " | >>> 3 + 2.5 * np.random.standard_normal(size=(2, 4))\n", + " | array([[-4.49401501, 4.00950034, -1.81814867, 7.29718677], # random\n", + " | [ 0.39924804, 4.68456316, 4.99394529, 4.84057254]]) # random\n", + " |\n", + " | standard_t(self, df, size=None)\n", + " | standard_t(df, size=None)\n", + " |\n", + " | Draw samples from a standard Student's t distribution with `df` degrees\n", + " | of freedom.\n", + " |\n", + " | A special case of the hyperbolic distribution. As `df` gets\n", + " | large, the result resembles that of the standard normal\n", + " | distribution (`standard_normal`).\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.standard_t`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | df : float or array_like of floats\n", + " | Degrees of freedom, must be > 0.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``df`` is a scalar. Otherwise,\n", + " | ``np.array(df).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized standard Student's t distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.standard_t: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density function for the t distribution is\n", + " |\n", + " | .. math:: P(x, df) = \\frac{\\Gamma(\\frac{df+1}{2})}{\\sqrt{\\pi df}\n", + " | \\Gamma(\\frac{df}{2})}\\Bigl( 1+\\frac{x^2}{df} \\Bigr)^{-(df+1)/2}\n", + " |\n", + " | The t test is based on an assumption that the data come from a\n", + " | Normal distribution. The t test provides a way to test whether\n", + " | the sample mean (that is the mean calculated from the data) is\n", + " | a good estimate of the true mean.\n", + " |\n", + " | The derivation of the t-distribution was first published in\n", + " | 1908 by William Gosset while working for the Guinness Brewery\n", + " | in Dublin. Due to proprietary issues, he had to publish under\n", + " | a pseudonym, and so he used the name Student.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Dalgaard, Peter, \"Introductory Statistics With R\",\n", + " | Springer, 2002.\n", + " | .. [2] Wikipedia, \"Student's t-distribution\"\n", + " | https://en.wikipedia.org/wiki/Student's_t-distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | From Dalgaard page 83 [1]_, suppose the daily energy intake for 11\n", + " | women in kilojoules (kJ) is:\n", + " |\n", + " | >>> intake = np.array([5260., 5470, 5640, 6180, 6390, 6515, 6805, 7515, \\\n", + " | ... 7515, 8230, 8770])\n", + " |\n", + " | Does their energy intake deviate systematically from the recommended\n", + " | value of 7725 kJ? Our null hypothesis will be the absence of deviation,\n", + " | and the alternate hypothesis will be the presence of an effect that could be\n", + " | either positive or negative, hence making our test 2-tailed.\n", + " |\n", + " | Because we are estimating the mean and we have N=11 values in our sample,\n", + " | we have N-1=10 degrees of freedom. We set our significance level to 95% and\n", + " | compute the t statistic using the empirical mean and empirical standard\n", + " | deviation of our intake. We use a ddof of 1 to base the computation of our\n", + " | empirical standard deviation on an unbiased estimate of the variance (note:\n", + " | the final estimate is not unbiased due to the concave nature of the square\n", + " | root).\n", + " |\n", + " | >>> np.mean(intake)\n", + " | 6753.636363636364\n", + " | >>> intake.std(ddof=1)\n", + " | 1142.1232221373727\n", + " | >>> t = (np.mean(intake)-7725)/(intake.std(ddof=1)/np.sqrt(len(intake)))\n", + " | >>> t\n", + " | -2.8207540608310198\n", + " |\n", + " | We draw 1000000 samples from Student's t distribution with the adequate\n", + " | degrees of freedom.\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> s = np.random.standard_t(10, size=1000000)\n", + " | >>> h = plt.hist(s, bins=100, density=True)\n", + " |\n", + " | Does our t statistic land in one of the two critical regions found at\n", + " | both tails of the distribution?\n", + " |\n", + " | >>> np.sum(np.abs(t) < np.abs(s)) / float(len(s))\n", + " | 0.018318 #random < 0.05, statistic is in critical region\n", + " |\n", + " | The probability value for this 2-tailed test is about 1.83%, which is\n", + " | lower than the 5% pre-determined significance threshold.\n", + " |\n", + " | Therefore, the probability of observing values as extreme as our intake\n", + " | conditionally on the null hypothesis being true is too low, and we reject\n", + " | the null hypothesis of no deviation.\n", + " |\n", + " | tomaxint(self, size=None)\n", + " | tomaxint(size=None)\n", + " |\n", + " | Return a sample of uniformly distributed random integers in the interval\n", + " | [0, ``np.iinfo(\"long\").max``].\n", + " |\n", + " | .. warning::\n", + " | This function uses the C-long dtype, which is 32bit on windows\n", + " | and otherwise 64bit on 64bit platforms (and 32bit on 32bit ones).\n", + " | Since NumPy 2.0, NumPy's default integer is 32bit on 32bit platforms\n", + " | and 64bit on 64bit platforms.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray\n", + " | Drawn samples, with shape `size`.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | randint : Uniform sampling over a given half-open interval of integers.\n", + " | random_integers : Uniform sampling over a given closed interval of\n", + " | integers.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | >>> rs = np.random.RandomState() # need a RandomState object\n", + " | >>> rs.tomaxint((2,2,2))\n", + " | array([[[1170048599, 1600360186], # random\n", + " | [ 739731006, 1947757578]],\n", + " | [[1871712945, 752307660],\n", + " | [1601631370, 1479324245]]])\n", + " | >>> rs.tomaxint((2,2,2)) < np.iinfo(np.int_).max\n", + " | array([[[ True, True],\n", + " | [ True, True]],\n", + " | [[ True, True],\n", + " | [ True, True]]])\n", + " |\n", + " | triangular(self, left, mode, right, size=None)\n", + " | triangular(left, mode, right, size=None)\n", + " |\n", + " | Draw samples from the triangular distribution over the\n", + " | interval ``[left, right]``.\n", + " |\n", + " | The triangular distribution is a continuous probability\n", + " | distribution with lower limit left, peak at mode, and upper\n", + " | limit right. Unlike the other distributions, these parameters\n", + " | directly define the shape of the pdf.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.triangular`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | left : float or array_like of floats\n", + " | Lower limit.\n", + " | mode : float or array_like of floats\n", + " | The value where the peak of the distribution occurs.\n", + " | The value must fulfill the condition ``left <= mode <= right``.\n", + " | right : float or array_like of floats\n", + " | Upper limit, must be larger than `left`.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``left``, ``mode``, and ``right``\n", + " | are all scalars. Otherwise, ``np.broadcast(left, mode, right).size``\n", + " | samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized triangular distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.triangular: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density function for the triangular distribution is\n", + " |\n", + " | .. math:: P(x;l, m, r) = \\begin{cases}\n", + " | \\frac{2(x-l)}{(r-l)(m-l)}& \\text{for $l \\leq x \\leq m$},\\\\\n", + " | \\frac{2(r-x)}{(r-l)(r-m)}& \\text{for $m \\leq x \\leq r$},\\\\\n", + " | 0& \\text{otherwise}.\n", + " | \\end{cases}\n", + " |\n", + " | The triangular distribution is often used in ill-defined\n", + " | problems where the underlying distribution is not known, but\n", + " | some knowledge of the limits and mode exists. Often it is used\n", + " | in simulations.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Wikipedia, \"Triangular distribution\"\n", + " | https://en.wikipedia.org/wiki/Triangular_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw values from the distribution and plot the histogram:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> h = plt.hist(np.random.triangular(-3, 0, 8, 100000), bins=200,\n", + " | ... density=True)\n", + " | >>> plt.show()\n", + " |\n", + " | uniform(self, low=0.0, high=1.0, size=None)\n", + " | uniform(low=0.0, high=1.0, size=None)\n", + " |\n", + " | Draw samples from a uniform distribution.\n", + " |\n", + " | Samples are uniformly distributed over the half-open interval\n", + " | ``[low, high)`` (includes low, but excludes high). In other words,\n", + " | any value within the given interval is equally likely to be drawn\n", + " | by `uniform`.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.uniform`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | low : float or array_like of floats, optional\n", + " | Lower boundary of the output interval. All values generated will be\n", + " | greater than or equal to low. The default value is 0.\n", + " | high : float or array_like of floats\n", + " | Upper boundary of the output interval. All values generated will be\n", + " | less than or equal to high. The high limit may be included in the\n", + " | returned array of floats due to floating-point rounding in the\n", + " | equation ``low + (high-low) * random_sample()``. The default value\n", + " | is 1.0.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``low`` and ``high`` are both scalars.\n", + " | Otherwise, ``np.broadcast(low, high).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized uniform distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | randint : Discrete uniform distribution, yielding integers.\n", + " | random_integers : Discrete uniform distribution over the closed\n", + " | interval ``[low, high]``.\n", + " | random_sample : Floats uniformly distributed over ``[0, 1)``.\n", + " | random : Alias for `random_sample`.\n", + " | rand : Convenience function that accepts dimensions as input, e.g.,\n", + " | ``rand(2,2)`` would generate a 2-by-2 array of floats,\n", + " | uniformly distributed over ``[0, 1)``.\n", + " | random.Generator.uniform: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density function of the uniform distribution is\n", + " |\n", + " | .. math:: p(x) = \\frac{1}{b - a}\n", + " |\n", + " | anywhere within the interval ``[a, b)``, and zero elsewhere.\n", + " |\n", + " | When ``high`` == ``low``, values of ``low`` will be returned.\n", + " | If ``high`` < ``low``, the results are officially undefined\n", + " | and may eventually raise an error, i.e. do not rely on this\n", + " | function to behave when passed arguments satisfying that\n", + " | inequality condition. The ``high`` limit may be included in the\n", + " | returned array of floats due to floating-point rounding in the\n", + " | equation ``low + (high-low) * random_sample()``. For example:\n", + " |\n", + " | >>> x = np.float32(5*0.99999999)\n", + " | >>> x\n", + " | np.float32(5.0)\n", + " |\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> s = np.random.uniform(-1,0,1000)\n", + " |\n", + " | All values are within the given interval:\n", + " |\n", + " | >>> np.all(s >= -1)\n", + " | True\n", + " | >>> np.all(s < 0)\n", + " | True\n", + " |\n", + " | Display the histogram of the samples, along with the\n", + " | probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> count, bins, ignored = plt.hist(s, 15, density=True)\n", + " | >>> plt.plot(bins, np.ones_like(bins), linewidth=2, color='r')\n", + " | >>> plt.show()\n", + " |\n", + " | vonmises(self, mu, kappa, size=None)\n", + " | vonmises(mu, kappa, size=None)\n", + " |\n", + " | Draw samples from a von Mises distribution.\n", + " |\n", + " | Samples are drawn from a von Mises distribution with specified mode\n", + " | (mu) and concentration (kappa), on the interval [-pi, pi].\n", + " |\n", + " | The von Mises distribution (also known as the circular normal\n", + " | distribution) is a continuous probability distribution on the unit\n", + " | circle. It may be thought of as the circular analogue of the normal\n", + " | distribution.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.vonmises`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | mu : float or array_like of floats\n", + " | Mode (\"center\") of the distribution.\n", + " | kappa : float or array_like of floats\n", + " | Concentration of the distribution, has to be >=0.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``mu`` and ``kappa`` are both scalars.\n", + " | Otherwise, ``np.broadcast(mu, kappa).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized von Mises distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.vonmises : probability density function, distribution, or\n", + " | cumulative density function, etc.\n", + " | random.Generator.vonmises: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density for the von Mises distribution is\n", + " |\n", + " | .. math:: p(x) = \\frac{e^{\\kappa cos(x-\\mu)}}{2\\pi I_0(\\kappa)},\n", + " |\n", + " | where :math:`\\mu` is the mode and :math:`\\kappa` the concentration,\n", + " | and :math:`I_0(\\kappa)` is the modified Bessel function of order 0.\n", + " |\n", + " | The von Mises is named for Richard Edler von Mises, who was born in\n", + " | Austria-Hungary, in what is now the Ukraine. He fled to the United\n", + " | States in 1939 and became a professor at Harvard. He worked in\n", + " | probability theory, aerodynamics, fluid mechanics, and philosophy of\n", + " | science.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Abramowitz, M. and Stegun, I. A. (Eds.). \"Handbook of\n", + " | Mathematical Functions with Formulas, Graphs, and Mathematical\n", + " | Tables, 9th printing,\" New York: Dover, 1972.\n", + " | .. [2] von Mises, R., \"Mathematical Theory of Probability\n", + " | and Statistics\", New York: Academic Press, 1964.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> mu, kappa = 0.0, 4.0 # mean and concentration\n", + " | >>> s = np.random.vonmises(mu, kappa, 1000)\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> from scipy.special import i0 # doctest: +SKIP\n", + " | >>> plt.hist(s, 50, density=True)\n", + " | >>> x = np.linspace(-np.pi, np.pi, num=51)\n", + " | >>> y = np.exp(kappa*np.cos(x-mu))/(2*np.pi*i0(kappa)) # doctest: +SKIP\n", + " | >>> plt.plot(x, y, linewidth=2, color='r') # doctest: +SKIP\n", + " | >>> plt.show()\n", + " |\n", + " | wald(self, mean, scale, size=None)\n", + " | wald(mean, scale, size=None)\n", + " |\n", + " | Draw samples from a Wald, or inverse Gaussian, distribution.\n", + " |\n", + " | As the scale approaches infinity, the distribution becomes more like a\n", + " | Gaussian. Some references claim that the Wald is an inverse Gaussian\n", + " | with mean equal to 1, but this is by no means universal.\n", + " |\n", + " | The inverse Gaussian distribution was first studied in relationship to\n", + " | Brownian motion. In 1956 M.C.K. Tweedie used the name inverse Gaussian\n", + " | because there is an inverse relationship between the time to cover a\n", + " | unit distance and distance covered in unit time.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.wald`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | mean : float or array_like of floats\n", + " | Distribution mean, must be > 0.\n", + " | scale : float or array_like of floats\n", + " | Scale parameter, must be > 0.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``mean`` and ``scale`` are both scalars.\n", + " | Otherwise, ``np.broadcast(mean, scale).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized Wald distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.wald: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability density function for the Wald distribution is\n", + " |\n", + " | .. math:: P(x;mean,scale) = \\sqrt{\\frac{scale}{2\\pi x^3}}e^\n", + " | \\frac{-scale(x-mean)^2}{2\\cdotp mean^2x}\n", + " |\n", + " | As noted above the inverse Gaussian distribution first arise\n", + " | from attempts to model Brownian motion. It is also a\n", + " | competitor to the Weibull for use in reliability modeling and\n", + " | modeling stock returns and interest rate processes.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Brighton Webs Ltd., Wald Distribution,\n", + " | https://web.archive.org/web/20090423014010/http://www.brighton-webs.co.uk:80/distributions/wald.asp\n", + " | .. [2] Chhikara, Raj S., and Folks, J. Leroy, \"The Inverse Gaussian\n", + " | Distribution: Theory : Methodology, and Applications\", CRC Press,\n", + " | 1988.\n", + " | .. [3] Wikipedia, \"Inverse Gaussian distribution\"\n", + " | https://en.wikipedia.org/wiki/Inverse_Gaussian_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw values from the distribution and plot the histogram:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> h = plt.hist(np.random.wald(3, 2, 100000), bins=200, density=True)\n", + " | >>> plt.show()\n", + " |\n", + " | weibull(self, a, size=None)\n", + " | weibull(a, size=None)\n", + " |\n", + " | Draw samples from a Weibull distribution.\n", + " |\n", + " | Draw samples from a 1-parameter Weibull distribution with the given\n", + " | shape parameter `a`.\n", + " |\n", + " | .. math:: X = (-ln(U))^{1/a}\n", + " |\n", + " | Here, U is drawn from the uniform distribution over (0,1].\n", + " |\n", + " | The more common 2-parameter Weibull, including a scale parameter\n", + " | :math:`\\lambda` is just :math:`X = \\lambda(-ln(U))^{1/a}`.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.weibull`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | a : float or array_like of floats\n", + " | Shape parameter of the distribution. Must be nonnegative.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``a`` is a scalar. Otherwise,\n", + " | ``np.array(a).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized Weibull distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.weibull_max\n", + " | scipy.stats.weibull_min\n", + " | scipy.stats.genextreme\n", + " | gumbel\n", + " | random.Generator.weibull: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The Weibull (or Type III asymptotic extreme value distribution\n", + " | for smallest values, SEV Type III, or Rosin-Rammler\n", + " | distribution) is one of a class of Generalized Extreme Value\n", + " | (GEV) distributions used in modeling extreme value problems.\n", + " | This class includes the Gumbel and Frechet distributions.\n", + " |\n", + " | The probability density for the Weibull distribution is\n", + " |\n", + " | .. math:: p(x) = \\frac{a}\n", + " | {\\lambda}(\\frac{x}{\\lambda})^{a-1}e^{-(x/\\lambda)^a},\n", + " |\n", + " | where :math:`a` is the shape and :math:`\\lambda` the scale.\n", + " |\n", + " | The function has its peak (the mode) at\n", + " | :math:`\\lambda(\\frac{a-1}{a})^{1/a}`.\n", + " |\n", + " | When ``a = 1``, the Weibull distribution reduces to the exponential\n", + " | distribution.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Waloddi Weibull, Royal Technical University, Stockholm,\n", + " | 1939 \"A Statistical Theory Of The Strength Of Materials\",\n", + " | Ingeniorsvetenskapsakademiens Handlingar Nr 151, 1939,\n", + " | Generalstabens Litografiska Anstalts Forlag, Stockholm.\n", + " | .. [2] Waloddi Weibull, \"A Statistical Distribution Function of\n", + " | Wide Applicability\", Journal Of Applied Mechanics ASME Paper\n", + " | 1951.\n", + " | .. [3] Wikipedia, \"Weibull distribution\",\n", + " | https://en.wikipedia.org/wiki/Weibull_distribution\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> a = 5. # shape\n", + " | >>> s = np.random.weibull(a, 1000)\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the probability density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> x = np.arange(1,100.)/50.\n", + " | >>> def weib(x,n,a):\n", + " | ... return (a / n) * (x / n)**(a - 1) * np.exp(-(x / n)**a)\n", + " |\n", + " | >>> count, bins, ignored = plt.hist(np.random.weibull(5.,1000))\n", + " | >>> x = np.arange(1,100.)/50.\n", + " | >>> scale = count.max()/weib(x, 1., 5.).max()\n", + " | >>> plt.plot(x, weib(x, 1., 5.)*scale)\n", + " | >>> plt.show()\n", + " |\n", + " | zipf(self, a, size=None)\n", + " | zipf(a, size=None)\n", + " |\n", + " | Draw samples from a Zipf distribution.\n", + " |\n", + " | Samples are drawn from a Zipf distribution with specified parameter\n", + " | `a` > 1.\n", + " |\n", + " | The Zipf distribution (also known as the zeta distribution) is a\n", + " | discrete probability distribution that satisfies Zipf's law: the\n", + " | frequency of an item is inversely proportional to its rank in a\n", + " | frequency table.\n", + " |\n", + " | .. note::\n", + " | New code should use the `~numpy.random.Generator.zipf`\n", + " | method of a `~numpy.random.Generator` instance instead;\n", + " | please see the :ref:`random-quick-start`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | a : float or array_like of floats\n", + " | Distribution parameter. Must be greater than 1.\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " | a single value is returned if ``a`` is a scalar. Otherwise,\n", + " | ``np.array(a).size`` samples are drawn.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : ndarray or scalar\n", + " | Drawn samples from the parameterized Zipf distribution.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | scipy.stats.zipf : probability density function, distribution, or\n", + " | cumulative density function, etc.\n", + " | random.Generator.zipf: which should be used for new code.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | The probability mass function (PMF) for the Zipf distribution is\n", + " |\n", + " | .. math:: p(k) = \\frac{k^{-a}}{\\zeta(a)},\n", + " |\n", + " | for integers :math:`k \\geq 1`, where :math:`\\zeta` is the Riemann Zeta\n", + " | function.\n", + " |\n", + " | It is named for the American linguist George Kingsley Zipf, who noted\n", + " | that the frequency of any word in a sample of a language is inversely\n", + " | proportional to its rank in the frequency table.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] Zipf, G. K., \"Selected Studies of the Principle of Relative\n", + " | Frequency in Language,\" Cambridge, MA: Harvard Univ. Press,\n", + " | 1932.\n", + " |\n", + " | Examples\n", + " | --------\n", + " | Draw samples from the distribution:\n", + " |\n", + " | >>> a = 4.0\n", + " | >>> n = 20000\n", + " | >>> s = np.random.zipf(a, n)\n", + " |\n", + " | Display the histogram of the samples, along with\n", + " | the expected histogram based on the probability\n", + " | density function:\n", + " |\n", + " | >>> import matplotlib.pyplot as plt\n", + " | >>> from scipy.special import zeta # doctest: +SKIP\n", + " |\n", + " | `bincount` provides a fast histogram for small integers.\n", + " |\n", + " | >>> count = np.bincount(s)\n", + " | >>> k = np.arange(1, s.max() + 1)\n", + " |\n", + " | >>> plt.bar(k, count[1:], alpha=0.5, label='sample count')\n", + " | >>> plt.plot(k, n*(k**-a)/zeta(a), 'k.-', alpha=0.5,\n", + " | ... label='expected count') # doctest: +SKIP\n", + " | >>> plt.semilogy()\n", + " | >>> plt.grid(alpha=0.4)\n", + " | >>> plt.legend()\n", + " | >>> plt.title(f'Zipf sample, a={a}, size={n}')\n", + " | >>> plt.show()\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Static methods defined here:\n", + " |\n", + " | __new__(*args, **kwargs)\n", + " | Create and return a new object. See help(type) for accurate signature.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data and other attributes defined here:\n", + " |\n", + " | __pyx_vtable__ = \n", + "\n", + " class SFC64(numpy.random.bit_generator.BitGenerator)\n", + " | SFC64(seed=None)\n", + " |\n", + " | BitGenerator for Chris Doty-Humphrey's Small Fast Chaotic PRNG.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | seed : {None, int, array_like[ints], SeedSequence}, optional\n", + " | A seed to initialize the `BitGenerator`. If None, then fresh,\n", + " | unpredictable entropy will be pulled from the OS. If an ``int`` or\n", + " | ``array_like[ints]`` is passed, then it will be passed to\n", + " | `SeedSequence` to derive the initial `BitGenerator` state. One may also\n", + " | pass in a `SeedSequence` instance.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | `SFC64` is a 256-bit implementation of Chris Doty-Humphrey's Small Fast\n", + " | Chaotic PRNG ([1]_). `SFC64` has a few different cycles that one might be\n", + " | on, depending on the seed; the expected period will be about\n", + " | :math:`2^{255}` ([2]_). `SFC64` incorporates a 64-bit counter which means\n", + " | that the absolute minimum cycle length is :math:`2^{64}` and that distinct\n", + " | seeds will not run into each other for at least :math:`2^{64}` iterations.\n", + " |\n", + " | `SFC64` provides a capsule containing function pointers that produce\n", + " | doubles, and unsigned 32 and 64- bit integers. These are not\n", + " | directly consumable in Python and must be consumed by a `Generator`\n", + " | or similar object that supports low-level access.\n", + " |\n", + " | **State and Seeding**\n", + " |\n", + " | The `SFC64` state vector consists of 4 unsigned 64-bit values. The last\n", + " | is a 64-bit counter that increments by 1 each iteration.\n", + " |\n", + " | The input seed is processed by `SeedSequence` to generate the first\n", + " | 3 values, then the `SFC64` algorithm is iterated a small number of times\n", + " | to mix.\n", + " |\n", + " | **Compatibility Guarantee**\n", + " |\n", + " | `SFC64` makes a guarantee that a fixed seed will always produce the same\n", + " | random integer stream.\n", + " |\n", + " | References\n", + " | ----------\n", + " | .. [1] `\"PractRand\"\n", + " | `_\n", + " | .. [2] `\"Random Invertible Mapping Statistics\"\n", + " | `_\n", + " |\n", + " | Method resolution order:\n", + " | SFC64\n", + " | numpy.random.bit_generator.BitGenerator\n", + " | builtins.object\n", + " |\n", + " | Methods defined here:\n", + " |\n", + " | __init__(self, /, *args, **kwargs)\n", + " | Initialize self. See help(type(self)) for accurate signature.\n", + " |\n", + " | __reduce_cython__(...)\n", + " |\n", + " | __setstate_cython__(...)\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Static methods defined here:\n", + " |\n", + " | __new__(*args, **kwargs)\n", + " | Create and return a new object. See help(type) for accurate signature.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors defined here:\n", + " |\n", + " | state\n", + " | Get or set the PRNG state\n", + " |\n", + " | Returns\n", + " | -------\n", + " | state : dict\n", + " | Dictionary containing the information required to describe the\n", + " | state of the PRNG\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data and other attributes defined here:\n", + " |\n", + " | __pyx_vtable__ = \n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Methods inherited from numpy.random.bit_generator.BitGenerator:\n", + " |\n", + " | __getstate__(self)\n", + " |\n", + " | __reduce__(self)\n", + " |\n", + " | __setstate__(self, state_seed_seq)\n", + " |\n", + " | random_raw(self, size=None, output=True)\n", + " | random_raw(self, size=None)\n", + " |\n", + " | Return randoms as generated by the underlying BitGenerator\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | size : int or tuple of ints, optional\n", + " | Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " | ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " | single value is returned.\n", + " | output : bool, optional\n", + " | Output values. Used for performance testing since the generated\n", + " | values are not returned.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | out : uint or ndarray\n", + " | Drawn samples.\n", + " |\n", + " | Notes\n", + " | -----\n", + " | This method directly exposes the raw underlying pseudo-random\n", + " | number generator. All values are returned as unsigned 64-bit\n", + " | values irrespective of the number of bits produced by the PRNG.\n", + " |\n", + " | See the class docstring for the number of bits returned.\n", + " |\n", + " | spawn(self, n_children)\n", + " | spawn(n_children)\n", + " |\n", + " | Create new independent child bit generators.\n", + " |\n", + " | See :ref:`seedsequence-spawn` for additional notes on spawning\n", + " | children. Some bit generators also implement ``jumped``\n", + " | as a different approach for creating independent streams.\n", + " |\n", + " | .. versionadded:: 1.25.0\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | n_children : int\n", + " |\n", + " | Returns\n", + " | -------\n", + " | child_bit_generators : list of BitGenerators\n", + " |\n", + " | Raises\n", + " | ------\n", + " | TypeError\n", + " | When the underlying SeedSequence does not implement spawning.\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.spawn, random.SeedSequence.spawn :\n", + " | Equivalent method on the generator and seed sequence.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors inherited from numpy.random.bit_generator.BitGenerator:\n", + " |\n", + " | capsule\n", + " |\n", + " | cffi\n", + " | CFFI interface\n", + " |\n", + " | Returns\n", + " | -------\n", + " | interface : namedtuple\n", + " | Named tuple containing CFFI wrapper\n", + " |\n", + " | * state_address - Memory address of the state struct\n", + " | * state - pointer to the state struct\n", + " | * next_uint64 - function pointer to produce 64 bit integers\n", + " | * next_uint32 - function pointer to produce 32 bit integers\n", + " | * next_double - function pointer to produce doubles\n", + " | * bitgen - pointer to the bit generator struct\n", + " |\n", + " | ctypes\n", + " | ctypes interface\n", + " |\n", + " | Returns\n", + " | -------\n", + " | interface : namedtuple\n", + " | Named tuple containing ctypes wrapper\n", + " |\n", + " | * state_address - Memory address of the state struct\n", + " | * state - pointer to the state struct\n", + " | * next_uint64 - function pointer to produce 64 bit integers\n", + " | * next_uint32 - function pointer to produce 32 bit integers\n", + " | * next_double - function pointer to produce doubles\n", + " | * bitgen - pointer to the bit generator struct\n", + " |\n", + " | lock\n", + " |\n", + " | seed_seq\n", + " | Get the seed sequence used to initialize the bit generator.\n", + " |\n", + " | .. versionadded:: 1.25.0\n", + " |\n", + " | Returns\n", + " | -------\n", + " | seed_seq : ISeedSequence\n", + " | The SeedSequence object used to initialize the BitGenerator.\n", + " | This is normally a `np.random.SeedSequence` instance.\n", + "\n", + " class SeedSequence(builtins.object)\n", + " | SeedSequence(entropy=None, *, spawn_key=(), pool_size=4)\n", + " |\n", + " | SeedSequence mixes sources of entropy in a reproducible way to set the\n", + " | initial state for independent and very probably non-overlapping\n", + " | BitGenerators.\n", + " |\n", + " | Once the SeedSequence is instantiated, you can call the `generate_state`\n", + " | method to get an appropriately sized seed. Calling `spawn(n) ` will\n", + " | create ``n`` SeedSequences that can be used to seed independent\n", + " | BitGenerators, i.e. for different threads.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | entropy : {None, int, sequence[int]}, optional\n", + " | The entropy for creating a `SeedSequence`.\n", + " | All integer values must be non-negative.\n", + " | spawn_key : {(), sequence[int]}, optional\n", + " | An additional source of entropy based on the position of this\n", + " | `SeedSequence` in the tree of such objects created with the\n", + " | `SeedSequence.spawn` method. Typically, only `SeedSequence.spawn` will\n", + " | set this, and users will not.\n", + " | pool_size : {int}, optional\n", + " | Size of the pooled entropy to store. Default is 4 to give a 128-bit\n", + " | entropy pool. 8 (for 256 bits) is another reasonable choice if working\n", + " | with larger PRNGs, but there is very little to be gained by selecting\n", + " | another value.\n", + " | n_children_spawned : {int}, optional\n", + " | The number of children already spawned. Only pass this if\n", + " | reconstructing a `SeedSequence` from a serialized form.\n", + " |\n", + " | Notes\n", + " | -----\n", + " |\n", + " | Best practice for achieving reproducible bit streams is to use\n", + " | the default ``None`` for the initial entropy, and then use\n", + " | `SeedSequence.entropy` to log/pickle the `entropy` for reproducibility:\n", + " |\n", + " | >>> sq1 = np.random.SeedSequence()\n", + " | >>> sq1.entropy\n", + " | 243799254704924441050048792905230269161 # random\n", + " | >>> sq2 = np.random.SeedSequence(sq1.entropy)\n", + " | >>> np.all(sq1.generate_state(10) == sq2.generate_state(10))\n", + " | True\n", + " |\n", + " | Methods defined here:\n", + " |\n", + " | __init__(self, /, *args, **kwargs)\n", + " | Initialize self. See help(type(self)) for accurate signature.\n", + " |\n", + " | __reduce__ = __reduce_cython__(...)\n", + " |\n", + " | __reduce_cython__(self)\n", + " |\n", + " | __repr__(...)\n", + " | Return repr(self).\n", + " |\n", + " | __setstate__ = __setstate_cython__(...)\n", + " |\n", + " | __setstate_cython__(self, __pyx_state)\n", + " |\n", + " | generate_state(self, n_words, dtype=)\n", + " | generate_state(n_words, dtype=np.uint32)\n", + " |\n", + " | Return the requested number of words for PRNG seeding.\n", + " |\n", + " | A BitGenerator should call this method in its constructor with\n", + " | an appropriate `n_words` parameter to properly seed itself.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | n_words : int\n", + " | dtype : np.uint32 or np.uint64, optional\n", + " | The size of each word. This should only be either `uint32` or\n", + " | `uint64`. Strings (`'uint32'`, `'uint64'`) are fine. Note that\n", + " | requesting `uint64` will draw twice as many bits as `uint32` for\n", + " | the same `n_words`. This is a convenience for `BitGenerator`\\ s\n", + " | that express their states as `uint64` arrays.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | state : uint32 or uint64 array, shape=(n_words,)\n", + " |\n", + " | spawn(self, n_children)\n", + " | spawn(n_children)\n", + " |\n", + " | Spawn a number of child `SeedSequence` s by extending the\n", + " | `spawn_key`.\n", + " |\n", + " | See :ref:`seedsequence-spawn` for additional notes on spawning\n", + " | children.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | n_children : int\n", + " |\n", + " | Returns\n", + " | -------\n", + " | seqs : list of `SeedSequence` s\n", + " |\n", + " | See Also\n", + " | --------\n", + " | random.Generator.spawn, random.BitGenerator.spawn :\n", + " | Equivalent method on the generator and bit generator.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Static methods defined here:\n", + " |\n", + " | __new__(*args, **kwargs)\n", + " | Create and return a new object. See help(type) for accurate signature.\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors defined here:\n", + " |\n", + " | entropy\n", + " |\n", + " | n_children_spawned\n", + " |\n", + " | pool\n", + " |\n", + " | pool_size\n", + " |\n", + " | spawn_key\n", + " |\n", + " | state\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data and other attributes defined here:\n", + " |\n", + " | __pyx_vtable__ = \n", + "\n", + "FUNCTIONS\n", + " beta(a, b, size=None) method of numpy.random.mtrand.RandomState instance\n", + " beta(a, b, size=None)\n", + "\n", + " Draw samples from a Beta distribution.\n", + "\n", + " The Beta distribution is a special case of the Dirichlet distribution,\n", + " and is related to the Gamma distribution. It has the probability\n", + " distribution function\n", + "\n", + " .. math:: f(x; a,b) = \\frac{1}{B(\\alpha, \\beta)} x^{\\alpha - 1}\n", + " (1 - x)^{\\beta - 1},\n", + "\n", + " where the normalization, B, is the beta function,\n", + "\n", + " .. math:: B(\\alpha, \\beta) = \\int_0^1 t^{\\alpha - 1}\n", + " (1 - t)^{\\beta - 1} dt.\n", + "\n", + " It is often seen in Bayesian inference and order statistics.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.beta`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + "\n", + " Parameters\n", + " ----------\n", + " a : float or array_like of floats\n", + " Alpha, positive (>0).\n", + " b : float or array_like of floats\n", + " Beta, positive (>0).\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``a`` and ``b`` are both scalars.\n", + " Otherwise, ``np.broadcast(a, b).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized beta distribution.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.beta: which should be used for new code.\n", + "\n", + " binomial(n, p, size=None) method of numpy.random.mtrand.RandomState instance\n", + " binomial(n, p, size=None)\n", + "\n", + " Draw samples from a binomial distribution.\n", + "\n", + " Samples are drawn from a binomial distribution with specified\n", + " parameters, n trials and p probability of success where\n", + " n an integer >= 0 and p is in the interval [0,1]. (n may be\n", + " input as a float, but it is truncated to an integer in use)\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.binomial`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " n : int or array_like of ints\n", + " Parameter of the distribution, >= 0. Floats are also accepted,\n", + " but they will be truncated to integers.\n", + " p : float or array_like of floats\n", + " Parameter of the distribution, >= 0 and <=1.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``n`` and ``p`` are both scalars.\n", + " Otherwise, ``np.broadcast(n, p).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized binomial distribution, where\n", + " each sample is equal to the number of successes over the n trials.\n", + "\n", + " See Also\n", + " --------\n", + " scipy.stats.binom : probability density function, distribution or\n", + " cumulative density function, etc.\n", + " random.Generator.binomial: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability mass function (PMF) for the binomial distribution is\n", + "\n", + " .. math:: P(N) = \\binom{n}{N}p^N(1-p)^{n-N},\n", + "\n", + " where :math:`n` is the number of trials, :math:`p` is the probability\n", + " of success, and :math:`N` is the number of successes.\n", + "\n", + " When estimating the standard error of a proportion in a population by\n", + " using a random sample, the normal distribution works well unless the\n", + " product p*n <=5, where p = population proportion estimate, and n =\n", + " number of samples, in which case the binomial distribution is used\n", + " instead. For example, a sample of 15 people shows 4 who are left\n", + " handed, and 11 who are right handed. Then p = 4/15 = 27%. 0.27*15 = 4,\n", + " so the binomial distribution should be used in this case.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Dalgaard, Peter, \"Introductory Statistics with R\",\n", + " Springer-Verlag, 2002.\n", + " .. [2] Glantz, Stanton A. \"Primer of Biostatistics.\", McGraw-Hill,\n", + " Fifth Edition, 2002.\n", + " .. [3] Lentner, Marvin, \"Elementary Applied Statistics\", Bogden\n", + " and Quigley, 1972.\n", + " .. [4] Weisstein, Eric W. \"Binomial Distribution.\" From MathWorld--A\n", + " Wolfram Web Resource.\n", + " https://mathworld.wolfram.com/BinomialDistribution.html\n", + " .. [5] Wikipedia, \"Binomial distribution\",\n", + " https://en.wikipedia.org/wiki/Binomial_distribution\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples from the distribution:\n", + "\n", + " >>> n, p = 10, .5 # number of trials, probability of each trial\n", + " >>> s = np.random.binomial(n, p, 1000)\n", + " # result of flipping a coin 10 times, tested 1000 times.\n", + "\n", + " A real world example. A company drills 9 wild-cat oil exploration\n", + " wells, each with an estimated probability of success of 0.1. All nine\n", + " wells fail. What is the probability of that happening?\n", + "\n", + " Let's do 20,000 trials of the model, and count the number that\n", + " generate zero positive results.\n", + "\n", + " >>> sum(np.random.binomial(9, 0.1, 20000) == 0)/20000.\n", + " # answer = 0.38885, or 38%.\n", + "\n", + " bytes(length) method of numpy.random.mtrand.RandomState instance\n", + " bytes(length)\n", + "\n", + " Return random bytes.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.bytes`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " length : int\n", + " Number of random bytes.\n", + "\n", + " Returns\n", + " -------\n", + " out : bytes\n", + " String of length `length`.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.bytes: which should be used for new code.\n", + "\n", + " Examples\n", + " --------\n", + " >>> np.random.bytes(10)\n", + " b' eh\\x85\\x022SZ\\xbf\\xa4' #random\n", + "\n", + " chisquare(df, size=None) method of numpy.random.mtrand.RandomState instance\n", + " chisquare(df, size=None)\n", + "\n", + " Draw samples from a chi-square distribution.\n", + "\n", + " When `df` independent random variables, each with standard normal\n", + " distributions (mean 0, variance 1), are squared and summed, the\n", + " resulting distribution is chi-square (see Notes). This distribution\n", + " is often used in hypothesis testing.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.chisquare`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " df : float or array_like of floats\n", + " Number of degrees of freedom, must be > 0.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``df`` is a scalar. Otherwise,\n", + " ``np.array(df).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized chi-square distribution.\n", + "\n", + " Raises\n", + " ------\n", + " ValueError\n", + " When `df` <= 0 or when an inappropriate `size` (e.g. ``size=-1``)\n", + " is given.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.chisquare: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The variable obtained by summing the squares of `df` independent,\n", + " standard normally distributed random variables:\n", + "\n", + " .. math:: Q = \\sum_{i=1}^{\\mathtt{df}} X^2_i\n", + "\n", + " is chi-square distributed, denoted\n", + "\n", + " .. math:: Q \\sim \\chi^2_k.\n", + "\n", + " The probability density function of the chi-squared distribution is\n", + "\n", + " .. math:: p(x) = \\frac{(1/2)^{k/2}}{\\Gamma(k/2)}\n", + " x^{k/2 - 1} e^{-x/2},\n", + "\n", + " where :math:`\\Gamma` is the gamma function,\n", + "\n", + " .. math:: \\Gamma(x) = \\int_0^{-\\infty} t^{x - 1} e^{-t} dt.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] NIST \"Engineering Statistics Handbook\"\n", + " https://www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm\n", + "\n", + " Examples\n", + " --------\n", + " >>> np.random.chisquare(2,4)\n", + " array([ 1.89920014, 9.00867716, 3.13710533, 5.62318272]) # random\n", + "\n", + " choice(a, size=None, replace=True, p=None) method of numpy.random.mtrand.RandomState instance\n", + " choice(a, size=None, replace=True, p=None)\n", + "\n", + " Generates a random sample from a given 1-D array\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.choice`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " .. warning::\n", + " This function uses the C-long dtype, which is 32bit on windows\n", + " and otherwise 64bit on 64bit platforms (and 32bit on 32bit ones).\n", + " Since NumPy 2.0, NumPy's default integer is 32bit on 32bit platforms\n", + " and 64bit on 64bit platforms.\n", + "\n", + "\n", + " Parameters\n", + " ----------\n", + " a : 1-D array-like or int\n", + " If an ndarray, a random sample is generated from its elements.\n", + " If an int, the random sample is generated as if it were ``np.arange(a)``\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " single value is returned.\n", + " replace : boolean, optional\n", + " Whether the sample is with or without replacement. Default is True,\n", + " meaning that a value of ``a`` can be selected multiple times.\n", + " p : 1-D array-like, optional\n", + " The probabilities associated with each entry in a.\n", + " If not given, the sample assumes a uniform distribution over all\n", + " entries in ``a``.\n", + "\n", + " Returns\n", + " -------\n", + " samples : single item or ndarray\n", + " The generated random samples\n", + "\n", + " Raises\n", + " ------\n", + " ValueError\n", + " If a is an int and less than zero, if a or p are not 1-dimensional,\n", + " if a is an array-like of size 0, if p is not a vector of\n", + " probabilities, if a and p have different lengths, or if\n", + " replace=False and the sample size is greater than the population\n", + " size\n", + "\n", + " See Also\n", + " --------\n", + " randint, shuffle, permutation\n", + " random.Generator.choice: which should be used in new code\n", + "\n", + " Notes\n", + " -----\n", + " Setting user-specified probabilities through ``p`` uses a more general but less\n", + " efficient sampler than the default. The general sampler produces a different sample\n", + " than the optimized sampler even if each element of ``p`` is 1 / len(a).\n", + "\n", + " Sampling random rows from a 2-D array is not possible with this function,\n", + " but is possible with `Generator.choice` through its ``axis`` keyword.\n", + "\n", + " Examples\n", + " --------\n", + " Generate a uniform random sample from np.arange(5) of size 3:\n", + "\n", + " >>> np.random.choice(5, 3)\n", + " array([0, 3, 4]) # random\n", + " >>> #This is equivalent to np.random.randint(0,5,3)\n", + "\n", + " Generate a non-uniform random sample from np.arange(5) of size 3:\n", + "\n", + " >>> np.random.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0])\n", + " array([3, 3, 0]) # random\n", + "\n", + " Generate a uniform random sample from np.arange(5) of size 3 without\n", + " replacement:\n", + "\n", + " >>> np.random.choice(5, 3, replace=False)\n", + " array([3,1,0]) # random\n", + " >>> #This is equivalent to np.random.permutation(np.arange(5))[:3]\n", + "\n", + " Generate a non-uniform random sample from np.arange(5) of size\n", + " 3 without replacement:\n", + "\n", + " >>> np.random.choice(5, 3, replace=False, p=[0.1, 0, 0.3, 0.6, 0])\n", + " array([2, 3, 0]) # random\n", + "\n", + " Any of the above can be repeated with an arbitrary array-like\n", + " instead of just integers. For instance:\n", + "\n", + " >>> aa_milne_arr = ['pooh', 'rabbit', 'piglet', 'Christopher']\n", + " >>> np.random.choice(aa_milne_arr, 5, p=[0.5, 0.1, 0.1, 0.3])\n", + " array(['pooh', 'pooh', 'pooh', 'Christopher', 'piglet'], # random\n", + " dtype='>> import numpy as np\n", + " >>> rng = np.random.default_rng(12345)\n", + " >>> print(rng)\n", + " Generator(PCG64)\n", + " >>> rfloat = rng.random()\n", + " >>> rfloat\n", + " 0.22733602246716966\n", + " >>> type(rfloat)\n", + " \n", + "\n", + " Here we use `default_rng` to generate 3 random integers between 0\n", + " (inclusive) and 10 (exclusive):\n", + "\n", + " >>> import numpy as np\n", + " >>> rng = np.random.default_rng(12345)\n", + " >>> rints = rng.integers(low=0, high=10, size=3)\n", + " >>> rints\n", + " array([6, 2, 7])\n", + " >>> type(rints[0])\n", + " \n", + "\n", + " Here we specify a seed so that we have reproducible results:\n", + "\n", + " >>> import numpy as np\n", + " >>> rng = np.random.default_rng(seed=42)\n", + " >>> print(rng)\n", + " Generator(PCG64)\n", + " >>> arr1 = rng.random((3, 3))\n", + " >>> arr1\n", + " array([[0.77395605, 0.43887844, 0.85859792],\n", + " [0.69736803, 0.09417735, 0.97562235],\n", + " [0.7611397 , 0.78606431, 0.12811363]])\n", + "\n", + " If we exit and restart our Python interpreter, we'll see that we\n", + " generate the same random numbers again:\n", + "\n", + " >>> import numpy as np\n", + " >>> rng = np.random.default_rng(seed=42)\n", + " >>> arr2 = rng.random((3, 3))\n", + " >>> arr2\n", + " array([[0.77395605, 0.43887844, 0.85859792],\n", + " [0.69736803, 0.09417735, 0.97562235],\n", + " [0.7611397 , 0.78606431, 0.12811363]])\n", + "\n", + " dirichlet(alpha, size=None) method of numpy.random.mtrand.RandomState instance\n", + " dirichlet(alpha, size=None)\n", + "\n", + " Draw samples from the Dirichlet distribution.\n", + "\n", + " Draw `size` samples of dimension k from a Dirichlet distribution. A\n", + " Dirichlet-distributed random variable can be seen as a multivariate\n", + " generalization of a Beta distribution. The Dirichlet distribution\n", + " is a conjugate prior of a multinomial distribution in Bayesian\n", + " inference.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.dirichlet`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " alpha : sequence of floats, length k\n", + " Parameter of the distribution (length ``k`` for sample of\n", + " length ``k``).\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n)``, then\n", + " ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " vector of length ``k`` is returned.\n", + "\n", + " Returns\n", + " -------\n", + " samples : ndarray,\n", + " The drawn samples, of shape ``(size, k)``.\n", + "\n", + " Raises\n", + " ------\n", + " ValueError\n", + " If any value in ``alpha`` is less than or equal to zero\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.dirichlet: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The Dirichlet distribution is a distribution over vectors\n", + " :math:`x` that fulfil the conditions :math:`x_i>0` and\n", + " :math:`\\sum_{i=1}^k x_i = 1`.\n", + "\n", + " The probability density function :math:`p` of a\n", + " Dirichlet-distributed random vector :math:`X` is\n", + " proportional to\n", + "\n", + " .. math:: p(x) \\propto \\prod_{i=1}^{k}{x^{\\alpha_i-1}_i},\n", + "\n", + " where :math:`\\alpha` is a vector containing the positive\n", + " concentration parameters.\n", + "\n", + " The method uses the following property for computation: let :math:`Y`\n", + " be a random vector which has components that follow a standard gamma\n", + " distribution, then :math:`X = \\frac{1}{\\sum_{i=1}^k{Y_i}} Y`\n", + " is Dirichlet-distributed\n", + "\n", + " References\n", + " ----------\n", + " .. [1] David McKay, \"Information Theory, Inference and Learning\n", + " Algorithms,\" chapter 23,\n", + " https://www.inference.org.uk/mackay/itila/\n", + " .. [2] Wikipedia, \"Dirichlet distribution\",\n", + " https://en.wikipedia.org/wiki/Dirichlet_distribution\n", + "\n", + " Examples\n", + " --------\n", + " Taking an example cited in Wikipedia, this distribution can be used if\n", + " one wanted to cut strings (each of initial length 1.0) into K pieces\n", + " with different lengths, where each piece had, on average, a designated\n", + " average length, but allowing some variation in the relative sizes of\n", + " the pieces.\n", + "\n", + " >>> s = np.random.dirichlet((10, 5, 3), 20).transpose()\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> plt.barh(range(20), s[0])\n", + " >>> plt.barh(range(20), s[1], left=s[0], color='g')\n", + " >>> plt.barh(range(20), s[2], left=s[0]+s[1], color='r')\n", + " >>> plt.title(\"Lengths of Strings\")\n", + "\n", + " exponential(scale=1.0, size=None) method of numpy.random.mtrand.RandomState instance\n", + " exponential(scale=1.0, size=None)\n", + "\n", + " Draw samples from an exponential distribution.\n", + "\n", + " Its probability density function is\n", + "\n", + " .. math:: f(x; \\frac{1}{\\beta}) = \\frac{1}{\\beta} \\exp(-\\frac{x}{\\beta}),\n", + "\n", + " for ``x > 0`` and 0 elsewhere. :math:`\\beta` is the scale parameter,\n", + " which is the inverse of the rate parameter :math:`\\lambda = 1/\\beta`.\n", + " The rate parameter is an alternative, widely used parameterization\n", + " of the exponential distribution [3]_.\n", + "\n", + " The exponential distribution is a continuous analogue of the\n", + " geometric distribution. It describes many common situations, such as\n", + " the size of raindrops measured over many rainstorms [1]_, or the time\n", + " between page requests to Wikipedia [2]_.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.exponential`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " scale : float or array_like of floats\n", + " The scale parameter, :math:`\\beta = 1/\\lambda`. Must be\n", + " non-negative.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``scale`` is a scalar. Otherwise,\n", + " ``np.array(scale).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized exponential distribution.\n", + "\n", + " Examples\n", + " --------\n", + " A real world example: Assume a company has 10000 customer support\n", + " agents and the average time between customer calls is 4 minutes.\n", + "\n", + " >>> n = 10000\n", + " >>> time_between_calls = np.random.default_rng().exponential(scale=4, size=n)\n", + "\n", + " What is the probability that a customer will call in the next\n", + " 4 to 5 minutes?\n", + "\n", + " >>> x = ((time_between_calls < 5).sum())/n\n", + " >>> y = ((time_between_calls < 4).sum())/n\n", + " >>> x-y\n", + " 0.08 # may vary\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.exponential: which should be used for new code.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Peyton Z. Peebles Jr., \"Probability, Random Variables and\n", + " Random Signal Principles\", 4th ed, 2001, p. 57.\n", + " .. [2] Wikipedia, \"Poisson process\",\n", + " https://en.wikipedia.org/wiki/Poisson_process\n", + " .. [3] Wikipedia, \"Exponential distribution\",\n", + " https://en.wikipedia.org/wiki/Exponential_distribution\n", + "\n", + " f(dfnum, dfden, size=None) method of numpy.random.mtrand.RandomState instance\n", + " f(dfnum, dfden, size=None)\n", + "\n", + " Draw samples from an F distribution.\n", + "\n", + " Samples are drawn from an F distribution with specified parameters,\n", + " `dfnum` (degrees of freedom in numerator) and `dfden` (degrees of\n", + " freedom in denominator), where both parameters must be greater than\n", + " zero.\n", + "\n", + " The random variate of the F distribution (also known as the\n", + " Fisher distribution) is a continuous probability distribution\n", + " that arises in ANOVA tests, and is the ratio of two chi-square\n", + " variates.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.f`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " dfnum : float or array_like of floats\n", + " Degrees of freedom in numerator, must be > 0.\n", + " dfden : float or array_like of float\n", + " Degrees of freedom in denominator, must be > 0.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``dfnum`` and ``dfden`` are both scalars.\n", + " Otherwise, ``np.broadcast(dfnum, dfden).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized Fisher distribution.\n", + "\n", + " See Also\n", + " --------\n", + " scipy.stats.f : probability density function, distribution or\n", + " cumulative density function, etc.\n", + " random.Generator.f: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The F statistic is used to compare in-group variances to between-group\n", + " variances. Calculating the distribution depends on the sampling, and\n", + " so it is a function of the respective degrees of freedom in the\n", + " problem. The variable `dfnum` is the number of samples minus one, the\n", + " between-groups degrees of freedom, while `dfden` is the within-groups\n", + " degrees of freedom, the sum of the number of samples in each group\n", + " minus the number of groups.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Glantz, Stanton A. \"Primer of Biostatistics.\", McGraw-Hill,\n", + " Fifth Edition, 2002.\n", + " .. [2] Wikipedia, \"F-distribution\",\n", + " https://en.wikipedia.org/wiki/F-distribution\n", + "\n", + " Examples\n", + " --------\n", + " An example from Glantz[1], pp 47-40:\n", + "\n", + " Two groups, children of diabetics (25 people) and children from people\n", + " without diabetes (25 controls). Fasting blood glucose was measured,\n", + " case group had a mean value of 86.1, controls had a mean value of\n", + " 82.2. Standard deviations were 2.09 and 2.49 respectively. Are these\n", + " data consistent with the null hypothesis that the parents diabetic\n", + " status does not affect their children's blood glucose levels?\n", + " Calculating the F statistic from the data gives a value of 36.01.\n", + "\n", + " Draw samples from the distribution:\n", + "\n", + " >>> dfnum = 1. # between group degrees of freedom\n", + " >>> dfden = 48. # within groups degrees of freedom\n", + " >>> s = np.random.f(dfnum, dfden, 1000)\n", + "\n", + " The lower bound for the top 1% of the samples is :\n", + "\n", + " >>> np.sort(s)[-10]\n", + " 7.61988120985 # random\n", + "\n", + " So there is about a 1% chance that the F statistic will exceed 7.62,\n", + " the measured value is 36, so the null hypothesis is rejected at the 1%\n", + " level.\n", + "\n", + " gamma(shape, scale=1.0, size=None) method of numpy.random.mtrand.RandomState instance\n", + " gamma(shape, scale=1.0, size=None)\n", + "\n", + " Draw samples from a Gamma distribution.\n", + "\n", + " Samples are drawn from a Gamma distribution with specified parameters,\n", + " `shape` (sometimes designated \"k\") and `scale` (sometimes designated\n", + " \"theta\"), where both parameters are > 0.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.gamma`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " shape : float or array_like of floats\n", + " The shape of the gamma distribution. Must be non-negative.\n", + " scale : float or array_like of floats, optional\n", + " The scale of the gamma distribution. Must be non-negative.\n", + " Default is equal to 1.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``shape`` and ``scale`` are both scalars.\n", + " Otherwise, ``np.broadcast(shape, scale).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized gamma distribution.\n", + "\n", + " See Also\n", + " --------\n", + " scipy.stats.gamma : probability density function, distribution or\n", + " cumulative density function, etc.\n", + " random.Generator.gamma: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability density for the Gamma distribution is\n", + "\n", + " .. math:: p(x) = x^{k-1}\\frac{e^{-x/\\theta}}{\\theta^k\\Gamma(k)},\n", + "\n", + " where :math:`k` is the shape and :math:`\\theta` the scale,\n", + " and :math:`\\Gamma` is the Gamma function.\n", + "\n", + " The Gamma distribution is often used to model the times to failure of\n", + " electronic components, and arises naturally in processes for which the\n", + " waiting times between Poisson distributed events are relevant.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Weisstein, Eric W. \"Gamma Distribution.\" From MathWorld--A\n", + " Wolfram Web Resource.\n", + " https://mathworld.wolfram.com/GammaDistribution.html\n", + " .. [2] Wikipedia, \"Gamma distribution\",\n", + " https://en.wikipedia.org/wiki/Gamma_distribution\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples from the distribution:\n", + "\n", + " >>> shape, scale = 2., 2. # mean=4, std=2*sqrt(2)\n", + " >>> s = np.random.gamma(shape, scale, 1000)\n", + "\n", + " Display the histogram of the samples, along with\n", + " the probability density function:\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> import scipy.special as sps # doctest: +SKIP\n", + " >>> count, bins, ignored = plt.hist(s, 50, density=True)\n", + " >>> y = bins**(shape-1)*(np.exp(-bins/scale) / # doctest: +SKIP\n", + " ... (sps.gamma(shape)*scale**shape))\n", + " >>> plt.plot(bins, y, linewidth=2, color='r') # doctest: +SKIP\n", + " >>> plt.show()\n", + "\n", + " geometric(p, size=None) method of numpy.random.mtrand.RandomState instance\n", + " geometric(p, size=None)\n", + "\n", + " Draw samples from the geometric distribution.\n", + "\n", + " Bernoulli trials are experiments with one of two outcomes:\n", + " success or failure (an example of such an experiment is flipping\n", + " a coin). The geometric distribution models the number of trials\n", + " that must be run in order to achieve success. It is therefore\n", + " supported on the positive integers, ``k = 1, 2, ...``.\n", + "\n", + " The probability mass function of the geometric distribution is\n", + "\n", + " .. math:: f(k) = (1 - p)^{k - 1} p\n", + "\n", + " where `p` is the probability of success of an individual trial.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.geometric`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " p : float or array_like of floats\n", + " The probability of success of an individual trial.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``p`` is a scalar. Otherwise,\n", + " ``np.array(p).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized geometric distribution.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.geometric: which should be used for new code.\n", + "\n", + " Examples\n", + " --------\n", + " Draw ten thousand values from the geometric distribution,\n", + " with the probability of an individual success equal to 0.35:\n", + "\n", + " >>> z = np.random.geometric(p=0.35, size=10000)\n", + "\n", + " How many trials succeeded after a single run?\n", + "\n", + " >>> (z == 1).sum() / 10000.\n", + " 0.34889999999999999 #random\n", + "\n", + " get_state(legacy=True) method of numpy.random.mtrand.RandomState instance\n", + " get_state(legacy=True)\n", + "\n", + " Return a tuple representing the internal state of the generator.\n", + "\n", + " For more details, see `set_state`.\n", + "\n", + " Parameters\n", + " ----------\n", + " legacy : bool, optional\n", + " Flag indicating to return a legacy tuple state when the BitGenerator\n", + " is MT19937, instead of a dict. Raises ValueError if the underlying\n", + " bit generator is not an instance of MT19937.\n", + "\n", + " Returns\n", + " -------\n", + " out : {tuple(str, ndarray of 624 uints, int, int, float), dict}\n", + " If legacy is True, the returned tuple has the following items:\n", + "\n", + " 1. the string 'MT19937'.\n", + " 2. a 1-D array of 624 unsigned integer keys.\n", + " 3. an integer ``pos``.\n", + " 4. an integer ``has_gauss``.\n", + " 5. a float ``cached_gaussian``.\n", + "\n", + " If `legacy` is False, or the BitGenerator is not MT19937, then\n", + " state is returned as a dictionary.\n", + "\n", + " See Also\n", + " --------\n", + " set_state\n", + "\n", + " Notes\n", + " -----\n", + " `set_state` and `get_state` are not needed to work with any of the\n", + " random distributions in NumPy. If the internal state is manually altered,\n", + " the user should know exactly what he/she is doing.\n", + "\n", + " gumbel(loc=0.0, scale=1.0, size=None) method of numpy.random.mtrand.RandomState instance\n", + " gumbel(loc=0.0, scale=1.0, size=None)\n", + "\n", + " Draw samples from a Gumbel distribution.\n", + "\n", + " Draw samples from a Gumbel distribution with specified location and\n", + " scale. For more information on the Gumbel distribution, see\n", + " Notes and References below.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.gumbel`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " loc : float or array_like of floats, optional\n", + " The location of the mode of the distribution. Default is 0.\n", + " scale : float or array_like of floats, optional\n", + " The scale parameter of the distribution. Default is 1. Must be non-\n", + " negative.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``loc`` and ``scale`` are both scalars.\n", + " Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized Gumbel distribution.\n", + "\n", + " See Also\n", + " --------\n", + " scipy.stats.gumbel_l\n", + " scipy.stats.gumbel_r\n", + " scipy.stats.genextreme\n", + " weibull\n", + " random.Generator.gumbel: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The Gumbel (or Smallest Extreme Value (SEV) or the Smallest Extreme\n", + " Value Type I) distribution is one of a class of Generalized Extreme\n", + " Value (GEV) distributions used in modeling extreme value problems.\n", + " The Gumbel is a special case of the Extreme Value Type I distribution\n", + " for maximums from distributions with \"exponential-like\" tails.\n", + "\n", + " The probability density for the Gumbel distribution is\n", + "\n", + " .. math:: p(x) = \\frac{e^{-(x - \\mu)/ \\beta}}{\\beta} e^{ -e^{-(x - \\mu)/\n", + " \\beta}},\n", + "\n", + " where :math:`\\mu` is the mode, a location parameter, and\n", + " :math:`\\beta` is the scale parameter.\n", + "\n", + " The Gumbel (named for German mathematician Emil Julius Gumbel) was used\n", + " very early in the hydrology literature, for modeling the occurrence of\n", + " flood events. It is also used for modeling maximum wind speed and\n", + " rainfall rates. It is a \"fat-tailed\" distribution - the probability of\n", + " an event in the tail of the distribution is larger than if one used a\n", + " Gaussian, hence the surprisingly frequent occurrence of 100-year\n", + " floods. Floods were initially modeled as a Gaussian process, which\n", + " underestimated the frequency of extreme events.\n", + "\n", + " It is one of a class of extreme value distributions, the Generalized\n", + " Extreme Value (GEV) distributions, which also includes the Weibull and\n", + " Frechet.\n", + "\n", + " The function has a mean of :math:`\\mu + 0.57721\\beta` and a variance\n", + " of :math:`\\frac{\\pi^2}{6}\\beta^2`.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Gumbel, E. J., \"Statistics of Extremes,\"\n", + " New York: Columbia University Press, 1958.\n", + " .. [2] Reiss, R.-D. and Thomas, M., \"Statistical Analysis of Extreme\n", + " Values from Insurance, Finance, Hydrology and Other Fields,\"\n", + " Basel: Birkhauser Verlag, 2001.\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples from the distribution:\n", + "\n", + " >>> mu, beta = 0, 0.1 # location and scale\n", + " >>> s = np.random.gumbel(mu, beta, 1000)\n", + "\n", + " Display the histogram of the samples, along with\n", + " the probability density function:\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> count, bins, ignored = plt.hist(s, 30, density=True)\n", + " >>> plt.plot(bins, (1/beta)*np.exp(-(bins - mu)/beta)\n", + " ... * np.exp( -np.exp( -(bins - mu) /beta) ),\n", + " ... linewidth=2, color='r')\n", + " >>> plt.show()\n", + "\n", + " Show how an extreme value distribution can arise from a Gaussian process\n", + " and compare to a Gaussian:\n", + "\n", + " >>> means = []\n", + " >>> maxima = []\n", + " >>> for i in range(0,1000) :\n", + " ... a = np.random.normal(mu, beta, 1000)\n", + " ... means.append(a.mean())\n", + " ... maxima.append(a.max())\n", + " >>> count, bins, ignored = plt.hist(maxima, 30, density=True)\n", + " >>> beta = np.std(maxima) * np.sqrt(6) / np.pi\n", + " >>> mu = np.mean(maxima) - 0.57721*beta\n", + " >>> plt.plot(bins, (1/beta)*np.exp(-(bins - mu)/beta)\n", + " ... * np.exp(-np.exp(-(bins - mu)/beta)),\n", + " ... linewidth=2, color='r')\n", + " >>> plt.plot(bins, 1/(beta * np.sqrt(2 * np.pi))\n", + " ... * np.exp(-(bins - mu)**2 / (2 * beta**2)),\n", + " ... linewidth=2, color='g')\n", + " >>> plt.show()\n", + "\n", + " hypergeometric(ngood, nbad, nsample, size=None) method of numpy.random.mtrand.RandomState instance\n", + " hypergeometric(ngood, nbad, nsample, size=None)\n", + "\n", + " Draw samples from a Hypergeometric distribution.\n", + "\n", + " Samples are drawn from a hypergeometric distribution with specified\n", + " parameters, `ngood` (ways to make a good selection), `nbad` (ways to make\n", + " a bad selection), and `nsample` (number of items sampled, which is less\n", + " than or equal to the sum ``ngood + nbad``).\n", + "\n", + " .. note::\n", + " New code should use the\n", + " `~numpy.random.Generator.hypergeometric`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " ngood : int or array_like of ints\n", + " Number of ways to make a good selection. Must be nonnegative.\n", + " nbad : int or array_like of ints\n", + " Number of ways to make a bad selection. Must be nonnegative.\n", + " nsample : int or array_like of ints\n", + " Number of items sampled. Must be at least 1 and at most\n", + " ``ngood + nbad``.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if `ngood`, `nbad`, and `nsample`\n", + " are all scalars. Otherwise, ``np.broadcast(ngood, nbad, nsample).size``\n", + " samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized hypergeometric distribution. Each\n", + " sample is the number of good items within a randomly selected subset of\n", + " size `nsample` taken from a set of `ngood` good items and `nbad` bad items.\n", + "\n", + " See Also\n", + " --------\n", + " scipy.stats.hypergeom : probability density function, distribution or\n", + " cumulative density function, etc.\n", + " random.Generator.hypergeometric: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability mass function (PMF) for the Hypergeometric distribution is\n", + "\n", + " .. math:: P(x) = \\frac{\\binom{g}{x}\\binom{b}{n-x}}{\\binom{g+b}{n}},\n", + "\n", + " where :math:`0 \\le x \\le n` and :math:`n-b \\le x \\le g`\n", + "\n", + " for P(x) the probability of ``x`` good results in the drawn sample,\n", + " g = `ngood`, b = `nbad`, and n = `nsample`.\n", + "\n", + " Consider an urn with black and white marbles in it, `ngood` of them\n", + " are black and `nbad` are white. If you draw `nsample` balls without\n", + " replacement, then the hypergeometric distribution describes the\n", + " distribution of black balls in the drawn sample.\n", + "\n", + " Note that this distribution is very similar to the binomial\n", + " distribution, except that in this case, samples are drawn without\n", + " replacement, whereas in the Binomial case samples are drawn with\n", + " replacement (or the sample space is infinite). As the sample space\n", + " becomes large, this distribution approaches the binomial.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Lentner, Marvin, \"Elementary Applied Statistics\", Bogden\n", + " and Quigley, 1972.\n", + " .. [2] Weisstein, Eric W. \"Hypergeometric Distribution.\" From\n", + " MathWorld--A Wolfram Web Resource.\n", + " https://mathworld.wolfram.com/HypergeometricDistribution.html\n", + " .. [3] Wikipedia, \"Hypergeometric distribution\",\n", + " https://en.wikipedia.org/wiki/Hypergeometric_distribution\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples from the distribution:\n", + "\n", + " >>> ngood, nbad, nsamp = 100, 2, 10\n", + " # number of good, number of bad, and number of samples\n", + " >>> s = np.random.hypergeometric(ngood, nbad, nsamp, 1000)\n", + " >>> from matplotlib.pyplot import hist\n", + " >>> hist(s)\n", + " # note that it is very unlikely to grab both bad items\n", + "\n", + " Suppose you have an urn with 15 white and 15 black marbles.\n", + " If you pull 15 marbles at random, how likely is it that\n", + " 12 or more of them are one color?\n", + "\n", + " >>> s = np.random.hypergeometric(15, 15, 15, 100000)\n", + " >>> sum(s>=12)/100000. + sum(s<=3)/100000.\n", + " # answer = 0.003 ... pretty unlikely!\n", + "\n", + " laplace(loc=0.0, scale=1.0, size=None) method of numpy.random.mtrand.RandomState instance\n", + " laplace(loc=0.0, scale=1.0, size=None)\n", + "\n", + " Draw samples from the Laplace or double exponential distribution with\n", + " specified location (or mean) and scale (decay).\n", + "\n", + " The Laplace distribution is similar to the Gaussian/normal distribution,\n", + " but is sharper at the peak and has fatter tails. It represents the\n", + " difference between two independent, identically distributed exponential\n", + " random variables.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.laplace`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " loc : float or array_like of floats, optional\n", + " The position, :math:`\\mu`, of the distribution peak. Default is 0.\n", + " scale : float or array_like of floats, optional\n", + " :math:`\\lambda`, the exponential decay. Default is 1. Must be non-\n", + " negative.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``loc`` and ``scale`` are both scalars.\n", + " Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized Laplace distribution.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.laplace: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " It has the probability density function\n", + "\n", + " .. math:: f(x; \\mu, \\lambda) = \\frac{1}{2\\lambda}\n", + " \\exp\\left(-\\frac{|x - \\mu|}{\\lambda}\\right).\n", + "\n", + " The first law of Laplace, from 1774, states that the frequency\n", + " of an error can be expressed as an exponential function of the\n", + " absolute magnitude of the error, which leads to the Laplace\n", + " distribution. For many problems in economics and health\n", + " sciences, this distribution seems to model the data better\n", + " than the standard Gaussian distribution.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Abramowitz, M. and Stegun, I. A. (Eds.). \"Handbook of\n", + " Mathematical Functions with Formulas, Graphs, and Mathematical\n", + " Tables, 9th printing,\" New York: Dover, 1972.\n", + " .. [2] Kotz, Samuel, et. al. \"The Laplace Distribution and\n", + " Generalizations, \" Birkhauser, 2001.\n", + " .. [3] Weisstein, Eric W. \"Laplace Distribution.\"\n", + " From MathWorld--A Wolfram Web Resource.\n", + " https://mathworld.wolfram.com/LaplaceDistribution.html\n", + " .. [4] Wikipedia, \"Laplace distribution\",\n", + " https://en.wikipedia.org/wiki/Laplace_distribution\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples from the distribution\n", + "\n", + " >>> loc, scale = 0., 1.\n", + " >>> s = np.random.laplace(loc, scale, 1000)\n", + "\n", + " Display the histogram of the samples, along with\n", + " the probability density function:\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> count, bins, ignored = plt.hist(s, 30, density=True)\n", + " >>> x = np.arange(-8., 8., .01)\n", + " >>> pdf = np.exp(-abs(x-loc)/scale)/(2.*scale)\n", + " >>> plt.plot(x, pdf)\n", + "\n", + " Plot Gaussian for comparison:\n", + "\n", + " >>> g = (1/(scale * np.sqrt(2 * np.pi)) *\n", + " ... np.exp(-(x - loc)**2 / (2 * scale**2)))\n", + " >>> plt.plot(x,g)\n", + "\n", + " logistic(loc=0.0, scale=1.0, size=None) method of numpy.random.mtrand.RandomState instance\n", + " logistic(loc=0.0, scale=1.0, size=None)\n", + "\n", + " Draw samples from a logistic distribution.\n", + "\n", + " Samples are drawn from a logistic distribution with specified\n", + " parameters, loc (location or mean, also median), and scale (>0).\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.logistic`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " loc : float or array_like of floats, optional\n", + " Parameter of the distribution. Default is 0.\n", + " scale : float or array_like of floats, optional\n", + " Parameter of the distribution. Must be non-negative.\n", + " Default is 1.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``loc`` and ``scale`` are both scalars.\n", + " Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized logistic distribution.\n", + "\n", + " See Also\n", + " --------\n", + " scipy.stats.logistic : probability density function, distribution or\n", + " cumulative density function, etc.\n", + " random.Generator.logistic: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability density for the Logistic distribution is\n", + "\n", + " .. math:: P(x) = P(x) = \\frac{e^{-(x-\\mu)/s}}{s(1+e^{-(x-\\mu)/s})^2},\n", + "\n", + " where :math:`\\mu` = location and :math:`s` = scale.\n", + "\n", + " The Logistic distribution is used in Extreme Value problems where it\n", + " can act as a mixture of Gumbel distributions, in Epidemiology, and by\n", + " the World Chess Federation (FIDE) where it is used in the Elo ranking\n", + " system, assuming the performance of each player is a logistically\n", + " distributed random variable.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Reiss, R.-D. and Thomas M. (2001), \"Statistical Analysis of\n", + " Extreme Values, from Insurance, Finance, Hydrology and Other\n", + " Fields,\" Birkhauser Verlag, Basel, pp 132-133.\n", + " .. [2] Weisstein, Eric W. \"Logistic Distribution.\" From\n", + " MathWorld--A Wolfram Web Resource.\n", + " https://mathworld.wolfram.com/LogisticDistribution.html\n", + " .. [3] Wikipedia, \"Logistic-distribution\",\n", + " https://en.wikipedia.org/wiki/Logistic_distribution\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples from the distribution:\n", + "\n", + " >>> loc, scale = 10, 1\n", + " >>> s = np.random.logistic(loc, scale, 10000)\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> count, bins, ignored = plt.hist(s, bins=50)\n", + "\n", + " # plot against distribution\n", + "\n", + " >>> def logist(x, loc, scale):\n", + " ... return np.exp((loc-x)/scale)/(scale*(1+np.exp((loc-x)/scale))**2)\n", + " >>> lgst_val = logist(bins, loc, scale)\n", + " >>> plt.plot(bins, lgst_val * count.max() / lgst_val.max())\n", + " >>> plt.show()\n", + "\n", + " lognormal(mean=0.0, sigma=1.0, size=None) method of numpy.random.mtrand.RandomState instance\n", + " lognormal(mean=0.0, sigma=1.0, size=None)\n", + "\n", + " Draw samples from a log-normal distribution.\n", + "\n", + " Draw samples from a log-normal distribution with specified mean,\n", + " standard deviation, and array shape. Note that the mean and standard\n", + " deviation are not the values for the distribution itself, but of the\n", + " underlying normal distribution it is derived from.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.lognormal`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " mean : float or array_like of floats, optional\n", + " Mean value of the underlying normal distribution. Default is 0.\n", + " sigma : float or array_like of floats, optional\n", + " Standard deviation of the underlying normal distribution. Must be\n", + " non-negative. Default is 1.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``mean`` and ``sigma`` are both scalars.\n", + " Otherwise, ``np.broadcast(mean, sigma).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized log-normal distribution.\n", + "\n", + " See Also\n", + " --------\n", + " scipy.stats.lognorm : probability density function, distribution,\n", + " cumulative density function, etc.\n", + " random.Generator.lognormal: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " A variable `x` has a log-normal distribution if `log(x)` is normally\n", + " distributed. The probability density function for the log-normal\n", + " distribution is:\n", + "\n", + " .. math:: p(x) = \\frac{1}{\\sigma x \\sqrt{2\\pi}}\n", + " e^{(-\\frac{(ln(x)-\\mu)^2}{2\\sigma^2})}\n", + "\n", + " where :math:`\\mu` is the mean and :math:`\\sigma` is the standard\n", + " deviation of the normally distributed logarithm of the variable.\n", + " A log-normal distribution results if a random variable is the *product*\n", + " of a large number of independent, identically-distributed variables in\n", + " the same way that a normal distribution results if the variable is the\n", + " *sum* of a large number of independent, identically-distributed\n", + " variables.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Limpert, E., Stahel, W. A., and Abbt, M., \"Log-normal\n", + " Distributions across the Sciences: Keys and Clues,\"\n", + " BioScience, Vol. 51, No. 5, May, 2001.\n", + " https://stat.ethz.ch/~stahel/lognormal/bioscience.pdf\n", + " .. [2] Reiss, R.D. and Thomas, M., \"Statistical Analysis of Extreme\n", + " Values,\" Basel: Birkhauser Verlag, 2001, pp. 31-32.\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples from the distribution:\n", + "\n", + " >>> mu, sigma = 3., 1. # mean and standard deviation\n", + " >>> s = np.random.lognormal(mu, sigma, 1000)\n", + "\n", + " Display the histogram of the samples, along with\n", + " the probability density function:\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> count, bins, ignored = plt.hist(s, 100, density=True, align='mid')\n", + "\n", + " >>> x = np.linspace(min(bins), max(bins), 10000)\n", + " >>> pdf = (np.exp(-(np.log(x) - mu)**2 / (2 * sigma**2))\n", + " ... / (x * sigma * np.sqrt(2 * np.pi)))\n", + "\n", + " >>> plt.plot(x, pdf, linewidth=2, color='r')\n", + " >>> plt.axis('tight')\n", + " >>> plt.show()\n", + "\n", + " Demonstrate that taking the products of random samples from a uniform\n", + " distribution can be fit well by a log-normal probability density\n", + " function.\n", + "\n", + " >>> # Generate a thousand samples: each is the product of 100 random\n", + " >>> # values, drawn from a normal distribution.\n", + " >>> b = []\n", + " >>> for i in range(1000):\n", + " ... a = 10. + np.random.standard_normal(100)\n", + " ... b.append(np.prod(a))\n", + "\n", + " >>> b = np.array(b) / np.min(b) # scale values to be positive\n", + " >>> count, bins, ignored = plt.hist(b, 100, density=True, align='mid')\n", + " >>> sigma = np.std(np.log(b))\n", + " >>> mu = np.mean(np.log(b))\n", + "\n", + " >>> x = np.linspace(min(bins), max(bins), 10000)\n", + " >>> pdf = (np.exp(-(np.log(x) - mu)**2 / (2 * sigma**2))\n", + " ... / (x * sigma * np.sqrt(2 * np.pi)))\n", + "\n", + " >>> plt.plot(x, pdf, color='r', linewidth=2)\n", + " >>> plt.show()\n", + "\n", + " logseries(p, size=None) method of numpy.random.mtrand.RandomState instance\n", + " logseries(p, size=None)\n", + "\n", + " Draw samples from a logarithmic series distribution.\n", + "\n", + " Samples are drawn from a log series distribution with specified\n", + " shape parameter, 0 <= ``p`` < 1.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.logseries`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " p : float or array_like of floats\n", + " Shape parameter for the distribution. Must be in the range [0, 1).\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``p`` is a scalar. Otherwise,\n", + " ``np.array(p).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized logarithmic series distribution.\n", + "\n", + " See Also\n", + " --------\n", + " scipy.stats.logser : probability density function, distribution or\n", + " cumulative density function, etc.\n", + " random.Generator.logseries: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability density for the Log Series distribution is\n", + "\n", + " .. math:: P(k) = \\frac{-p^k}{k \\ln(1-p)},\n", + "\n", + " where p = probability.\n", + "\n", + " The log series distribution is frequently used to represent species\n", + " richness and occurrence, first proposed by Fisher, Corbet, and\n", + " Williams in 1943 [2]. It may also be used to model the numbers of\n", + " occupants seen in cars [3].\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Buzas, Martin A.; Culver, Stephen J., Understanding regional\n", + " species diversity through the log series distribution of\n", + " occurrences: BIODIVERSITY RESEARCH Diversity & Distributions,\n", + " Volume 5, Number 5, September 1999 , pp. 187-195(9).\n", + " .. [2] Fisher, R.A,, A.S. Corbet, and C.B. Williams. 1943. The\n", + " relation between the number of species and the number of\n", + " individuals in a random sample of an animal population.\n", + " Journal of Animal Ecology, 12:42-58.\n", + " .. [3] D. J. Hand, F. Daly, D. Lunn, E. Ostrowski, A Handbook of Small\n", + " Data Sets, CRC Press, 1994.\n", + " .. [4] Wikipedia, \"Logarithmic distribution\",\n", + " https://en.wikipedia.org/wiki/Logarithmic_distribution\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples from the distribution:\n", + "\n", + " >>> a = .6\n", + " >>> s = np.random.logseries(a, 10000)\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> count, bins, ignored = plt.hist(s)\n", + "\n", + " # plot against distribution\n", + "\n", + " >>> def logseries(k, p):\n", + " ... return -p**k/(k*np.log(1-p))\n", + " >>> plt.plot(bins, logseries(bins, a)*count.max()/\n", + " ... logseries(bins, a).max(), 'r')\n", + " >>> plt.show()\n", + "\n", + " multinomial(n, pvals, size=None) method of numpy.random.mtrand.RandomState instance\n", + " multinomial(n, pvals, size=None)\n", + "\n", + " Draw samples from a multinomial distribution.\n", + "\n", + " The multinomial distribution is a multivariate generalization of the\n", + " binomial distribution. Take an experiment with one of ``p``\n", + " possible outcomes. An example of such an experiment is throwing a dice,\n", + " where the outcome can be 1 through 6. Each sample drawn from the\n", + " distribution represents `n` such experiments. Its values,\n", + " ``X_i = [X_0, X_1, ..., X_p]``, represent the number of times the\n", + " outcome was ``i``.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.multinomial`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " .. warning::\n", + " This function defaults to the C-long dtype, which is 32bit on windows\n", + " and otherwise 64bit on 64bit platforms (and 32bit on 32bit ones).\n", + " Since NumPy 2.0, NumPy's default integer is 32bit on 32bit platforms\n", + " and 64bit on 64bit platforms.\n", + "\n", + "\n", + " Parameters\n", + " ----------\n", + " n : int\n", + " Number of experiments.\n", + " pvals : sequence of floats, length p\n", + " Probabilities of each of the ``p`` different outcomes. These\n", + " must sum to 1 (however, the last element is always assumed to\n", + " account for the remaining probability, as long as\n", + " ``sum(pvals[:-1]) <= 1)``.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " single value is returned.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray\n", + " The drawn samples, of shape *size*, if that was provided. If not,\n", + " the shape is ``(N,)``.\n", + "\n", + " In other words, each entry ``out[i,j,...,:]`` is an N-dimensional\n", + " value drawn from the distribution.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.multinomial: which should be used for new code.\n", + "\n", + " Examples\n", + " --------\n", + " Throw a dice 20 times:\n", + "\n", + " >>> np.random.multinomial(20, [1/6.]*6, size=1)\n", + " array([[4, 1, 7, 5, 2, 1]]) # random\n", + "\n", + " It landed 4 times on 1, once on 2, etc.\n", + "\n", + " Now, throw the dice 20 times, and 20 times again:\n", + "\n", + " >>> np.random.multinomial(20, [1/6.]*6, size=2)\n", + " array([[3, 4, 3, 3, 4, 3], # random\n", + " [2, 4, 3, 4, 0, 7]])\n", + "\n", + " For the first run, we threw 3 times 1, 4 times 2, etc. For the second,\n", + " we threw 2 times 1, 4 times 2, etc.\n", + "\n", + " A loaded die is more likely to land on number 6:\n", + "\n", + " >>> np.random.multinomial(100, [1/7.]*5 + [2/7.])\n", + " array([11, 16, 14, 17, 16, 26]) # random\n", + "\n", + " The probability inputs should be normalized. As an implementation\n", + " detail, the value of the last entry is ignored and assumed to take\n", + " up any leftover probability mass, but this should not be relied on.\n", + " A biased coin which has twice as much weight on one side as on the\n", + " other should be sampled like so:\n", + "\n", + " >>> np.random.multinomial(100, [1.0 / 3, 2.0 / 3]) # RIGHT\n", + " array([38, 62]) # random\n", + "\n", + " not like:\n", + "\n", + " >>> np.random.multinomial(100, [1.0, 2.0]) # WRONG\n", + " Traceback (most recent call last):\n", + " ValueError: pvals < 0, pvals > 1 or pvals contains NaNs\n", + "\n", + " multivariate_normal(mean, cov, size=None, check_valid='warn', tol=1e-08) method of numpy.random.mtrand.RandomState instance\n", + " multivariate_normal(mean, cov, size=None, check_valid='warn', tol=1e-8)\n", + "\n", + " Draw random samples from a multivariate normal distribution.\n", + "\n", + " The multivariate normal, multinormal or Gaussian distribution is a\n", + " generalization of the one-dimensional normal distribution to higher\n", + " dimensions. Such a distribution is specified by its mean and\n", + " covariance matrix. These parameters are analogous to the mean\n", + " (average or \"center\") and variance (standard deviation, or \"width,\"\n", + " squared) of the one-dimensional normal distribution.\n", + "\n", + " .. note::\n", + " New code should use the\n", + " `~numpy.random.Generator.multivariate_normal`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " mean : 1-D array_like, of length N\n", + " Mean of the N-dimensional distribution.\n", + " cov : 2-D array_like, of shape (N, N)\n", + " Covariance matrix of the distribution. It must be symmetric and\n", + " positive-semidefinite for proper sampling.\n", + " size : int or tuple of ints, optional\n", + " Given a shape of, for example, ``(m,n,k)``, ``m*n*k`` samples are\n", + " generated, and packed in an `m`-by-`n`-by-`k` arrangement. Because\n", + " each sample is `N`-dimensional, the output shape is ``(m,n,k,N)``.\n", + " If no shape is specified, a single (`N`-D) sample is returned.\n", + " check_valid : { 'warn', 'raise', 'ignore' }, optional\n", + " Behavior when the covariance matrix is not positive semidefinite.\n", + " tol : float, optional\n", + " Tolerance when checking the singular values in covariance matrix.\n", + " cov is cast to double before the check.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray\n", + " The drawn samples, of shape *size*, if that was provided. If not,\n", + " the shape is ``(N,)``.\n", + "\n", + " In other words, each entry ``out[i,j,...,:]`` is an N-dimensional\n", + " value drawn from the distribution.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.multivariate_normal: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The mean is a coordinate in N-dimensional space, which represents the\n", + " location where samples are most likely to be generated. This is\n", + " analogous to the peak of the bell curve for the one-dimensional or\n", + " univariate normal distribution.\n", + "\n", + " Covariance indicates the level to which two variables vary together.\n", + " From the multivariate normal distribution, we draw N-dimensional\n", + " samples, :math:`X = [x_1, x_2, ... x_N]`. The covariance matrix\n", + " element :math:`C_{ij}` is the covariance of :math:`x_i` and :math:`x_j`.\n", + " The element :math:`C_{ii}` is the variance of :math:`x_i` (i.e. its\n", + " \"spread\").\n", + "\n", + " Instead of specifying the full covariance matrix, popular\n", + " approximations include:\n", + "\n", + " - Spherical covariance (`cov` is a multiple of the identity matrix)\n", + " - Diagonal covariance (`cov` has non-negative elements, and only on\n", + " the diagonal)\n", + "\n", + " This geometrical property can be seen in two dimensions by plotting\n", + " generated data-points:\n", + "\n", + " >>> mean = [0, 0]\n", + " >>> cov = [[1, 0], [0, 100]] # diagonal covariance\n", + "\n", + " Diagonal covariance means that points are oriented along x or y-axis:\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> x, y = np.random.multivariate_normal(mean, cov, 5000).T\n", + " >>> plt.plot(x, y, 'x')\n", + " >>> plt.axis('equal')\n", + " >>> plt.show()\n", + "\n", + " Note that the covariance matrix must be positive semidefinite (a.k.a.\n", + " nonnegative-definite). Otherwise, the behavior of this method is\n", + " undefined and backwards compatibility is not guaranteed.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Papoulis, A., \"Probability, Random Variables, and Stochastic\n", + " Processes,\" 3rd ed., New York: McGraw-Hill, 1991.\n", + " .. [2] Duda, R. O., Hart, P. E., and Stork, D. G., \"Pattern\n", + " Classification,\" 2nd ed., New York: Wiley, 2001.\n", + "\n", + " Examples\n", + " --------\n", + " >>> mean = (1, 2)\n", + " >>> cov = [[1, 0], [0, 1]]\n", + " >>> x = np.random.multivariate_normal(mean, cov, (3, 3))\n", + " >>> x.shape\n", + " (3, 3, 2)\n", + "\n", + " Here we generate 800 samples from the bivariate normal distribution\n", + " with mean [0, 0] and covariance matrix [[6, -3], [-3, 3.5]]. The\n", + " expected variances of the first and second components of the sample\n", + " are 6 and 3.5, respectively, and the expected correlation\n", + " coefficient is -3/sqrt(6*3.5) ≈ -0.65465.\n", + "\n", + " >>> cov = np.array([[6, -3], [-3, 3.5]])\n", + " >>> pts = np.random.multivariate_normal([0, 0], cov, size=800)\n", + "\n", + " Check that the mean, covariance, and correlation coefficient of the\n", + " sample are close to the expected values:\n", + "\n", + " >>> pts.mean(axis=0)\n", + " array([ 0.0326911 , -0.01280782]) # may vary\n", + " >>> np.cov(pts.T)\n", + " array([[ 5.96202397, -2.85602287],\n", + " [-2.85602287, 3.47613949]]) # may vary\n", + " >>> np.corrcoef(pts.T)[0, 1]\n", + " -0.6273591314603949 # may vary\n", + "\n", + " We can visualize this data with a scatter plot. The orientation\n", + " of the point cloud illustrates the negative correlation of the\n", + " components of this sample.\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> plt.plot(pts[:, 0], pts[:, 1], '.', alpha=0.5)\n", + " >>> plt.axis('equal')\n", + " >>> plt.grid()\n", + " >>> plt.show()\n", + "\n", + " negative_binomial(n, p, size=None) method of numpy.random.mtrand.RandomState instance\n", + " negative_binomial(n, p, size=None)\n", + "\n", + " Draw samples from a negative binomial distribution.\n", + "\n", + " Samples are drawn from a negative binomial distribution with specified\n", + " parameters, `n` successes and `p` probability of success where `n`\n", + " is > 0 and `p` is in the interval [0, 1].\n", + "\n", + " .. note::\n", + " New code should use the\n", + " `~numpy.random.Generator.negative_binomial`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " n : float or array_like of floats\n", + " Parameter of the distribution, > 0.\n", + " p : float or array_like of floats\n", + " Parameter of the distribution, >= 0 and <=1.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``n`` and ``p`` are both scalars.\n", + " Otherwise, ``np.broadcast(n, p).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized negative binomial distribution,\n", + " where each sample is equal to N, the number of failures that\n", + " occurred before a total of n successes was reached.\n", + "\n", + " .. warning::\n", + " This function returns the C-long dtype, which is 32bit on windows\n", + " and otherwise 64bit on 64bit platforms (and 32bit on 32bit ones).\n", + " Since NumPy 2.0, NumPy's default integer is 32bit on 32bit platforms\n", + " and 64bit on 64bit platforms.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.negative_binomial: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability mass function of the negative binomial distribution is\n", + "\n", + " .. math:: P(N;n,p) = \\frac{\\Gamma(N+n)}{N!\\Gamma(n)}p^{n}(1-p)^{N},\n", + "\n", + " where :math:`n` is the number of successes, :math:`p` is the\n", + " probability of success, :math:`N+n` is the number of trials, and\n", + " :math:`\\Gamma` is the gamma function. When :math:`n` is an integer,\n", + " :math:`\\frac{\\Gamma(N+n)}{N!\\Gamma(n)} = \\binom{N+n-1}{N}`, which is\n", + " the more common form of this term in the pmf. The negative\n", + " binomial distribution gives the probability of N failures given n\n", + " successes, with a success on the last trial.\n", + "\n", + " If one throws a die repeatedly until the third time a \"1\" appears,\n", + " then the probability distribution of the number of non-\"1\"s that\n", + " appear before the third \"1\" is a negative binomial distribution.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Weisstein, Eric W. \"Negative Binomial Distribution.\" From\n", + " MathWorld--A Wolfram Web Resource.\n", + " https://mathworld.wolfram.com/NegativeBinomialDistribution.html\n", + " .. [2] Wikipedia, \"Negative binomial distribution\",\n", + " https://en.wikipedia.org/wiki/Negative_binomial_distribution\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples from the distribution:\n", + "\n", + " A real world example. A company drills wild-cat oil\n", + " exploration wells, each with an estimated probability of\n", + " success of 0.1. What is the probability of having one success\n", + " for each successive well, that is what is the probability of a\n", + " single success after drilling 5 wells, after 6 wells, etc.?\n", + "\n", + " >>> s = np.random.negative_binomial(1, 0.1, 100000)\n", + " >>> for i in range(1, 11): # doctest: +SKIP\n", + " ... probability = sum(s 0.\n", + " nonc : float or array_like of floats\n", + " Non-centrality, must be non-negative.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``df`` and ``nonc`` are both scalars.\n", + " Otherwise, ``np.broadcast(df, nonc).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized noncentral chi-square distribution.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.noncentral_chisquare: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability density function for the noncentral Chi-square\n", + " distribution is\n", + "\n", + " .. math:: P(x;df,nonc) = \\sum^{\\infty}_{i=0}\n", + " \\frac{e^{-nonc/2}(nonc/2)^{i}}{i!}\n", + " P_{Y_{df+2i}}(x),\n", + "\n", + " where :math:`Y_{q}` is the Chi-square with q degrees of freedom.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Wikipedia, \"Noncentral chi-squared distribution\"\n", + " https://en.wikipedia.org/wiki/Noncentral_chi-squared_distribution\n", + "\n", + " Examples\n", + " --------\n", + " Draw values from the distribution and plot the histogram\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> values = plt.hist(np.random.noncentral_chisquare(3, 20, 100000),\n", + " ... bins=200, density=True)\n", + " >>> plt.show()\n", + "\n", + " Draw values from a noncentral chisquare with very small noncentrality,\n", + " and compare to a chisquare.\n", + "\n", + " >>> plt.figure()\n", + " >>> values = plt.hist(np.random.noncentral_chisquare(3, .0000001, 100000),\n", + " ... bins=np.arange(0., 25, .1), density=True)\n", + " >>> values2 = plt.hist(np.random.chisquare(3, 100000),\n", + " ... bins=np.arange(0., 25, .1), density=True)\n", + " >>> plt.plot(values[1][0:-1], values[0]-values2[0], 'ob')\n", + " >>> plt.show()\n", + "\n", + " Demonstrate how large values of non-centrality lead to a more symmetric\n", + " distribution.\n", + "\n", + " >>> plt.figure()\n", + " >>> values = plt.hist(np.random.noncentral_chisquare(3, 20, 100000),\n", + " ... bins=200, density=True)\n", + " >>> plt.show()\n", + "\n", + " noncentral_f(dfnum, dfden, nonc, size=None) method of numpy.random.mtrand.RandomState instance\n", + " noncentral_f(dfnum, dfden, nonc, size=None)\n", + "\n", + " Draw samples from the noncentral F distribution.\n", + "\n", + " Samples are drawn from an F distribution with specified parameters,\n", + " `dfnum` (degrees of freedom in numerator) and `dfden` (degrees of\n", + " freedom in denominator), where both parameters > 1.\n", + " `nonc` is the non-centrality parameter.\n", + "\n", + " .. note::\n", + " New code should use the\n", + " `~numpy.random.Generator.noncentral_f`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " dfnum : float or array_like of floats\n", + " Numerator degrees of freedom, must be > 0.\n", + " dfden : float or array_like of floats\n", + " Denominator degrees of freedom, must be > 0.\n", + " nonc : float or array_like of floats\n", + " Non-centrality parameter, the sum of the squares of the numerator\n", + " means, must be >= 0.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``dfnum``, ``dfden``, and ``nonc``\n", + " are all scalars. Otherwise, ``np.broadcast(dfnum, dfden, nonc).size``\n", + " samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized noncentral Fisher distribution.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.noncentral_f: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " When calculating the power of an experiment (power = probability of\n", + " rejecting the null hypothesis when a specific alternative is true) the\n", + " non-central F statistic becomes important. When the null hypothesis is\n", + " true, the F statistic follows a central F distribution. When the null\n", + " hypothesis is not true, then it follows a non-central F statistic.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Weisstein, Eric W. \"Noncentral F-Distribution.\"\n", + " From MathWorld--A Wolfram Web Resource.\n", + " https://mathworld.wolfram.com/NoncentralF-Distribution.html\n", + " .. [2] Wikipedia, \"Noncentral F-distribution\",\n", + " https://en.wikipedia.org/wiki/Noncentral_F-distribution\n", + "\n", + " Examples\n", + " --------\n", + " In a study, testing for a specific alternative to the null hypothesis\n", + " requires use of the Noncentral F distribution. We need to calculate the\n", + " area in the tail of the distribution that exceeds the value of the F\n", + " distribution for the null hypothesis. We'll plot the two probability\n", + " distributions for comparison.\n", + "\n", + " >>> dfnum = 3 # between group deg of freedom\n", + " >>> dfden = 20 # within groups degrees of freedom\n", + " >>> nonc = 3.0\n", + " >>> nc_vals = np.random.noncentral_f(dfnum, dfden, nonc, 1000000)\n", + " >>> NF = np.histogram(nc_vals, bins=50, density=True)\n", + " >>> c_vals = np.random.f(dfnum, dfden, 1000000)\n", + " >>> F = np.histogram(c_vals, bins=50, density=True)\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> plt.plot(F[1][1:], F[0])\n", + " >>> plt.plot(NF[1][1:], NF[0])\n", + " >>> plt.show()\n", + "\n", + " normal(loc=0.0, scale=1.0, size=None) method of numpy.random.mtrand.RandomState instance\n", + " normal(loc=0.0, scale=1.0, size=None)\n", + "\n", + " Draw random samples from a normal (Gaussian) distribution.\n", + "\n", + " The probability density function of the normal distribution, first\n", + " derived by De Moivre and 200 years later by both Gauss and Laplace\n", + " independently [2]_, is often called the bell curve because of\n", + " its characteristic shape (see the example below).\n", + "\n", + " The normal distributions occurs often in nature. For example, it\n", + " describes the commonly occurring distribution of samples influenced\n", + " by a large number of tiny, random disturbances, each with its own\n", + " unique distribution [2]_.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.normal`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " loc : float or array_like of floats\n", + " Mean (\"centre\") of the distribution.\n", + " scale : float or array_like of floats\n", + " Standard deviation (spread or \"width\") of the distribution. Must be\n", + " non-negative.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``loc`` and ``scale`` are both scalars.\n", + " Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized normal distribution.\n", + "\n", + " See Also\n", + " --------\n", + " scipy.stats.norm : probability density function, distribution or\n", + " cumulative density function, etc.\n", + " random.Generator.normal: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability density for the Gaussian distribution is\n", + "\n", + " .. math:: p(x) = \\frac{1}{\\sqrt{ 2 \\pi \\sigma^2 }}\n", + " e^{ - \\frac{ (x - \\mu)^2 } {2 \\sigma^2} },\n", + "\n", + " where :math:`\\mu` is the mean and :math:`\\sigma` the standard\n", + " deviation. The square of the standard deviation, :math:`\\sigma^2`,\n", + " is called the variance.\n", + "\n", + " The function has its peak at the mean, and its \"spread\" increases with\n", + " the standard deviation (the function reaches 0.607 times its maximum at\n", + " :math:`x + \\sigma` and :math:`x - \\sigma` [2]_). This implies that\n", + " normal is more likely to return samples lying close to the mean, rather\n", + " than those far away.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Wikipedia, \"Normal distribution\",\n", + " https://en.wikipedia.org/wiki/Normal_distribution\n", + " .. [2] P. R. Peebles Jr., \"Central Limit Theorem\" in \"Probability,\n", + " Random Variables and Random Signal Principles\", 4th ed., 2001,\n", + " pp. 51, 51, 125.\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples from the distribution:\n", + "\n", + " >>> mu, sigma = 0, 0.1 # mean and standard deviation\n", + " >>> s = np.random.normal(mu, sigma, 1000)\n", + "\n", + " Verify the mean and the standard deviation:\n", + "\n", + " >>> abs(mu - np.mean(s))\n", + " 0.0 # may vary\n", + "\n", + " >>> abs(sigma - np.std(s, ddof=1))\n", + " 0.1 # may vary\n", + "\n", + " Display the histogram of the samples, along with\n", + " the probability density function:\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> count, bins, ignored = plt.hist(s, 30, density=True)\n", + " >>> plt.plot(bins, 1/(sigma * np.sqrt(2 * np.pi)) *\n", + " ... np.exp( - (bins - mu)**2 / (2 * sigma**2) ),\n", + " ... linewidth=2, color='r')\n", + " >>> plt.show()\n", + "\n", + " Two-by-four array of samples from the normal distribution with\n", + " mean 3 and standard deviation 2.5:\n", + "\n", + " >>> np.random.normal(3, 2.5, size=(2, 4))\n", + " array([[-4.49401501, 4.00950034, -1.81814867, 7.29718677], # random\n", + " [ 0.39924804, 4.68456316, 4.99394529, 4.84057254]]) # random\n", + "\n", + " pareto(a, size=None) method of numpy.random.mtrand.RandomState instance\n", + " pareto(a, size=None)\n", + "\n", + " Draw samples from a Pareto II or Lomax distribution with\n", + " specified shape.\n", + "\n", + " The Lomax or Pareto II distribution is a shifted Pareto\n", + " distribution. The classical Pareto distribution can be\n", + " obtained from the Lomax distribution by adding 1 and\n", + " multiplying by the scale parameter ``m`` (see Notes). The\n", + " smallest value of the Lomax distribution is zero while for the\n", + " classical Pareto distribution it is ``mu``, where the standard\n", + " Pareto distribution has location ``mu = 1``. Lomax can also\n", + " be considered as a simplified version of the Generalized\n", + " Pareto distribution (available in SciPy), with the scale set\n", + " to one and the location set to zero.\n", + "\n", + " The Pareto distribution must be greater than zero, and is\n", + " unbounded above. It is also known as the \"80-20 rule\". In\n", + " this distribution, 80 percent of the weights are in the lowest\n", + " 20 percent of the range, while the other 20 percent fill the\n", + " remaining 80 percent of the range.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.pareto`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " a : float or array_like of floats\n", + " Shape of the distribution. Must be positive.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``a`` is a scalar. Otherwise,\n", + " ``np.array(a).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized Pareto distribution.\n", + "\n", + " See Also\n", + " --------\n", + " scipy.stats.lomax : probability density function, distribution or\n", + " cumulative density function, etc.\n", + " scipy.stats.genpareto : probability density function, distribution or\n", + " cumulative density function, etc.\n", + " random.Generator.pareto: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability density for the Pareto distribution is\n", + "\n", + " .. math:: p(x) = \\frac{am^a}{x^{a+1}}\n", + "\n", + " where :math:`a` is the shape and :math:`m` the scale.\n", + "\n", + " The Pareto distribution, named after the Italian economist\n", + " Vilfredo Pareto, is a power law probability distribution\n", + " useful in many real world problems. Outside the field of\n", + " economics it is generally referred to as the Bradford\n", + " distribution. Pareto developed the distribution to describe\n", + " the distribution of wealth in an economy. It has also found\n", + " use in insurance, web page access statistics, oil field sizes,\n", + " and many other problems, including the download frequency for\n", + " projects in Sourceforge [1]_. It is one of the so-called\n", + " \"fat-tailed\" distributions.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Francis Hunt and Paul Johnson, On the Pareto Distribution of\n", + " Sourceforge projects.\n", + " .. [2] Pareto, V. (1896). Course of Political Economy. Lausanne.\n", + " .. [3] Reiss, R.D., Thomas, M.(2001), Statistical Analysis of Extreme\n", + " Values, Birkhauser Verlag, Basel, pp 23-30.\n", + " .. [4] Wikipedia, \"Pareto distribution\",\n", + " https://en.wikipedia.org/wiki/Pareto_distribution\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples from the distribution:\n", + "\n", + " >>> a, m = 3., 2. # shape and mode\n", + " >>> s = (np.random.pareto(a, 1000) + 1) * m\n", + "\n", + " Display the histogram of the samples, along with the probability\n", + " density function:\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> count, bins, _ = plt.hist(s, 100, density=True)\n", + " >>> fit = a*m**a / bins**(a+1)\n", + " >>> plt.plot(bins, max(count)*fit/max(fit), linewidth=2, color='r')\n", + " >>> plt.show()\n", + "\n", + " permutation(x) method of numpy.random.mtrand.RandomState instance\n", + " permutation(x)\n", + "\n", + " Randomly permute a sequence, or return a permuted range.\n", + "\n", + " If `x` is a multi-dimensional array, it is only shuffled along its\n", + " first index.\n", + "\n", + " .. note::\n", + " New code should use the\n", + " `~numpy.random.Generator.permutation`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " x : int or array_like\n", + " If `x` is an integer, randomly permute ``np.arange(x)``.\n", + " If `x` is an array, make a copy and shuffle the elements\n", + " randomly.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray\n", + " Permuted sequence or array range.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.permutation: which should be used for new code.\n", + "\n", + " Examples\n", + " --------\n", + " >>> np.random.permutation(10)\n", + " array([1, 7, 4, 3, 0, 9, 2, 5, 8, 6]) # random\n", + "\n", + " >>> np.random.permutation([1, 4, 9, 12, 15])\n", + " array([15, 1, 9, 4, 12]) # random\n", + "\n", + " >>> arr = np.arange(9).reshape((3, 3))\n", + " >>> np.random.permutation(arr)\n", + " array([[6, 7, 8], # random\n", + " [0, 1, 2],\n", + " [3, 4, 5]])\n", + "\n", + " poisson(lam=1.0, size=None) method of numpy.random.mtrand.RandomState instance\n", + " poisson(lam=1.0, size=None)\n", + "\n", + " Draw samples from a Poisson distribution.\n", + "\n", + " The Poisson distribution is the limit of the binomial distribution\n", + " for large N.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.poisson`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " lam : float or array_like of floats\n", + " Expected number of events occurring in a fixed-time interval,\n", + " must be >= 0. A sequence must be broadcastable over the requested\n", + " size.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``lam`` is a scalar. Otherwise,\n", + " ``np.array(lam).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized Poisson distribution.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.poisson: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability mass function (PMF) of Poisson distribution is\n", + "\n", + " .. math:: f(k; \\lambda)=\\frac{\\lambda^k e^{-\\lambda}}{k!}\n", + "\n", + " For events with an expected separation :math:`\\lambda` the Poisson\n", + " distribution :math:`f(k; \\lambda)` describes the probability of\n", + " :math:`k` events occurring within the observed\n", + " interval :math:`\\lambda`.\n", + "\n", + " Because the output is limited to the range of the C int64 type, a\n", + " ValueError is raised when `lam` is within 10 sigma of the maximum\n", + " representable value.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Weisstein, Eric W. \"Poisson Distribution.\"\n", + " From MathWorld--A Wolfram Web Resource.\n", + " https://mathworld.wolfram.com/PoissonDistribution.html\n", + " .. [2] Wikipedia, \"Poisson distribution\",\n", + " https://en.wikipedia.org/wiki/Poisson_distribution\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples from the distribution:\n", + "\n", + " >>> import numpy as np\n", + " >>> s = np.random.poisson(5, 10000)\n", + "\n", + " Display histogram of the sample:\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> count, bins, ignored = plt.hist(s, 14, density=True)\n", + " >>> plt.show()\n", + "\n", + " Draw each 100 values for lambda 100 and 500:\n", + "\n", + " >>> s = np.random.poisson(lam=(100., 500.), size=(100, 2))\n", + "\n", + " power(a, size=None) method of numpy.random.mtrand.RandomState instance\n", + " power(a, size=None)\n", + "\n", + " Draws samples in [0, 1] from a power distribution with positive\n", + " exponent a - 1.\n", + "\n", + " Also known as the power function distribution.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.power`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " a : float or array_like of floats\n", + " Parameter of the distribution. Must be non-negative.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``a`` is a scalar. Otherwise,\n", + " ``np.array(a).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized power distribution.\n", + "\n", + " Raises\n", + " ------\n", + " ValueError\n", + " If a <= 0.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.power: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability density function is\n", + "\n", + " .. math:: P(x; a) = ax^{a-1}, 0 \\le x \\le 1, a>0.\n", + "\n", + " The power function distribution is just the inverse of the Pareto\n", + " distribution. It may also be seen as a special case of the Beta\n", + " distribution.\n", + "\n", + " It is used, for example, in modeling the over-reporting of insurance\n", + " claims.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Christian Kleiber, Samuel Kotz, \"Statistical size distributions\n", + " in economics and actuarial sciences\", Wiley, 2003.\n", + " .. [2] Heckert, N. A. and Filliben, James J. \"NIST Handbook 148:\n", + " Dataplot Reference Manual, Volume 2: Let Subcommands and Library\n", + " Functions\", National Institute of Standards and Technology\n", + " Handbook Series, June 2003.\n", + " https://www.itl.nist.gov/div898/software/dataplot/refman2/auxillar/powpdf.pdf\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples from the distribution:\n", + "\n", + " >>> a = 5. # shape\n", + " >>> samples = 1000\n", + " >>> s = np.random.power(a, samples)\n", + "\n", + " Display the histogram of the samples, along with\n", + " the probability density function:\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> count, bins, ignored = plt.hist(s, bins=30)\n", + " >>> x = np.linspace(0, 1, 100)\n", + " >>> y = a*x**(a-1.)\n", + " >>> normed_y = samples*np.diff(bins)[0]*y\n", + " >>> plt.plot(x, normed_y)\n", + " >>> plt.show()\n", + "\n", + " Compare the power function distribution to the inverse of the Pareto.\n", + "\n", + " >>> from scipy import stats # doctest: +SKIP\n", + " >>> rvs = np.random.power(5, 1000000)\n", + " >>> rvsp = np.random.pareto(5, 1000000)\n", + " >>> xx = np.linspace(0,1,100)\n", + " >>> powpdf = stats.powerlaw.pdf(xx,5) # doctest: +SKIP\n", + "\n", + " >>> plt.figure()\n", + " >>> plt.hist(rvs, bins=50, density=True)\n", + " >>> plt.plot(xx,powpdf,'r-') # doctest: +SKIP\n", + " >>> plt.title('np.random.power(5)')\n", + "\n", + " >>> plt.figure()\n", + " >>> plt.hist(1./(1.+rvsp), bins=50, density=True)\n", + " >>> plt.plot(xx,powpdf,'r-') # doctest: +SKIP\n", + " >>> plt.title('inverse of 1 + np.random.pareto(5)')\n", + "\n", + " >>> plt.figure()\n", + " >>> plt.hist(1./(1.+rvsp), bins=50, density=True)\n", + " >>> plt.plot(xx,powpdf,'r-') # doctest: +SKIP\n", + " >>> plt.title('inverse of stats.pareto(5)')\n", + "\n", + " rand(*args) method of numpy.random.mtrand.RandomState instance\n", + " rand(d0, d1, ..., dn)\n", + "\n", + " Random values in a given shape.\n", + "\n", + " .. note::\n", + " This is a convenience function for users porting code from Matlab,\n", + " and wraps `random_sample`. That function takes a\n", + " tuple to specify the size of the output, which is consistent with\n", + " other NumPy functions like `numpy.zeros` and `numpy.ones`.\n", + "\n", + " Create an array of the given shape and populate it with\n", + " random samples from a uniform distribution\n", + " over ``[0, 1)``.\n", + "\n", + " Parameters\n", + " ----------\n", + " d0, d1, ..., dn : int, optional\n", + " The dimensions of the returned array, must be non-negative.\n", + " If no argument is given a single Python float is returned.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray, shape ``(d0, d1, ..., dn)``\n", + " Random values.\n", + "\n", + " See Also\n", + " --------\n", + " random\n", + "\n", + " Examples\n", + " --------\n", + " >>> np.random.rand(3,2)\n", + " array([[ 0.14022471, 0.96360618], #random\n", + " [ 0.37601032, 0.25528411], #random\n", + " [ 0.49313049, 0.94909878]]) #random\n", + "\n", + " randint(low, high=None, size=None, dtype=) method of numpy.random.mtrand.RandomState instance\n", + " randint(low, high=None, size=None, dtype=int)\n", + "\n", + " Return random integers from `low` (inclusive) to `high` (exclusive).\n", + "\n", + " Return random integers from the \"discrete uniform\" distribution of\n", + " the specified dtype in the \"half-open\" interval [`low`, `high`). If\n", + " `high` is None (the default), then results are from [0, `low`).\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.integers`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " low : int or array-like of ints\n", + " Lowest (signed) integers to be drawn from the distribution (unless\n", + " ``high=None``, in which case this parameter is one above the\n", + " *highest* such integer).\n", + " high : int or array-like of ints, optional\n", + " If provided, one above the largest (signed) integer to be drawn\n", + " from the distribution (see above for behavior if ``high=None``).\n", + " If array-like, must contain integer values\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " single value is returned.\n", + " dtype : dtype, optional\n", + " Desired dtype of the result. Byteorder must be native.\n", + " The default value is long.\n", + "\n", + " .. warning::\n", + " This function defaults to the C-long dtype, which is 32bit on windows\n", + " and otherwise 64bit on 64bit platforms (and 32bit on 32bit ones).\n", + " Since NumPy 2.0, NumPy's default integer is 32bit on 32bit platforms\n", + " and 64bit on 64bit platforms. Which corresponds to `np.intp`.\n", + " (`dtype=int` is not the same as in most NumPy functions.)\n", + "\n", + " Returns\n", + " -------\n", + " out : int or ndarray of ints\n", + " `size`-shaped array of random integers from the appropriate\n", + " distribution, or a single such random int if `size` not provided.\n", + "\n", + " See Also\n", + " --------\n", + " random_integers : similar to `randint`, only for the closed\n", + " interval [`low`, `high`], and 1 is the lowest value if `high` is\n", + " omitted.\n", + " random.Generator.integers: which should be used for new code.\n", + "\n", + " Examples\n", + " --------\n", + " >>> np.random.randint(2, size=10)\n", + " array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0]) # random\n", + " >>> np.random.randint(1, size=10)\n", + " array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n", + "\n", + " Generate a 2 x 4 array of ints between 0 and 4, inclusive:\n", + "\n", + " >>> np.random.randint(5, size=(2, 4))\n", + " array([[4, 0, 2, 1], # random\n", + " [3, 2, 2, 0]])\n", + "\n", + " Generate a 1 x 3 array with 3 different upper bounds\n", + "\n", + " >>> np.random.randint(1, [3, 5, 10])\n", + " array([2, 2, 9]) # random\n", + "\n", + " Generate a 1 by 3 array with 3 different lower bounds\n", + "\n", + " >>> np.random.randint([1, 5, 7], 10)\n", + " array([9, 8, 7]) # random\n", + "\n", + " Generate a 2 by 4 array using broadcasting with dtype of uint8\n", + "\n", + " >>> np.random.randint([1, 3, 5, 7], [[10], [20]], dtype=np.uint8)\n", + " array([[ 8, 6, 9, 7], # random\n", + " [ 1, 16, 9, 12]], dtype=uint8)\n", + "\n", + " randn(*args) method of numpy.random.mtrand.RandomState instance\n", + " randn(d0, d1, ..., dn)\n", + "\n", + " Return a sample (or samples) from the \"standard normal\" distribution.\n", + "\n", + " .. note::\n", + " This is a convenience function for users porting code from Matlab,\n", + " and wraps `standard_normal`. That function takes a\n", + " tuple to specify the size of the output, which is consistent with\n", + " other NumPy functions like `numpy.zeros` and `numpy.ones`.\n", + "\n", + " .. note::\n", + " New code should use the\n", + " `~numpy.random.Generator.standard_normal`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " If positive int_like arguments are provided, `randn` generates an array\n", + " of shape ``(d0, d1, ..., dn)``, filled\n", + " with random floats sampled from a univariate \"normal\" (Gaussian)\n", + " distribution of mean 0 and variance 1. A single float randomly sampled\n", + " from the distribution is returned if no argument is provided.\n", + "\n", + " Parameters\n", + " ----------\n", + " d0, d1, ..., dn : int, optional\n", + " The dimensions of the returned array, must be non-negative.\n", + " If no argument is given a single Python float is returned.\n", + "\n", + " Returns\n", + " -------\n", + " Z : ndarray or float\n", + " A ``(d0, d1, ..., dn)``-shaped array of floating-point samples from\n", + " the standard normal distribution, or a single such float if\n", + " no parameters were supplied.\n", + "\n", + " See Also\n", + " --------\n", + " standard_normal : Similar, but takes a tuple as its argument.\n", + " normal : Also accepts mu and sigma arguments.\n", + " random.Generator.standard_normal: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " For random samples from the normal distribution with mean ``mu`` and\n", + " standard deviation ``sigma``, use::\n", + "\n", + " sigma * np.random.randn(...) + mu\n", + "\n", + " Examples\n", + " --------\n", + " >>> np.random.randn()\n", + " 2.1923875335537315 # random\n", + "\n", + " Two-by-four array of samples from the normal distribution with\n", + " mean 3 and standard deviation 2.5:\n", + "\n", + " >>> 3 + 2.5 * np.random.randn(2, 4)\n", + " array([[-4.49401501, 4.00950034, -1.81814867, 7.29718677], # random\n", + " [ 0.39924804, 4.68456316, 4.99394529, 4.84057254]]) # random\n", + "\n", + " random(size=None) method of numpy.random.mtrand.RandomState instance\n", + " random(size=None)\n", + "\n", + " Return random floats in the half-open interval [0.0, 1.0). Alias for\n", + " `random_sample` to ease forward-porting to the new random API.\n", + "\n", + " random_integers(low, high=None, size=None) method of numpy.random.mtrand.RandomState instance\n", + " random_integers(low, high=None, size=None)\n", + "\n", + " Random integers of type `numpy.int_` between `low` and `high`, inclusive.\n", + "\n", + " Return random integers of type `numpy.int_` from the \"discrete uniform\"\n", + " distribution in the closed interval [`low`, `high`]. If `high` is\n", + " None (the default), then results are from [1, `low`]. The `numpy.int_`\n", + " type translates to the C long integer type and its precision\n", + " is platform dependent.\n", + "\n", + " This function has been deprecated. Use randint instead.\n", + "\n", + " .. deprecated:: 1.11.0\n", + "\n", + " Parameters\n", + " ----------\n", + " low : int\n", + " Lowest (signed) integer to be drawn from the distribution (unless\n", + " ``high=None``, in which case this parameter is the *highest* such\n", + " integer).\n", + " high : int, optional\n", + " If provided, the largest (signed) integer to be drawn from the\n", + " distribution (see above for behavior if ``high=None``).\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " single value is returned.\n", + "\n", + " Returns\n", + " -------\n", + " out : int or ndarray of ints\n", + " `size`-shaped array of random integers from the appropriate\n", + " distribution, or a single such random int if `size` not provided.\n", + "\n", + " See Also\n", + " --------\n", + " randint : Similar to `random_integers`, only for the half-open\n", + " interval [`low`, `high`), and 0 is the lowest value if `high` is\n", + " omitted.\n", + "\n", + " Notes\n", + " -----\n", + " To sample from N evenly spaced floating-point numbers between a and b,\n", + " use::\n", + "\n", + " a + (b - a) * (np.random.random_integers(N) - 1) / (N - 1.)\n", + "\n", + " Examples\n", + " --------\n", + " >>> np.random.random_integers(5)\n", + " 4 # random\n", + " >>> type(np.random.random_integers(5))\n", + " \n", + " >>> np.random.random_integers(5, size=(3,2))\n", + " array([[5, 4], # random\n", + " [3, 3],\n", + " [4, 5]])\n", + "\n", + " Choose five random numbers from the set of five evenly-spaced\n", + " numbers between 0 and 2.5, inclusive (*i.e.*, from the set\n", + " :math:`{0, 5/8, 10/8, 15/8, 20/8}`):\n", + "\n", + " >>> 2.5 * (np.random.random_integers(5, size=(5,)) - 1) / 4.\n", + " array([ 0.625, 1.25 , 0.625, 0.625, 2.5 ]) # random\n", + "\n", + " Roll two six sided dice 1000 times and sum the results:\n", + "\n", + " >>> d1 = np.random.random_integers(1, 6, 1000)\n", + " >>> d2 = np.random.random_integers(1, 6, 1000)\n", + " >>> dsums = d1 + d2\n", + "\n", + " Display results as a histogram:\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> count, bins, ignored = plt.hist(dsums, 11, density=True)\n", + " >>> plt.show()\n", + "\n", + " random_sample(size=None) method of numpy.random.mtrand.RandomState instance\n", + " random_sample(size=None)\n", + "\n", + " Return random floats in the half-open interval [0.0, 1.0).\n", + "\n", + " Results are from the \"continuous uniform\" distribution over the\n", + " stated interval. To sample :math:`Unif[a, b), b > a` multiply\n", + " the output of `random_sample` by `(b-a)` and add `a`::\n", + "\n", + " (b - a) * random_sample() + a\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.random`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " single value is returned.\n", + "\n", + " Returns\n", + " -------\n", + " out : float or ndarray of floats\n", + " Array of random floats of shape `size` (unless ``size=None``, in which\n", + " case a single float is returned).\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.random: which should be used for new code.\n", + "\n", + " Examples\n", + " --------\n", + " >>> np.random.random_sample()\n", + " 0.47108547995356098 # random\n", + " >>> type(np.random.random_sample())\n", + " \n", + " >>> np.random.random_sample((5,))\n", + " array([ 0.30220482, 0.86820401, 0.1654503 , 0.11659149, 0.54323428]) # random\n", + "\n", + " Three-by-two array of random numbers from [-5, 0):\n", + "\n", + " >>> 5 * np.random.random_sample((3, 2)) - 5\n", + " array([[-3.99149989, -0.52338984], # random\n", + " [-2.99091858, -0.79479508],\n", + " [-1.23204345, -1.75224494]])\n", + "\n", + " ranf(*args, **kwargs)\n", + " This is an alias of `random_sample`. See `random_sample` for the complete\n", + " documentation.\n", + "\n", + " rayleigh(scale=1.0, size=None) method of numpy.random.mtrand.RandomState instance\n", + " rayleigh(scale=1.0, size=None)\n", + "\n", + " Draw samples from a Rayleigh distribution.\n", + "\n", + " The :math:`\\chi` and Weibull distributions are generalizations of the\n", + " Rayleigh.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.rayleigh`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " scale : float or array_like of floats, optional\n", + " Scale, also equals the mode. Must be non-negative. Default is 1.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``scale`` is a scalar. Otherwise,\n", + " ``np.array(scale).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized Rayleigh distribution.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.rayleigh: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability density function for the Rayleigh distribution is\n", + "\n", + " .. math:: P(x;scale) = \\frac{x}{scale^2}e^{\\frac{-x^2}{2 \\cdotp scale^2}}\n", + "\n", + " The Rayleigh distribution would arise, for example, if the East\n", + " and North components of the wind velocity had identical zero-mean\n", + " Gaussian distributions. Then the wind speed would have a Rayleigh\n", + " distribution.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Brighton Webs Ltd., \"Rayleigh Distribution,\"\n", + " https://web.archive.org/web/20090514091424/http://brighton-webs.co.uk:80/distributions/rayleigh.asp\n", + " .. [2] Wikipedia, \"Rayleigh distribution\"\n", + " https://en.wikipedia.org/wiki/Rayleigh_distribution\n", + "\n", + " Examples\n", + " --------\n", + " Draw values from the distribution and plot the histogram\n", + "\n", + " >>> from matplotlib.pyplot import hist\n", + " >>> values = hist(np.random.rayleigh(3, 100000), bins=200, density=True)\n", + "\n", + " Wave heights tend to follow a Rayleigh distribution. If the mean wave\n", + " height is 1 meter, what fraction of waves are likely to be larger than 3\n", + " meters?\n", + "\n", + " >>> meanvalue = 1\n", + " >>> modevalue = np.sqrt(2 / np.pi) * meanvalue\n", + " >>> s = np.random.rayleigh(modevalue, 1000000)\n", + "\n", + " The percentage of waves larger than 3 meters is:\n", + "\n", + " >>> 100.*sum(s>3)/1000000.\n", + " 0.087300000000000003 # random\n", + "\n", + " sample(*args, **kwargs)\n", + " This is an alias of `random_sample`. See `random_sample` for the complete\n", + " documentation.\n", + "\n", + " seed(seed=None)\n", + " seed(seed=None)\n", + "\n", + " Reseed the singleton RandomState instance.\n", + "\n", + " Notes\n", + " -----\n", + " This is a convenience, legacy function that exists to support\n", + " older code that uses the singleton RandomState. Best practice\n", + " is to use a dedicated ``Generator`` instance rather than\n", + " the random variate generation methods exposed directly in\n", + " the random module.\n", + "\n", + " See Also\n", + " --------\n", + " numpy.random.Generator\n", + "\n", + " set_state(state) method of numpy.random.mtrand.RandomState instance\n", + " set_state(state)\n", + "\n", + " Set the internal state of the generator from a tuple.\n", + "\n", + " For use if one has reason to manually (re-)set the internal state of\n", + " the bit generator used by the RandomState instance. By default,\n", + " RandomState uses the \"Mersenne Twister\"[1]_ pseudo-random number\n", + " generating algorithm.\n", + "\n", + " Parameters\n", + " ----------\n", + " state : {tuple(str, ndarray of 624 uints, int, int, float), dict}\n", + " The `state` tuple has the following items:\n", + "\n", + " 1. the string 'MT19937', specifying the Mersenne Twister algorithm.\n", + " 2. a 1-D array of 624 unsigned integers ``keys``.\n", + " 3. an integer ``pos``.\n", + " 4. an integer ``has_gauss``.\n", + " 5. a float ``cached_gaussian``.\n", + "\n", + " If state is a dictionary, it is directly set using the BitGenerators\n", + " `state` property.\n", + "\n", + " Returns\n", + " -------\n", + " out : None\n", + " Returns 'None' on success.\n", + "\n", + " See Also\n", + " --------\n", + " get_state\n", + "\n", + " Notes\n", + " -----\n", + " `set_state` and `get_state` are not needed to work with any of the\n", + " random distributions in NumPy. If the internal state is manually altered,\n", + " the user should know exactly what he/she is doing.\n", + "\n", + " For backwards compatibility, the form (str, array of 624 uints, int) is\n", + " also accepted although it is missing some information about the cached\n", + " Gaussian value: ``state = ('MT19937', keys, pos)``.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] M. Matsumoto and T. Nishimura, \"Mersenne Twister: A\n", + " 623-dimensionally equidistributed uniform pseudorandom number\n", + " generator,\" *ACM Trans. on Modeling and Computer Simulation*,\n", + " Vol. 8, No. 1, pp. 3-30, Jan. 1998.\n", + "\n", + " shuffle(x) method of numpy.random.mtrand.RandomState instance\n", + " shuffle(x)\n", + "\n", + " Modify a sequence in-place by shuffling its contents.\n", + "\n", + " This function only shuffles the array along the first axis of a\n", + " multi-dimensional array. The order of sub-arrays is changed but\n", + " their contents remains the same.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.shuffle`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " x : ndarray or MutableSequence\n", + " The array, list or mutable sequence to be shuffled.\n", + "\n", + " Returns\n", + " -------\n", + " None\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.shuffle: which should be used for new code.\n", + "\n", + " Examples\n", + " --------\n", + " >>> arr = np.arange(10)\n", + " >>> np.random.shuffle(arr)\n", + " >>> arr\n", + " [1 7 5 2 9 4 3 6 0 8] # random\n", + "\n", + " Multi-dimensional arrays are only shuffled along the first axis:\n", + "\n", + " >>> arr = np.arange(9).reshape((3, 3))\n", + " >>> np.random.shuffle(arr)\n", + " >>> arr\n", + " array([[3, 4, 5], # random\n", + " [6, 7, 8],\n", + " [0, 1, 2]])\n", + "\n", + " standard_cauchy(size=None) method of numpy.random.mtrand.RandomState instance\n", + " standard_cauchy(size=None)\n", + "\n", + " Draw samples from a standard Cauchy distribution with mode = 0.\n", + "\n", + " Also known as the Lorentz distribution.\n", + "\n", + " .. note::\n", + " New code should use the\n", + " `~numpy.random.Generator.standard_cauchy`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " single value is returned.\n", + "\n", + " Returns\n", + " -------\n", + " samples : ndarray or scalar\n", + " The drawn samples.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.standard_cauchy: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability density function for the full Cauchy distribution is\n", + "\n", + " .. math:: P(x; x_0, \\gamma) = \\frac{1}{\\pi \\gamma \\bigl[ 1+\n", + " (\\frac{x-x_0}{\\gamma})^2 \\bigr] }\n", + "\n", + " and the Standard Cauchy distribution just sets :math:`x_0=0` and\n", + " :math:`\\gamma=1`\n", + "\n", + " The Cauchy distribution arises in the solution to the driven harmonic\n", + " oscillator problem, and also describes spectral line broadening. It\n", + " also describes the distribution of values at which a line tilted at\n", + " a random angle will cut the x axis.\n", + "\n", + " When studying hypothesis tests that assume normality, seeing how the\n", + " tests perform on data from a Cauchy distribution is a good indicator of\n", + " their sensitivity to a heavy-tailed distribution, since the Cauchy looks\n", + " very much like a Gaussian distribution, but with heavier tails.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] NIST/SEMATECH e-Handbook of Statistical Methods, \"Cauchy\n", + " Distribution\",\n", + " https://www.itl.nist.gov/div898/handbook/eda/section3/eda3663.htm\n", + " .. [2] Weisstein, Eric W. \"Cauchy Distribution.\" From MathWorld--A\n", + " Wolfram Web Resource.\n", + " https://mathworld.wolfram.com/CauchyDistribution.html\n", + " .. [3] Wikipedia, \"Cauchy distribution\"\n", + " https://en.wikipedia.org/wiki/Cauchy_distribution\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples and plot the distribution:\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> s = np.random.standard_cauchy(1000000)\n", + " >>> s = s[(s>-25) & (s<25)] # truncate distribution so it plots well\n", + " >>> plt.hist(s, bins=100)\n", + " >>> plt.show()\n", + "\n", + " standard_exponential(size=None) method of numpy.random.mtrand.RandomState instance\n", + " standard_exponential(size=None)\n", + "\n", + " Draw samples from the standard exponential distribution.\n", + "\n", + " `standard_exponential` is identical to the exponential distribution\n", + " with a scale parameter of 1.\n", + "\n", + " .. note::\n", + " New code should use the\n", + " `~numpy.random.Generator.standard_exponential`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " single value is returned.\n", + "\n", + " Returns\n", + " -------\n", + " out : float or ndarray\n", + " Drawn samples.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.standard_exponential: which should be used for new code.\n", + "\n", + " Examples\n", + " --------\n", + " Output a 3x8000 array:\n", + "\n", + " >>> n = np.random.standard_exponential((3, 8000))\n", + "\n", + " standard_gamma(shape, size=None) method of numpy.random.mtrand.RandomState instance\n", + " standard_gamma(shape, size=None)\n", + "\n", + " Draw samples from a standard Gamma distribution.\n", + "\n", + " Samples are drawn from a Gamma distribution with specified parameters,\n", + " shape (sometimes designated \"k\") and scale=1.\n", + "\n", + " .. note::\n", + " New code should use the\n", + " `~numpy.random.Generator.standard_gamma`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " shape : float or array_like of floats\n", + " Parameter, must be non-negative.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``shape`` is a scalar. Otherwise,\n", + " ``np.array(shape).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized standard gamma distribution.\n", + "\n", + " See Also\n", + " --------\n", + " scipy.stats.gamma : probability density function, distribution or\n", + " cumulative density function, etc.\n", + " random.Generator.standard_gamma: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability density for the Gamma distribution is\n", + "\n", + " .. math:: p(x) = x^{k-1}\\frac{e^{-x/\\theta}}{\\theta^k\\Gamma(k)},\n", + "\n", + " where :math:`k` is the shape and :math:`\\theta` the scale,\n", + " and :math:`\\Gamma` is the Gamma function.\n", + "\n", + " The Gamma distribution is often used to model the times to failure of\n", + " electronic components, and arises naturally in processes for which the\n", + " waiting times between Poisson distributed events are relevant.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Weisstein, Eric W. \"Gamma Distribution.\" From MathWorld--A\n", + " Wolfram Web Resource.\n", + " https://mathworld.wolfram.com/GammaDistribution.html\n", + " .. [2] Wikipedia, \"Gamma distribution\",\n", + " https://en.wikipedia.org/wiki/Gamma_distribution\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples from the distribution:\n", + "\n", + " >>> shape, scale = 2., 1. # mean and width\n", + " >>> s = np.random.standard_gamma(shape, 1000000)\n", + "\n", + " Display the histogram of the samples, along with\n", + " the probability density function:\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> import scipy.special as sps # doctest: +SKIP\n", + " >>> count, bins, ignored = plt.hist(s, 50, density=True)\n", + " >>> y = bins**(shape-1) * ((np.exp(-bins/scale))/ # doctest: +SKIP\n", + " ... (sps.gamma(shape) * scale**shape))\n", + " >>> plt.plot(bins, y, linewidth=2, color='r') # doctest: +SKIP\n", + " >>> plt.show()\n", + "\n", + " standard_normal(size=None) method of numpy.random.mtrand.RandomState instance\n", + " standard_normal(size=None)\n", + "\n", + " Draw samples from a standard Normal distribution (mean=0, stdev=1).\n", + "\n", + " .. note::\n", + " New code should use the\n", + " `~numpy.random.Generator.standard_normal`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. Default is None, in which case a\n", + " single value is returned.\n", + "\n", + " Returns\n", + " -------\n", + " out : float or ndarray\n", + " A floating-point array of shape ``size`` of drawn samples, or a\n", + " single sample if ``size`` was not specified.\n", + "\n", + " See Also\n", + " --------\n", + " normal :\n", + " Equivalent function with additional ``loc`` and ``scale`` arguments\n", + " for setting the mean and standard deviation.\n", + " random.Generator.standard_normal: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " For random samples from the normal distribution with mean ``mu`` and\n", + " standard deviation ``sigma``, use one of::\n", + "\n", + " mu + sigma * np.random.standard_normal(size=...)\n", + " np.random.normal(mu, sigma, size=...)\n", + "\n", + " Examples\n", + " --------\n", + " >>> np.random.standard_normal()\n", + " 2.1923875335537315 #random\n", + "\n", + " >>> s = np.random.standard_normal(8000)\n", + " >>> s\n", + " array([ 0.6888893 , 0.78096262, -0.89086505, ..., 0.49876311, # random\n", + " -0.38672696, -0.4685006 ]) # random\n", + " >>> s.shape\n", + " (8000,)\n", + " >>> s = np.random.standard_normal(size=(3, 4, 2))\n", + " >>> s.shape\n", + " (3, 4, 2)\n", + "\n", + " Two-by-four array of samples from the normal distribution with\n", + " mean 3 and standard deviation 2.5:\n", + "\n", + " >>> 3 + 2.5 * np.random.standard_normal(size=(2, 4))\n", + " array([[-4.49401501, 4.00950034, -1.81814867, 7.29718677], # random\n", + " [ 0.39924804, 4.68456316, 4.99394529, 4.84057254]]) # random\n", + "\n", + " standard_t(df, size=None) method of numpy.random.mtrand.RandomState instance\n", + " standard_t(df, size=None)\n", + "\n", + " Draw samples from a standard Student's t distribution with `df` degrees\n", + " of freedom.\n", + "\n", + " A special case of the hyperbolic distribution. As `df` gets\n", + " large, the result resembles that of the standard normal\n", + " distribution (`standard_normal`).\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.standard_t`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " df : float or array_like of floats\n", + " Degrees of freedom, must be > 0.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``df`` is a scalar. Otherwise,\n", + " ``np.array(df).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized standard Student's t distribution.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.standard_t: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability density function for the t distribution is\n", + "\n", + " .. math:: P(x, df) = \\frac{\\Gamma(\\frac{df+1}{2})}{\\sqrt{\\pi df}\n", + " \\Gamma(\\frac{df}{2})}\\Bigl( 1+\\frac{x^2}{df} \\Bigr)^{-(df+1)/2}\n", + "\n", + " The t test is based on an assumption that the data come from a\n", + " Normal distribution. The t test provides a way to test whether\n", + " the sample mean (that is the mean calculated from the data) is\n", + " a good estimate of the true mean.\n", + "\n", + " The derivation of the t-distribution was first published in\n", + " 1908 by William Gosset while working for the Guinness Brewery\n", + " in Dublin. Due to proprietary issues, he had to publish under\n", + " a pseudonym, and so he used the name Student.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Dalgaard, Peter, \"Introductory Statistics With R\",\n", + " Springer, 2002.\n", + " .. [2] Wikipedia, \"Student's t-distribution\"\n", + " https://en.wikipedia.org/wiki/Student's_t-distribution\n", + "\n", + " Examples\n", + " --------\n", + " From Dalgaard page 83 [1]_, suppose the daily energy intake for 11\n", + " women in kilojoules (kJ) is:\n", + "\n", + " >>> intake = np.array([5260., 5470, 5640, 6180, 6390, 6515, 6805, 7515, \\\n", + " ... 7515, 8230, 8770])\n", + "\n", + " Does their energy intake deviate systematically from the recommended\n", + " value of 7725 kJ? Our null hypothesis will be the absence of deviation,\n", + " and the alternate hypothesis will be the presence of an effect that could be\n", + " either positive or negative, hence making our test 2-tailed.\n", + "\n", + " Because we are estimating the mean and we have N=11 values in our sample,\n", + " we have N-1=10 degrees of freedom. We set our significance level to 95% and\n", + " compute the t statistic using the empirical mean and empirical standard\n", + " deviation of our intake. We use a ddof of 1 to base the computation of our\n", + " empirical standard deviation on an unbiased estimate of the variance (note:\n", + " the final estimate is not unbiased due to the concave nature of the square\n", + " root).\n", + "\n", + " >>> np.mean(intake)\n", + " 6753.636363636364\n", + " >>> intake.std(ddof=1)\n", + " 1142.1232221373727\n", + " >>> t = (np.mean(intake)-7725)/(intake.std(ddof=1)/np.sqrt(len(intake)))\n", + " >>> t\n", + " -2.8207540608310198\n", + "\n", + " We draw 1000000 samples from Student's t distribution with the adequate\n", + " degrees of freedom.\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> s = np.random.standard_t(10, size=1000000)\n", + " >>> h = plt.hist(s, bins=100, density=True)\n", + "\n", + " Does our t statistic land in one of the two critical regions found at\n", + " both tails of the distribution?\n", + "\n", + " >>> np.sum(np.abs(t) < np.abs(s)) / float(len(s))\n", + " 0.018318 #random < 0.05, statistic is in critical region\n", + "\n", + " The probability value for this 2-tailed test is about 1.83%, which is\n", + " lower than the 5% pre-determined significance threshold.\n", + "\n", + " Therefore, the probability of observing values as extreme as our intake\n", + " conditionally on the null hypothesis being true is too low, and we reject\n", + " the null hypothesis of no deviation.\n", + "\n", + " triangular(left, mode, right, size=None) method of numpy.random.mtrand.RandomState instance\n", + " triangular(left, mode, right, size=None)\n", + "\n", + " Draw samples from the triangular distribution over the\n", + " interval ``[left, right]``.\n", + "\n", + " The triangular distribution is a continuous probability\n", + " distribution with lower limit left, peak at mode, and upper\n", + " limit right. Unlike the other distributions, these parameters\n", + " directly define the shape of the pdf.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.triangular`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " left : float or array_like of floats\n", + " Lower limit.\n", + " mode : float or array_like of floats\n", + " The value where the peak of the distribution occurs.\n", + " The value must fulfill the condition ``left <= mode <= right``.\n", + " right : float or array_like of floats\n", + " Upper limit, must be larger than `left`.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``left``, ``mode``, and ``right``\n", + " are all scalars. Otherwise, ``np.broadcast(left, mode, right).size``\n", + " samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized triangular distribution.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.triangular: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability density function for the triangular distribution is\n", + "\n", + " .. math:: P(x;l, m, r) = \\begin{cases}\n", + " \\frac{2(x-l)}{(r-l)(m-l)}& \\text{for $l \\leq x \\leq m$},\\\\\n", + " \\frac{2(r-x)}{(r-l)(r-m)}& \\text{for $m \\leq x \\leq r$},\\\\\n", + " 0& \\text{otherwise}.\n", + " \\end{cases}\n", + "\n", + " The triangular distribution is often used in ill-defined\n", + " problems where the underlying distribution is not known, but\n", + " some knowledge of the limits and mode exists. Often it is used\n", + " in simulations.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Wikipedia, \"Triangular distribution\"\n", + " https://en.wikipedia.org/wiki/Triangular_distribution\n", + "\n", + " Examples\n", + " --------\n", + " Draw values from the distribution and plot the histogram:\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> h = plt.hist(np.random.triangular(-3, 0, 8, 100000), bins=200,\n", + " ... density=True)\n", + " >>> plt.show()\n", + "\n", + " uniform(low=0.0, high=1.0, size=None) method of numpy.random.mtrand.RandomState instance\n", + " uniform(low=0.0, high=1.0, size=None)\n", + "\n", + " Draw samples from a uniform distribution.\n", + "\n", + " Samples are uniformly distributed over the half-open interval\n", + " ``[low, high)`` (includes low, but excludes high). In other words,\n", + " any value within the given interval is equally likely to be drawn\n", + " by `uniform`.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.uniform`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " low : float or array_like of floats, optional\n", + " Lower boundary of the output interval. All values generated will be\n", + " greater than or equal to low. The default value is 0.\n", + " high : float or array_like of floats\n", + " Upper boundary of the output interval. All values generated will be\n", + " less than or equal to high. The high limit may be included in the\n", + " returned array of floats due to floating-point rounding in the\n", + " equation ``low + (high-low) * random_sample()``. The default value\n", + " is 1.0.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``low`` and ``high`` are both scalars.\n", + " Otherwise, ``np.broadcast(low, high).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized uniform distribution.\n", + "\n", + " See Also\n", + " --------\n", + " randint : Discrete uniform distribution, yielding integers.\n", + " random_integers : Discrete uniform distribution over the closed\n", + " interval ``[low, high]``.\n", + " random_sample : Floats uniformly distributed over ``[0, 1)``.\n", + " random : Alias for `random_sample`.\n", + " rand : Convenience function that accepts dimensions as input, e.g.,\n", + " ``rand(2,2)`` would generate a 2-by-2 array of floats,\n", + " uniformly distributed over ``[0, 1)``.\n", + " random.Generator.uniform: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability density function of the uniform distribution is\n", + "\n", + " .. math:: p(x) = \\frac{1}{b - a}\n", + "\n", + " anywhere within the interval ``[a, b)``, and zero elsewhere.\n", + "\n", + " When ``high`` == ``low``, values of ``low`` will be returned.\n", + " If ``high`` < ``low``, the results are officially undefined\n", + " and may eventually raise an error, i.e. do not rely on this\n", + " function to behave when passed arguments satisfying that\n", + " inequality condition. The ``high`` limit may be included in the\n", + " returned array of floats due to floating-point rounding in the\n", + " equation ``low + (high-low) * random_sample()``. For example:\n", + "\n", + " >>> x = np.float32(5*0.99999999)\n", + " >>> x\n", + " np.float32(5.0)\n", + "\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples from the distribution:\n", + "\n", + " >>> s = np.random.uniform(-1,0,1000)\n", + "\n", + " All values are within the given interval:\n", + "\n", + " >>> np.all(s >= -1)\n", + " True\n", + " >>> np.all(s < 0)\n", + " True\n", + "\n", + " Display the histogram of the samples, along with the\n", + " probability density function:\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> count, bins, ignored = plt.hist(s, 15, density=True)\n", + " >>> plt.plot(bins, np.ones_like(bins), linewidth=2, color='r')\n", + " >>> plt.show()\n", + "\n", + " vonmises(mu, kappa, size=None) method of numpy.random.mtrand.RandomState instance\n", + " vonmises(mu, kappa, size=None)\n", + "\n", + " Draw samples from a von Mises distribution.\n", + "\n", + " Samples are drawn from a von Mises distribution with specified mode\n", + " (mu) and concentration (kappa), on the interval [-pi, pi].\n", + "\n", + " The von Mises distribution (also known as the circular normal\n", + " distribution) is a continuous probability distribution on the unit\n", + " circle. It may be thought of as the circular analogue of the normal\n", + " distribution.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.vonmises`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " mu : float or array_like of floats\n", + " Mode (\"center\") of the distribution.\n", + " kappa : float or array_like of floats\n", + " Concentration of the distribution, has to be >=0.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``mu`` and ``kappa`` are both scalars.\n", + " Otherwise, ``np.broadcast(mu, kappa).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized von Mises distribution.\n", + "\n", + " See Also\n", + " --------\n", + " scipy.stats.vonmises : probability density function, distribution, or\n", + " cumulative density function, etc.\n", + " random.Generator.vonmises: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability density for the von Mises distribution is\n", + "\n", + " .. math:: p(x) = \\frac{e^{\\kappa cos(x-\\mu)}}{2\\pi I_0(\\kappa)},\n", + "\n", + " where :math:`\\mu` is the mode and :math:`\\kappa` the concentration,\n", + " and :math:`I_0(\\kappa)` is the modified Bessel function of order 0.\n", + "\n", + " The von Mises is named for Richard Edler von Mises, who was born in\n", + " Austria-Hungary, in what is now the Ukraine. He fled to the United\n", + " States in 1939 and became a professor at Harvard. He worked in\n", + " probability theory, aerodynamics, fluid mechanics, and philosophy of\n", + " science.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Abramowitz, M. and Stegun, I. A. (Eds.). \"Handbook of\n", + " Mathematical Functions with Formulas, Graphs, and Mathematical\n", + " Tables, 9th printing,\" New York: Dover, 1972.\n", + " .. [2] von Mises, R., \"Mathematical Theory of Probability\n", + " and Statistics\", New York: Academic Press, 1964.\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples from the distribution:\n", + "\n", + " >>> mu, kappa = 0.0, 4.0 # mean and concentration\n", + " >>> s = np.random.vonmises(mu, kappa, 1000)\n", + "\n", + " Display the histogram of the samples, along with\n", + " the probability density function:\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> from scipy.special import i0 # doctest: +SKIP\n", + " >>> plt.hist(s, 50, density=True)\n", + " >>> x = np.linspace(-np.pi, np.pi, num=51)\n", + " >>> y = np.exp(kappa*np.cos(x-mu))/(2*np.pi*i0(kappa)) # doctest: +SKIP\n", + " >>> plt.plot(x, y, linewidth=2, color='r') # doctest: +SKIP\n", + " >>> plt.show()\n", + "\n", + " wald(mean, scale, size=None) method of numpy.random.mtrand.RandomState instance\n", + " wald(mean, scale, size=None)\n", + "\n", + " Draw samples from a Wald, or inverse Gaussian, distribution.\n", + "\n", + " As the scale approaches infinity, the distribution becomes more like a\n", + " Gaussian. Some references claim that the Wald is an inverse Gaussian\n", + " with mean equal to 1, but this is by no means universal.\n", + "\n", + " The inverse Gaussian distribution was first studied in relationship to\n", + " Brownian motion. In 1956 M.C.K. Tweedie used the name inverse Gaussian\n", + " because there is an inverse relationship between the time to cover a\n", + " unit distance and distance covered in unit time.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.wald`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " mean : float or array_like of floats\n", + " Distribution mean, must be > 0.\n", + " scale : float or array_like of floats\n", + " Scale parameter, must be > 0.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``mean`` and ``scale`` are both scalars.\n", + " Otherwise, ``np.broadcast(mean, scale).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized Wald distribution.\n", + "\n", + " See Also\n", + " --------\n", + " random.Generator.wald: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability density function for the Wald distribution is\n", + "\n", + " .. math:: P(x;mean,scale) = \\sqrt{\\frac{scale}{2\\pi x^3}}e^\n", + " \\frac{-scale(x-mean)^2}{2\\cdotp mean^2x}\n", + "\n", + " As noted above the inverse Gaussian distribution first arise\n", + " from attempts to model Brownian motion. It is also a\n", + " competitor to the Weibull for use in reliability modeling and\n", + " modeling stock returns and interest rate processes.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Brighton Webs Ltd., Wald Distribution,\n", + " https://web.archive.org/web/20090423014010/http://www.brighton-webs.co.uk:80/distributions/wald.asp\n", + " .. [2] Chhikara, Raj S., and Folks, J. Leroy, \"The Inverse Gaussian\n", + " Distribution: Theory : Methodology, and Applications\", CRC Press,\n", + " 1988.\n", + " .. [3] Wikipedia, \"Inverse Gaussian distribution\"\n", + " https://en.wikipedia.org/wiki/Inverse_Gaussian_distribution\n", + "\n", + " Examples\n", + " --------\n", + " Draw values from the distribution and plot the histogram:\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> h = plt.hist(np.random.wald(3, 2, 100000), bins=200, density=True)\n", + " >>> plt.show()\n", + "\n", + " weibull(a, size=None) method of numpy.random.mtrand.RandomState instance\n", + " weibull(a, size=None)\n", + "\n", + " Draw samples from a Weibull distribution.\n", + "\n", + " Draw samples from a 1-parameter Weibull distribution with the given\n", + " shape parameter `a`.\n", + "\n", + " .. math:: X = (-ln(U))^{1/a}\n", + "\n", + " Here, U is drawn from the uniform distribution over (0,1].\n", + "\n", + " The more common 2-parameter Weibull, including a scale parameter\n", + " :math:`\\lambda` is just :math:`X = \\lambda(-ln(U))^{1/a}`.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.weibull`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " a : float or array_like of floats\n", + " Shape parameter of the distribution. Must be nonnegative.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``a`` is a scalar. Otherwise,\n", + " ``np.array(a).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized Weibull distribution.\n", + "\n", + " See Also\n", + " --------\n", + " scipy.stats.weibull_max\n", + " scipy.stats.weibull_min\n", + " scipy.stats.genextreme\n", + " gumbel\n", + " random.Generator.weibull: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The Weibull (or Type III asymptotic extreme value distribution\n", + " for smallest values, SEV Type III, or Rosin-Rammler\n", + " distribution) is one of a class of Generalized Extreme Value\n", + " (GEV) distributions used in modeling extreme value problems.\n", + " This class includes the Gumbel and Frechet distributions.\n", + "\n", + " The probability density for the Weibull distribution is\n", + "\n", + " .. math:: p(x) = \\frac{a}\n", + " {\\lambda}(\\frac{x}{\\lambda})^{a-1}e^{-(x/\\lambda)^a},\n", + "\n", + " where :math:`a` is the shape and :math:`\\lambda` the scale.\n", + "\n", + " The function has its peak (the mode) at\n", + " :math:`\\lambda(\\frac{a-1}{a})^{1/a}`.\n", + "\n", + " When ``a = 1``, the Weibull distribution reduces to the exponential\n", + " distribution.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Waloddi Weibull, Royal Technical University, Stockholm,\n", + " 1939 \"A Statistical Theory Of The Strength Of Materials\",\n", + " Ingeniorsvetenskapsakademiens Handlingar Nr 151, 1939,\n", + " Generalstabens Litografiska Anstalts Forlag, Stockholm.\n", + " .. [2] Waloddi Weibull, \"A Statistical Distribution Function of\n", + " Wide Applicability\", Journal Of Applied Mechanics ASME Paper\n", + " 1951.\n", + " .. [3] Wikipedia, \"Weibull distribution\",\n", + " https://en.wikipedia.org/wiki/Weibull_distribution\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples from the distribution:\n", + "\n", + " >>> a = 5. # shape\n", + " >>> s = np.random.weibull(a, 1000)\n", + "\n", + " Display the histogram of the samples, along with\n", + " the probability density function:\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> x = np.arange(1,100.)/50.\n", + " >>> def weib(x,n,a):\n", + " ... return (a / n) * (x / n)**(a - 1) * np.exp(-(x / n)**a)\n", + "\n", + " >>> count, bins, ignored = plt.hist(np.random.weibull(5.,1000))\n", + " >>> x = np.arange(1,100.)/50.\n", + " >>> scale = count.max()/weib(x, 1., 5.).max()\n", + " >>> plt.plot(x, weib(x, 1., 5.)*scale)\n", + " >>> plt.show()\n", + "\n", + " zipf(a, size=None) method of numpy.random.mtrand.RandomState instance\n", + " zipf(a, size=None)\n", + "\n", + " Draw samples from a Zipf distribution.\n", + "\n", + " Samples are drawn from a Zipf distribution with specified parameter\n", + " `a` > 1.\n", + "\n", + " The Zipf distribution (also known as the zeta distribution) is a\n", + " discrete probability distribution that satisfies Zipf's law: the\n", + " frequency of an item is inversely proportional to its rank in a\n", + " frequency table.\n", + "\n", + " .. note::\n", + " New code should use the `~numpy.random.Generator.zipf`\n", + " method of a `~numpy.random.Generator` instance instead;\n", + " please see the :ref:`random-quick-start`.\n", + "\n", + " Parameters\n", + " ----------\n", + " a : float or array_like of floats\n", + " Distribution parameter. Must be greater than 1.\n", + " size : int or tuple of ints, optional\n", + " Output shape. If the given shape is, e.g., ``(m, n, k)``, then\n", + " ``m * n * k`` samples are drawn. If size is ``None`` (default),\n", + " a single value is returned if ``a`` is a scalar. Otherwise,\n", + " ``np.array(a).size`` samples are drawn.\n", + "\n", + " Returns\n", + " -------\n", + " out : ndarray or scalar\n", + " Drawn samples from the parameterized Zipf distribution.\n", + "\n", + " See Also\n", + " --------\n", + " scipy.stats.zipf : probability density function, distribution, or\n", + " cumulative density function, etc.\n", + " random.Generator.zipf: which should be used for new code.\n", + "\n", + " Notes\n", + " -----\n", + " The probability mass function (PMF) for the Zipf distribution is\n", + "\n", + " .. math:: p(k) = \\frac{k^{-a}}{\\zeta(a)},\n", + "\n", + " for integers :math:`k \\geq 1`, where :math:`\\zeta` is the Riemann Zeta\n", + " function.\n", + "\n", + " It is named for the American linguist George Kingsley Zipf, who noted\n", + " that the frequency of any word in a sample of a language is inversely\n", + " proportional to its rank in the frequency table.\n", + "\n", + " References\n", + " ----------\n", + " .. [1] Zipf, G. K., \"Selected Studies of the Principle of Relative\n", + " Frequency in Language,\" Cambridge, MA: Harvard Univ. Press,\n", + " 1932.\n", + "\n", + " Examples\n", + " --------\n", + " Draw samples from the distribution:\n", + "\n", + " >>> a = 4.0\n", + " >>> n = 20000\n", + " >>> s = np.random.zipf(a, n)\n", + "\n", + " Display the histogram of the samples, along with\n", + " the expected histogram based on the probability\n", + " density function:\n", + "\n", + " >>> import matplotlib.pyplot as plt\n", + " >>> from scipy.special import zeta # doctest: +SKIP\n", + "\n", + " `bincount` provides a fast histogram for small integers.\n", + "\n", + " >>> count = np.bincount(s)\n", + " >>> k = np.arange(1, s.max() + 1)\n", + "\n", + " >>> plt.bar(k, count[1:], alpha=0.5, label='sample count')\n", + " >>> plt.plot(k, n*(k**-a)/zeta(a), 'k.-', alpha=0.5,\n", + " ... label='expected count') # doctest: +SKIP\n", + " >>> plt.semilogy()\n", + " >>> plt.grid(alpha=0.4)\n", + " >>> plt.legend()\n", + " >>> plt.title(f'Zipf sample, a={a}, size={n}')\n", + " >>> plt.show()\n", + "\n", + "DATA\n", + " __all__ = ['beta', 'binomial', 'bytes', 'chisquare', 'choice', 'dirich...\n", + "\n", + "FILE\n", + " /Users/krishna/Github Projects/Python_Codes/.venv/lib/python3.12/site-packages/numpy/random/__init__.py\n", + "\n", + "\n" + ] + } + ], + "source": [ + "help(np.random)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['rand', 'randint', 'randn', 'random', 'random_integers', 'random_sample']\n" + ] + } + ], + "source": [ + "# print(\"\\n\".join(dir(np.random)))\n", + "\n", + "l = [x for x in dir(np.random) if x.startswith('rand')]\n", + "print(l)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " random(size=None)\n", + "\n", + " Return random floats in the half-open interval [0.0, 1.0). Alias for\n", + " `random_sample` to ease forward-porting to the new random API.\n", + " \n", + "[0.0522319 0.86097596 0.5949323 0.70050462 0.03705692 0.2162239\n", + " 0.70763079 0.75203006 0.60034062 0.5194058 0.90711348 0.85074071\n", + " 0.78160859 0.88343916 0.20950278 0.52756511 0.37839439 0.37737909\n", + " 0.53773977 0.56732587 0.69277868 0.70555609 0.75678495 0.243224\n", + " 0.58821656 0.23304631 0.30625331 0.42618465 0.17652946 0.52304341\n", + " 0.89926665 0.82058935 0.84776799 0.57147929 0.3505355 0.75000648\n", + " 0.31350361 0.78181948 0.94912502 0.11707903 0.99565647 0.98579648\n", + " 0.93546862 0.94061148 0.81146049 0.88473338 0.24415951 0.74901852\n", + " 0.91058259 0.15135872 0.98555646 0.89959558 0.99190224 0.75498013\n", + " 0.26713654 0.06617613 0.88222829 0.75947129 0.02738074 0.8078397\n", + " 0.38359591 0.47654313 0.00690508 0.19918179 0.80755677 0.55288436\n", + " 0.23326657 0.65854358 0.01035514 0.3765133 0.38306361 0.98800049\n", + " 0.13989193 0.28907474 0.49800448 0.65561975 0.43807675 0.25031693\n", + " 0.57204363 0.17136936 0.00938998 0.57396467 0.53272649 0.8461976\n", + " 0.5044597 0.14106267 0.3935775 0.964319 0.8875512 0.02845842\n", + " 0.91326176 0.99759709 0.98328059 0.92210783 0.3985288 0.36663955\n", + " 0.64794815 0.36459583 0.32271727 0.08406373 0.76078181 0.04174265\n", + " 0.50028313 0.43352795 0.36903826 0.86083212 0.47872894 0.40343096\n", + " 0.06857677 0.82698276 0.5524679 0.38050411 0.82020832 0.34671858\n", + " 0.41032589 0.51527381 0.09171761 0.78488377 0.33289959 0.67790606\n", + " 0.60414704 0.3072119 0.69734428 0.94469003 0.36903761 0.65623432\n", + " 0.53038103 0.356435 0.22229291 0.27365121 0.35736837 0.82864652\n", + " 0.37637924 0.69928755 0.25013133 0.54617408 0.22892735 0.42072691\n", + " 0.70583068 0.96282291 0.1964836 0.9799331 0.18919833 0.07218442\n", + " 0.3750774 0.20812402 0.82161378 0.41877954 0.04054913 0.62818416\n", + " 0.27824214 0.35813623 0.72713174 0.60454025 0.06212605 0.81372161\n", + " 0.81927336 0.43711337 0.8670371 0.12825545 0.06092558 0.50834456\n", + " 0.8201934 0.60199332 0.94949304 0.48742823 0.48208351 0.37181231\n", + " 0.59618792 0.7453354 0.68977701 0.13775754 0.43895311 0.34504085\n", + " 0.21945118 0.55519072 0.61660157 0.33804465 0.96794745 0.28699036\n", + " 0.32707711 0.04376481 0.78341741 0.28179574 0.74046107 0.5886916\n", + " 0.19444852 0.2440456 0.3238199 0.13891744 0.3904282 0.94180583\n", + " 0.04589152 0.08196945 0.03320912 0.79155549 0.17149585 0.67319527\n", + " 0.2696951 0.25534677]\n" + ] + } + ], + "source": [ + "# print(np.random.random_sample(30))\n", + "# print(np.random.random_sample.__doc__)\n", + "\n", + "# print(np.random.random_integers(2,30000))\n", + "# print(np.random.random_integers.__doc__)\n", + "\n", + "print(np.random.random.__doc__)\n", + "print(np.random.random(200))\n", + "\n", + "# print(np.random.randn(2,30))\n", + "# print(np.random.randn.__doc__)\n", + "\n", + "# print(np.random.randint.__doc__)\n", + "# print(np.random.randint(2,30))\n", + "\n", + "# print(np.random.rand.__doc__)\n", + "# print(np.random.rand(2,3,4))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "A", + "rawType": "float64", + "type": "float" + }, + { + "name": "B", + "rawType": "int64", + "type": "integer" + }, + { + "name": "C", + "rawType": "float64", + "type": "float" + } + ], + "conversionMethod": "pd.DataFrame", + "ref": "26b5431b-6d43-44cc-b361-a44f2cafaaf0", + "rows": [ + [ + "0", + "-1.4393130228047484", + "22", + "-0.429961207877459" + ], + [ + "1", + "-1.091406759098203", + "22", + "3.1214346372871735" + ], + [ + "2", + "-0.7178738578864597", + "22", + "-0.034496747811079795" + ], + [ + "3", + "1.1153627823555052", + "22", + "0.04046211680518889" + ], + [ + "4", + "-2.7082695726357917", + "22", + "0.4770491629387382" + ], + [ + "5", + "-0.7861071430399413", + "22", + "-2.017289394158469" + ], + [ + "6", + "-0.4473465578409842", + "22", + "2.0329143957161024" + ], + [ + "7", + "1.3081184060091962", + "22", + "-1.6247092129146894" + ], + [ + "8", + "0.14343341341900628", + "22", + "0.41579679904117595" + ], + [ + "9", + "0.4423767219222803", + "22", + "-0.35784076597845665" + ], + [ + "10", + "0.9031762931168485", + "22", + "-0.7188545452044268" + ], + [ + "11", + "0.3250031415359289", + "22", + "0.1854506382475213" + ], + [ + "12", + "0.4000828148833142", + "22", + "-0.37066978979270776" + ], + [ + "13", + "0.3340771297161135", + "22", + "-0.391222940466054" + ], + [ + "14", + "-0.6618072132548062", + "22", + "-1.4217163033542246" + ], + [ + "15", + "-0.13624629365453647", + "22", + "0.581453883723803" + ], + [ + "16", + "1.0409419538362652", + "22", + "-0.4599815130735636" + ], + [ + "17", + "-0.49246439422633914", + "22", + "0.8545761208394194" + ], + [ + "18", + "-0.9244302513670836", + "22", + "0.2961601642078916" + ], + [ + "19", + "0.6934064760035118", + "22", + "-0.6872167204104863" + ], + [ + "20", + "-0.10831614734568341", + "22", + "-0.507857653311998" + ], + [ + "21", + "0.5395893265284709", + "22", + "0.6155090374686493" + ], + [ + "22", + "-1.4324864016543815", + "22", + "-0.13700059656114802" + ], + [ + "23", + "-2.341210447116743", + "22", + "-0.28409965290599404" + ], + [ + "24", + "-0.40831323560863325", + "22", + "1.1709296754916232" + ], + [ + "25", + "2.7065518245305524", + "22", + "0.6333069254704857" + ], + [ + "26", + "-1.4585866229185072", + "22", + "-2.248829542359628" + ], + [ + "27", + "-0.3750760375623893", + "22", + "0.7642785829917098" + ], + [ + "28", + "1.1281426914481283", + "22", + "-0.7076006387190027" + ], + [ + "29", + "-0.8546217167230873", + "22", + "0.21718543590762063" + ], + [ + "30", + "0.3030546980402073", + "22", + "1.268388390090179" + ], + [ + "31", + "1.7579101309924454", + "22", + "2.7259222458195165" + ], + [ + "32", + "-0.05751779010532276", + "22", + "-0.8869915084929053" + ], + [ + "33", + "-1.1273162519613724", + "22", + "0.22575576203876616" + ], + [ + "34", + "1.5245648260883664", + "22", + "-1.1918969620297222" + ], + [ + "35", + "1.0108748031278547", + "22", + "-0.933283779155798" + ], + [ + "36", + "1.375246565196075", + "22", + "0.13800382091728405" + ], + [ + "37", + "0.3485623165050691", + "22", + "-0.09603150928261873" + ], + [ + "38", + "-1.105928796542901", + "22", + "-0.30416466707935363" + ], + [ + "39", + "-0.10188913691494345", + "22", + "1.4069284370344772" + ], + [ + "40", + "0.6229104074543691", + "22", + "1.7942486961093773" + ], + [ + "41", + "-0.3715731618068609", + "22", + "-0.7511367516727725" + ], + [ + "42", + "0.7238727719489159", + "22", + "-0.42975190113449696" + ], + [ + "43", + "-0.11340984672723038", + "22", + "1.8033630534589136" + ], + [ + "44", + "0.835940333388994", + "22", + "1.573461685146302" + ], + [ + "45", + "-0.9415370607415531", + "22", + "0.26859137175988795" + ], + [ + "46", + "-0.0012842991097047752", + "22", + "1.108408403165676" + ], + [ + "47", + "0.4588454323400258", + "22", + "0.0014199362492335204" + ], + [ + "48", + "-0.05091868062208462", + "22", + "0.45371508893796525" + ], + [ + "49", + "-0.9148841179307503", + "22", + "-1.482468481856581" + ] + ], + "shape": { + "columns": 3, + "rows": 300 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ABC
0-1.43931322-0.429961
1-1.091407223.121435
2-0.71787422-0.034497
31.115363220.040462
4-2.708270220.477049
............
2950.518037221.966599
2960.783148221.244444
297-0.655603221.305265
298-0.731128220.213772
299-1.47247522-1.095289
\n", + "

300 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " A B C\n", + "0 -1.439313 22 -0.429961\n", + "1 -1.091407 22 3.121435\n", + "2 -0.717874 22 -0.034497\n", + "3 1.115363 22 0.040462\n", + "4 -2.708270 22 0.477049\n", + ".. ... .. ...\n", + "295 0.518037 22 1.966599\n", + "296 0.783148 22 1.244444\n", + "297 -0.655603 22 1.305265\n", + "298 -0.731128 22 0.213772\n", + "299 -1.472475 22 -1.095289\n", + "\n", + "[300 rows x 3 columns]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "df = pd.DataFrame({\n", + " 'A': np.random.randn(300),\n", + " 'B': np.random.randint(300),\n", + " 'C': np.random.randn(300),\n", + "})\n", + "\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "A", + "rawType": "float64", + "type": "float" + }, + { + "name": "B", + "rawType": "int64", + "type": "integer" + }, + { + "name": "C", + "rawType": "float64", + "type": "float" + }, + { + "name": "Test", + "rawType": "float64", + "type": "float" + } + ], + "conversionMethod": "pd.DataFrame", + "ref": "6e0f5737-ce6c-455a-bf15-915ed30f8f0e", + "rows": [ + [ + "0", + "-1.4393130228047484", + "22", + "-0.429961207877459", + "20.0" + ], + [ + "1", + "-1.091406759098203", + "22", + "3.1214346372871735", + "10.0" + ], + [ + "2", + "-0.7178738578864597", + "22", + "-0.034496747811079795", + "20.0" + ], + [ + "3", + "1.1153627823555052", + "22", + "0.04046211680518889", + "20.0" + ], + [ + "4", + "-2.7082695726357917", + "22", + "0.4770491629387382", + "20.0" + ], + [ + "5", + "-0.7861071430399413", + "22", + "-2.017289394158469", + "20.0" + ], + [ + "6", + "-0.4473465578409842", + "22", + "2.0329143957161024", + "10.0" + ], + [ + "7", + "1.3081184060091962", + "22", + "-1.6247092129146894", + "20.0" + ], + [ + "8", + "0.14343341341900628", + "22", + "0.41579679904117595", + "20.0" + ], + [ + "9", + "0.4423767219222803", + "22", + "-0.35784076597845665", + "20.0" + ], + [ + "10", + "0.9031762931168485", + "22", + "-0.7188545452044268", + "20.0" + ], + [ + "11", + "0.3250031415359289", + "22", + "0.1854506382475213", + "20.0" + ], + [ + "12", + "0.4000828148833142", + "22", + "-0.37066978979270776", + "20.0" + ], + [ + "13", + "0.3340771297161135", + "22", + "-0.391222940466054", + "20.0" + ], + [ + "14", + "-0.6618072132548062", + "22", + "-1.4217163033542246", + "20.0" + ], + [ + "15", + "-0.13624629365453647", + "22", + "0.581453883723803", + "20.0" + ], + [ + "16", + "1.0409419538362652", + "22", + "-0.4599815130735636", + "20.0" + ], + [ + "17", + "-0.49246439422633914", + "22", + "0.8545761208394194", + "20.0" + ], + [ + "18", + "-0.9244302513670836", + "22", + "0.2961601642078916", + "20.0" + ], + [ + "19", + "0.6934064760035118", + "22", + "-0.6872167204104863", + "20.0" + ], + [ + "20", + "-0.10831614734568341", + "22", + "-0.507857653311998", + "20.0" + ], + [ + "21", + "0.5395893265284709", + "22", + "0.6155090374686493", + "20.0" + ], + [ + "22", + "-1.4324864016543815", + "22", + "-0.13700059656114802", + "20.0" + ], + [ + "23", + "-2.341210447116743", + "22", + "-0.28409965290599404", + "20.0" + ], + [ + "24", + "-0.40831323560863325", + "22", + "1.1709296754916232", + "10.0" + ], + [ + "25", + "2.7065518245305524", + "22", + "0.6333069254704857", + "20.0" + ], + [ + "26", + "-1.4585866229185072", + "22", + "-2.248829542359628", + "20.0" + ], + [ + "27", + "-0.3750760375623893", + "22", + "0.7642785829917098", + "20.0" + ], + [ + "28", + "1.1281426914481283", + "22", + "-0.7076006387190027", + "20.0" + ], + [ + "29", + "-0.8546217167230873", + "22", + "0.21718543590762063", + "20.0" + ], + [ + "30", + "0.3030546980402073", + "22", + "1.268388390090179", + "10.0" + ], + [ + "31", + "1.7579101309924454", + "22", + "2.7259222458195165", + "10.0" + ], + [ + "32", + "-0.05751779010532276", + "22", + "-0.8869915084929053", + "20.0" + ], + [ + "33", + "-1.1273162519613724", + "22", + "0.22575576203876616", + "20.0" + ], + [ + "34", + "1.5245648260883664", + "22", + "-1.1918969620297222", + "20.0" + ], + [ + "35", + "1.0108748031278547", + "22", + "-0.933283779155798", + "20.0" + ], + [ + "36", + "1.375246565196075", + "22", + "0.13800382091728405", + "20.0" + ], + [ + "37", + "0.3485623165050691", + "22", + "-0.09603150928261873", + "20.0" + ], + [ + "38", + "-1.105928796542901", + "22", + "-0.30416466707935363", + "20.0" + ], + [ + "39", + "-0.10188913691494345", + "22", + "1.4069284370344772", + "10.0" + ], + [ + "40", + "0.6229104074543691", + "22", + "1.7942486961093773", + "10.0" + ], + [ + "41", + "-0.3715731618068609", + "22", + "-0.7511367516727725", + "20.0" + ], + [ + "42", + "0.7238727719489159", + "22", + "-0.42975190113449696", + "20.0" + ], + [ + "43", + "-0.11340984672723038", + "22", + "1.8033630534589136", + "10.0" + ], + [ + "44", + "0.835940333388994", + "22", + "1.573461685146302", + "10.0" + ], + [ + "45", + "-0.9415370607415531", + "22", + "0.26859137175988795", + "20.0" + ], + [ + "46", + "-0.0012842991097047752", + "22", + "1.108408403165676", + "10.0" + ], + [ + "47", + "0.4588454323400258", + "22", + "0.0014199362492335204", + "20.0" + ], + [ + "48", + "-0.05091868062208462", + "22", + "0.45371508893796525", + "20.0" + ], + [ + "49", + "-0.9148841179307503", + "22", + "-1.482468481856581", + "20.0" + ] + ], + "shape": { + "columns": 4, + "rows": 300 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ABCTest
0-1.43931322-0.42996120.0
1-1.091407223.12143510.0
2-0.71787422-0.03449720.0
31.115363220.04046220.0
4-2.708270220.47704920.0
...............
2950.518037221.96659910.0
2960.783148221.24444410.0
297-0.655603221.30526510.0
298-0.731128220.21377220.0
299-1.47247522-1.09528920.0
\n", + "

300 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " A B C Test\n", + "0 -1.439313 22 -0.429961 20.0\n", + "1 -1.091407 22 3.121435 10.0\n", + "2 -0.717874 22 -0.034497 20.0\n", + "3 1.115363 22 0.040462 20.0\n", + "4 -2.708270 22 0.477049 20.0\n", + ".. ... .. ... ...\n", + "295 0.518037 22 1.966599 10.0\n", + "296 0.783148 22 1.244444 10.0\n", + "297 -0.655603 22 1.305265 10.0\n", + "298 -0.731128 22 0.213772 20.0\n", + "299 -1.472475 22 -1.095289 20.0\n", + "\n", + "[300 rows x 4 columns]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.loc[df['B']>20,'Test'] = df.apply(lambda x: 10 if x['C']>1 else 20, axis=1)\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "A", + "rawType": "float64", + "type": "float" + }, + { + "name": "B", + "rawType": "int64", + "type": "integer" + }, + { + "name": "C", + "rawType": "int64", + "type": "integer" + }, + { + "name": "Test", + "rawType": "float64", + "type": "float" + } + ], + "conversionMethod": "pd.DataFrame", + "ref": "8dcec3ec-b553-4da0-ac27-b6c36fdff517", + "rows": [ + [ + "0", + "-1.4393130228047484", + "22", + "10", + "20.0" + ], + [ + "1", + "-1.091406759098203", + "22", + "10", + "10.0" + ], + [ + "2", + "-0.7178738578864597", + "22", + "10", + "20.0" + ], + [ + "3", + "1.1153627823555052", + "22", + "10", + "20.0" + ], + [ + "4", + "-2.7082695726357917", + "22", + "10", + "20.0" + ], + [ + "5", + "-0.7861071430399413", + "22", + "10", + "20.0" + ], + [ + "6", + "-0.4473465578409842", + "22", + "10", + "10.0" + ], + [ + "7", + "1.3081184060091962", + "22", + "10", + "20.0" + ], + [ + "8", + "0.14343341341900628", + "22", + "10", + "20.0" + ], + [ + "9", + "0.4423767219222803", + "22", + "10", + "20.0" + ], + [ + "10", + "0.9031762931168485", + "22", + "10", + "20.0" + ], + [ + "11", + "0.3250031415359289", + "22", + "10", + "20.0" + ], + [ + "12", + "0.4000828148833142", + "22", + "10", + "20.0" + ], + [ + "13", + "0.3340771297161135", + "22", + "10", + "20.0" + ], + [ + "14", + "-0.6618072132548062", + "22", + "10", + "20.0" + ], + [ + "15", + "-0.13624629365453647", + "22", + "10", + "20.0" + ], + [ + "16", + "1.0409419538362652", + "22", + "10", + "20.0" + ], + [ + "17", + "-0.49246439422633914", + "22", + "10", + "20.0" + ], + [ + "18", + "-0.9244302513670836", + "22", + "10", + "20.0" + ], + [ + "19", + "0.6934064760035118", + "22", + "10", + "20.0" + ], + [ + "20", + "-0.10831614734568341", + "22", + "10", + "20.0" + ], + [ + "21", + "0.5395893265284709", + "22", + "10", + "20.0" + ], + [ + "22", + "-1.4324864016543815", + "22", + "10", + "20.0" + ], + [ + "23", + "-2.341210447116743", + "22", + "10", + "20.0" + ], + [ + "24", + "-0.40831323560863325", + "22", + "10", + "10.0" + ], + [ + "25", + "2.7065518245305524", + "22", + "10", + "20.0" + ], + [ + "26", + "-1.4585866229185072", + "22", + "10", + "20.0" + ], + [ + "27", + "-0.3750760375623893", + "22", + "10", + "20.0" + ], + [ + "28", + "1.1281426914481283", + "22", + "10", + "20.0" + ], + [ + "29", + "-0.8546217167230873", + "22", + "10", + "20.0" + ], + [ + "30", + "0.3030546980402073", + "22", + "10", + "10.0" + ], + [ + "31", + "1.7579101309924454", + "22", + "10", + "10.0" + ], + [ + "32", + "-0.05751779010532276", + "22", + "10", + "20.0" + ], + [ + "33", + "-1.1273162519613724", + "22", + "10", + "20.0" + ], + [ + "34", + "1.5245648260883664", + "22", + "10", + "20.0" + ], + [ + "35", + "1.0108748031278547", + "22", + "10", + "20.0" + ], + [ + "36", + "1.375246565196075", + "22", + "10", + "20.0" + ], + [ + "37", + "0.3485623165050691", + "22", + "10", + "20.0" + ], + [ + "38", + "-1.105928796542901", + "22", + "10", + "20.0" + ], + [ + "39", + "-0.10188913691494345", + "22", + "10", + "10.0" + ], + [ + "40", + "0.6229104074543691", + "22", + "10", + "10.0" + ], + [ + "41", + "-0.3715731618068609", + "22", + "10", + "20.0" + ], + [ + "42", + "0.7238727719489159", + "22", + "10", + "20.0" + ], + [ + "43", + "-0.11340984672723038", + "22", + "10", + "10.0" + ], + [ + "44", + "0.835940333388994", + "22", + "10", + "10.0" + ], + [ + "45", + "-0.9415370607415531", + "22", + "10", + "20.0" + ], + [ + "46", + "-0.0012842991097047752", + "22", + "10", + "10.0" + ], + [ + "47", + "0.4588454323400258", + "22", + "10", + "20.0" + ], + [ + "48", + "-0.05091868062208462", + "22", + "10", + "20.0" + ], + [ + "49", + "-0.9148841179307503", + "22", + "10", + "20.0" + ] + ], + "shape": { + "columns": 4, + "rows": 300 + } + }, + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ABCTest
0-1.439313221020.0
1-1.091407221010.0
2-0.717874221020.0
31.115363221020.0
4-2.708270221020.0
...............
2950.518037221010.0
2960.783148221010.0
297-0.655603221010.0
298-0.731128221020.0
299-1.472475221020.0
\n", + "

300 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " A B C Test\n", + "0 -1.439313 22 10 20.0\n", + "1 -1.091407 22 10 10.0\n", + "2 -0.717874 22 10 20.0\n", + "3 1.115363 22 10 20.0\n", + "4 -2.708270 22 10 20.0\n", + ".. ... .. .. ...\n", + "295 0.518037 22 10 10.0\n", + "296 0.783148 22 10 10.0\n", + "297 -0.655603 22 10 10.0\n", + "298 -0.731128 22 10 20.0\n", + "299 -1.472475 22 10 20.0\n", + "\n", + "[300 rows x 4 columns]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df['C'] = np.where(df['B']>20, 10, 20)\n", + "df" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 42583745dbb596dff26e1690401d7e0d24ee791c Mon Sep 17 00:00:00 2001 From: KRISHNA DIPAYAN BHUNIA Date: Tue, 15 Apr 2025 16:15:11 +0530 Subject: [PATCH 5/9] lintin errors solving --- Basic python/abstract example.ipynb | 4 +- Basic python/duplicate emails.ipynb | 20 +- duplicate emails.ipynb | 1864 +++++++++++++++++++++++++++ 3 files changed, 1876 insertions(+), 12 deletions(-) create mode 100644 duplicate emails.ipynb diff --git a/Basic python/abstract example.ipynb b/Basic python/abstract example.ipynb index 5f2b277..80eecc9 100644 --- a/Basic python/abstract example.ipynb +++ b/Basic python/abstract example.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "id": "299fc2f5", "metadata": {}, "outputs": [ @@ -40,7 +40,7 @@ " def gold(self):\n", " print(\"this is grandparent class gold\")\n", " \n", - " abstractclassmethod\n", + " abstractclassmethod # type: ignore\n", " \n", "class parent(ABC,grandparent):\n", " @abstractmethod\n", diff --git a/Basic python/duplicate emails.ipynb b/Basic python/duplicate emails.ipynb index a53c58d..b1aff1c 100644 --- a/Basic python/duplicate emails.ipynb +++ b/Basic python/duplicate emails.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 95, + "execution_count": null, "id": "145f871d", "metadata": {}, "outputs": [ @@ -89,7 +89,7 @@ } ], "source": [ - "import pandas as pd\n", + "import pandas as pd # type: ignore\n", "path = r\"C:\\Users\\kbhunia\\Downloads\\GDrive Backup Downloads\\Jupyter Notebook Programs\\excel read files\\duplicate emails.csv\"\n", "df = pd.read_csv(path)\n", "df" @@ -1469,7 +1469,7 @@ }, { "cell_type": "code", - "execution_count": 117, + "execution_count": null, "id": "1fea75bc", "metadata": {}, "outputs": [ @@ -1570,7 +1570,7 @@ } ], "source": [ - "import pandas as pd \n", + "import pandas as pd # type: ignore\n", "\n", "# Define a dictionary containing employee data \n", "data1 = {'Name':['Jai', 'Princi', 'Gaurav', 'Anuj'], \n", @@ -1743,13 +1743,13 @@ }, { "cell_type": "code", - "execution_count": 120, + "execution_count": null, "id": "4645ae72", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1759,13 +1759,13 @@ } ], "source": [ - "import matplotlib as plot\n", + "import matplotlib as plot # type: ignore\n", "res3.plot(title = \"Abc\",kind=\"bar\");" ] }, { "cell_type": "code", - "execution_count": 121, + "execution_count": null, "id": "b3b85aae", "metadata": {}, "outputs": [ @@ -1781,7 +1781,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1791,7 +1791,7 @@ } ], "source": [ - "import seaborn as sns\n", + "import seaborn as sns # type: ignore\n", "sns.barplot(res3)" ] }, diff --git a/duplicate emails.ipynb b/duplicate emails.ipynb new file mode 100644 index 0000000..b1aff1c --- /dev/null +++ b/duplicate emails.ipynb @@ -0,0 +1,1864 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "145f871d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idemailrollno
01john@example.com1001
12bob@example.com1002
23john@example.com1003
34abc@example.com1004
45abc@example.com1005
56abc@example.com1006
\n", + "
" + ], + "text/plain": [ + " id email rollno\n", + "0 1 john@example.com 1001\n", + "1 2 bob@example.com 1002\n", + "2 3 john@example.com 1003\n", + "3 4 abc@example.com 1004\n", + "4 5 abc@example.com 1005\n", + "5 6 abc@example.com 1006" + ] + }, + "execution_count": 95, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd # type: ignore\n", + "path = r\"C:\\Users\\kbhunia\\Downloads\\GDrive Backup Downloads\\Jupyter Notebook Programs\\excel read files\\duplicate emails.csv\"\n", + "df = pd.read_csv(path)\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "4839b0f8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "email\n", + "abc@example.com 3\n", + "bob@example.com 1\n", + "john@example.com 2\n", + "dtype: int64" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.groupby([\"email\"]).size()" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "3420b04f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idemailrollno
01john@example.com1001
12bob@example.com1002
23john@example.com1003
34abc@example.com1004
45abc@example.com1005
56abc@example.com1006
\n", + "
" + ], + "text/plain": [ + " id email rollno\n", + "0 1 john@example.com 1001\n", + "1 2 bob@example.com 1002\n", + "2 3 john@example.com 1003\n", + "3 4 abc@example.com 1004\n", + "4 5 abc@example.com 1005\n", + "5 6 abc@example.com 1006" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "path = r\"C:\\Users\\kbhunia\\Downloads\\GDrive Backup Downloads\\Jupyter Notebook Programs\\excel read files\\duplicate emails.csv\"\n", + "dfc = pd.read_csv(path)\n", + "dfc" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "564cfdf7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "email\n", + "abc@example.com 3\n", + "bob@example.com 1\n", + "john@example.com 2\n", + "dtype: int64" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gs = dfc.groupby(\"email\").size()\n", + "gs" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "0fcf68c4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "email\n", + "abc@example.com 3\n", + "bob@example.com 1\n", + "john@example.com 2\n", + "dtype: int64" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gc = dfc.groupby(\"email\").count()\n", + "gs" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "ab526b3b", + "metadata": {}, + "outputs": [], + "source": [ + "a = dfc.groupby(\"id\").count()" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "beda5a6b", + "metadata": {}, + "outputs": [], + "source": [ + "b = dfc.groupby(\"id\").size()" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "0a75f3bc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
emailrollno
id
111
211
311
411
511
611
\n", + "
" + ], + "text/plain": [ + " email rollno\n", + "id \n", + "1 1 1\n", + "2 1 1\n", + "3 1 1\n", + "4 1 1\n", + "5 1 1\n", + "6 1 1" + ] + }, + "execution_count": 102, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "51122c68", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "id\n", + "1 1\n", + "2 1\n", + "3 1\n", + "4 1\n", + "5 1\n", + "6 1\n", + "dtype: int64" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "id": "f9bd5dd8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
emailrollno
id
511
\n", + "
" + ], + "text/plain": [ + " email rollno\n", + "id \n", + "5 1 1" + ] + }, + "execution_count": 104, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a.loc[[5]]" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "id": "90c421da", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "pandas.core.series.Series" + ] + }, + "execution_count": 105, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(gs)" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "87dae2ed", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idemailrollno
01john@example.com1001
12bob@example.com1002
23john@example.com1003
34abc@example.com1004
45abc@example.com1005
56abc@example.com1006
\n", + "
" + ], + "text/plain": [ + " id email rollno\n", + "0 1 john@example.com 1001\n", + "1 2 bob@example.com 1002\n", + "2 3 john@example.com 1003\n", + "3 4 abc@example.com 1004\n", + "4 5 abc@example.com 1005\n", + "5 6 abc@example.com 1006" + ] + }, + "execution_count": 106, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "id": "24baff18", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idemailrollno
01john@example.com1001
12bob@example.com1002
23john@example.com1003
34abc@example.com1004
45abc@example.com1005
56abc@example.com1006
\n", + "
" + ], + "text/plain": [ + " id email rollno\n", + "0 1 john@example.com 1001\n", + "1 2 bob@example.com 1002\n", + "2 3 john@example.com 1003\n", + "3 4 abc@example.com 1004\n", + "4 5 abc@example.com 1005\n", + "5 6 abc@example.com 1006" + ] + }, + "execution_count": 107, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.loc[df[\"email\"].isnull(),\"email\"]=\"this is test\"\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "id": "0afd2685", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idemailrollno
01john@example.com1001
12bob@example.com1002
23john@example.com1003
34abc@example.com1004
45abc@example.com1005
56abc@example.com1006
\n", + "
" + ], + "text/plain": [ + " id email rollno\n", + "0 1 john@example.com 1001\n", + "1 2 bob@example.com 1002\n", + "2 3 john@example.com 1003\n", + "3 4 abc@example.com 1004\n", + "4 5 abc@example.com 1005\n", + "5 6 abc@example.com 1006" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.loc[df[\"email\"]==\"this is test\",\"email\"]=None\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "id": "a711ec11", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "id 0\n", + "email 0\n", + "rollno 0\n", + "dtype: int64" + ] + }, + "execution_count": 109, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.isnull().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "id": "15c764d9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idemailrollno
01john@example.com1001
12bob@example.com1002
23john@example.com1003
34abc@example.com1004
45abc@example.com1005
56abc@example.com1006
\n", + "
" + ], + "text/plain": [ + " id email rollno\n", + "0 1 john@example.com 1001\n", + "1 2 bob@example.com 1002\n", + "2 3 john@example.com 1003\n", + "3 4 abc@example.com 1004\n", + "4 5 abc@example.com 1005\n", + "5 6 abc@example.com 1006" + ] + }, + "execution_count": 110, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "50e6970a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idemailrollno
01john@example.com1001
12bob@example.com1002
23john@example.com1003
34abc@example.com1004
45abc@example.com1005
56abc@example.com1006
\n", + "
" + ], + "text/plain": [ + " id email rollno\n", + "0 1 john@example.com 1001\n", + "1 2 bob@example.com 1002\n", + "2 3 john@example.com 1003\n", + "3 4 abc@example.com 1004\n", + "4 5 abc@example.com 1005\n", + "5 6 abc@example.com 1006" + ] + }, + "execution_count": 111, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.loc[df[\"email\"].isnull(),\"email\"]=df[\"id\"].apply(lambda x:\"Even\" if x%2==0 else \"Odd\")\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "id": "4da43d43", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idemailrollno
01john@example.com1001
12bob@example.com1002
23john@example.com1003
34abc@example.com1004
45abc@example.com1005
56abc@example.com1006
\n", + "
" + ], + "text/plain": [ + " id email rollno\n", + "0 1 john@example.com 1001\n", + "1 2 bob@example.com 1002\n", + "2 3 john@example.com 1003\n", + "3 4 abc@example.com 1004\n", + "4 5 abc@example.com 1005\n", + "5 6 abc@example.com 1006" + ] + }, + "execution_count": 112, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.loc[df[\"email\"].isnull(),\"email\"]=df[\"id\"].map(lambda x:\"Even\" if x%2==0 else \"Odd\")\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "id": "53e8b067", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idemailrollnoNew field added
01john@example.com1001NaN
12bob@example.com1002NaN
23john@example.com1003NaN
34abc@example.com1004Test
45abc@example.com1005Test
56abc@example.com1006Test
\n", + "
" + ], + "text/plain": [ + " id email rollno New field added\n", + "0 1 john@example.com 1001 NaN\n", + "1 2 bob@example.com 1002 NaN\n", + "2 3 john@example.com 1003 NaN\n", + "3 4 abc@example.com 1004 Test\n", + "4 5 abc@example.com 1005 Test\n", + "5 6 abc@example.com 1006 Test" + ] + }, + "execution_count": 113, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.loc[(df[\"email\"].str.len()>10) & (df[\"email\"].str.contains(\"abc\")),\"New field added\"]=\"Test\"\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "id": "6c7fb9f0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idemailrollnoTest Status
01john@example.com1001NaN
12bob@example.com1002NaN
23john@example.com1003NaN
34abc@example.com1004Test
45abc@example.com1005Test
56abc@example.com1006Test
\n", + "
" + ], + "text/plain": [ + " id email rollno Test Status\n", + "0 1 john@example.com 1001 NaN\n", + "1 2 bob@example.com 1002 NaN\n", + "2 3 john@example.com 1003 NaN\n", + "3 4 abc@example.com 1004 Test\n", + "4 5 abc@example.com 1005 Test\n", + "5 6 abc@example.com 1006 Test" + ] + }, + "execution_count": 114, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.rename(columns={\"New field added\":\"Test Status\"},inplace=True)\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "id": "efc0d5ad", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idemailrollnoTest Status
01john@example.com1001NaN
12bob@example.com1002NaN
23john@example.com1003NaN
34abc@example.com1004Pass
45abc@example.com1005Pass
56abc@example.com1006Pass
\n", + "
" + ], + "text/plain": [ + " id email rollno Test Status\n", + "0 1 john@example.com 1001 NaN\n", + "1 2 bob@example.com 1002 NaN\n", + "2 3 john@example.com 1003 NaN\n", + "3 4 abc@example.com 1004 Pass\n", + "4 5 abc@example.com 1005 Pass\n", + "5 6 abc@example.com 1006 Pass" + ] + }, + "execution_count": 115, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.loc[df[\"Test Status\"]==\"Test\",\"Test Status\"]=\"Pass\"\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "id": "4becd3f2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idemailrollnoTest Status
01john@mygoogle.com1001NaN
12bob@mygoogle.com1002NaN
23john@mygoogle.com1003NaN
34abc@mygoogle.com1004Pass
45abc@mygoogle.com1005Pass
56abc@mygoogle.com1006Pass
\n", + "
" + ], + "text/plain": [ + " id email rollno Test Status\n", + "0 1 john@mygoogle.com 1001 NaN\n", + "1 2 bob@mygoogle.com 1002 NaN\n", + "2 3 john@mygoogle.com 1003 NaN\n", + "3 4 abc@mygoogle.com 1004 Pass\n", + "4 5 abc@mygoogle.com 1005 Pass\n", + "5 6 abc@mygoogle.com 1006 Pass" + ] + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.loc[(df[\"email\"].str.len()>10),\"email\"]=df[\"email\"].str.replace(\"example\",\"mygoogle\")\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1fea75bc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Name Age Address Qualification Mobile No\n", + "0 Jai 27 Nagpur Msc 97\n", + "1 Princi 24 Kanpur MA 91\n", + "2 Gaurav 22 Allahabad MCA 58\n", + "3 Anuj 32 Kannuaj Phd 76 \n", + "\n", + " Name Age Address Qualification Salary\n", + "2 Gaurav 22 Allahabad MCA 1000\n", + "3 Anuj 32 Kannuaj Phd 2000\n", + "6 Dhiraj 12 Allahabad Bcom 3000\n", + "7 Hitesh 52 Kannuaj B.hons 4000\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
NameAgeAddressQualificationMobile NoNameAgeAddressQualificationSalary
2Gaurav22AllahabadMCA58Gaurav22AllahabadMCA1000
3Anuj32KannuajPhd76Anuj32KannuajPhd2000
\n", + "
" + ], + "text/plain": [ + " Name Age Address Qualification Mobile No Name Age Address \\\n", + "2 Gaurav 22 Allahabad MCA 58 Gaurav 22 Allahabad \n", + "3 Anuj 32 Kannuaj Phd 76 Anuj 32 Kannuaj \n", + "\n", + " Qualification Salary \n", + "2 MCA 1000 \n", + "3 Phd 2000 " + ] + }, + "execution_count": 117, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd # type: ignore\n", + "\n", + "# Define a dictionary containing employee data \n", + "data1 = {'Name':['Jai', 'Princi', 'Gaurav', 'Anuj'], \n", + "'Age':[27, 24, 22, 32], \n", + "'Address':['Nagpur', 'Kanpur', 'Allahabad', 'Kannuaj'], \n", + "'Qualification':['Msc', 'MA', 'MCA', 'Phd'],\n", + "'Mobile No': [97, 91, 58, 76]} \n", + "\n", + "# Define a dictionary containing employee data \n", + "data2 = {'Name':['Gaurav', 'Anuj', 'Dhiraj', 'Hitesh'], \n", + "'Age':[22, 32, 12, 52], \n", + "'Address':['Allahabad', 'Kannuaj', 'Allahabad', 'Kannuaj'], \n", + "'Qualification':['MCA', 'Phd', 'Bcom', 'B.hons'],\n", + "'Salary':[1000, 2000, 3000, 4000]} \n", + "\n", + "# Convert the dictionary into DataFrame\n", + "df = pd.DataFrame(data1,index=[0, 1, 2, 3])\n", + "# Now we set axes join = inner forintersection of dataframe\n", + "# Output :\n", + "# As shown in the output image, we get the intersection of dataframe\n", + "# Now we set axes join = outer for union of dataframe.\n", + "# Output :\n", + "# As shown in the output image, we get the union of dataframe\n", + "# Run on IDE\n", + "\n", + "# Convert the dictionary into DataFrame\n", + "df1 = pd.DataFrame(data2, index=[2, 3, 6, 7]) \n", + "print(df, \"\\n\\n\", df1) \n", + "# applying concat with axes\n", + "# join = 'inner'\n", + "res2 = pd.concat([df, df1], axis=1, join='inner')\n", + "res2" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "id": "03a39982", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
NameAgeAddressQualification
0Jai27NagpurMsc
1Princi24KanpurMA
2Gaurav22AllahabadMCA
3Anuj32KannuajPhd
2Gaurav22AllahabadMCA
3Anuj32KannuajPhd
6Dhiraj12AllahabadBcom
7Hitesh52KannuajB.hons
\n", + "
" + ], + "text/plain": [ + " Name Age Address Qualification\n", + "0 Jai 27 Nagpur Msc\n", + "1 Princi 24 Kanpur MA\n", + "2 Gaurav 22 Allahabad MCA\n", + "3 Anuj 32 Kannuaj Phd\n", + "2 Gaurav 22 Allahabad MCA\n", + "3 Anuj 32 Kannuaj Phd\n", + "6 Dhiraj 12 Allahabad Bcom\n", + "7 Hitesh 52 Kannuaj B.hons" + ] + }, + "execution_count": 118, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "res3 = pd.concat([df, df1], axis=0, join='inner')\n", + "res3" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "id": "722c3e0e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File generated successfully\n" + ] + } + ], + "source": [ + "outputpath = r\"C:\\Users\\kbhunia\\Downloads\\GDrive Backup Downloads\\Jupyter Notebook Programs\\excel read files\\output duplicate emails_1.xlsx\"\n", + "res3.to_excel(outputpath,sheet_name=\"krishna\")\n", + "print(\"File generated successfully\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4645ae72", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAGsCAYAAAB968WXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAhmElEQVR4nO3de1TUdf7H8dd4YYAEytsMrKBsolmkx9ualGEXbM10zW3T7LpdjnfjWGsqpyO1iZc2tWKzy6LpllrrVnbTI9WmJVF4K495LSxKR2ojQEFI+Pz+8DC/ZtFyED7DwPNxzvecne/3O3zfX8fkuV++zDiMMUYAAACWtAj0AAAAoHkhPgAAgFXEBwAAsIr4AAAAVhEfAADAKuIDAABYRXwAAACriA8AAGAV8QEAAKwiPgCctSeeeEIOh0OJiYm1th08eFAOh0N/+9vfAjAZgMaI+ABw1pYuXSpJ2rVrlz7++OMATwOgsSM+AJyVLVu26NNPP9WwYcMkSVlZWQGeCEBjR3wAOCs1sTFv3jwlJSVp9erVKisrq7VfdXW15syZo7i4OIWGhqpfv3569913a+23Z88e3XTTTXK5XHI6nYqLi9Ntt92mioqKBj8XAHYQHwDqrLy8XKtWrVL//v2VmJioO++8U6WlpfrXv/5Va9/MzEytX79eixcv1gsvvKAWLVpo6NCh+uijj7z7fPrpp+rfv79yc3P18MMPa926dZo7d64qKipUWVlp89QANCCHMcYEeggAwemf//ynbrvtNj399NMaN26cjh49qujoaPXu3VubNm2SdPKG0/j4eMXExOiLL75QaGioJKm0tFRdunRRnz59lJ2dLUm66qqrtG3bNu3bt08dOnQI2HkBaFhc+QBQZ1lZWQoLC9OYMWMkSW3atNGf/vQnffDBB9q/f7/PvqNGjfKGhyRFRERo+PDh2rRpk6qqqlRWVqaNGzfqxhtvJDyAJo74AFAnBw4c0KZNmzRs2DAZY/Tjjz/qxx9/1A033CDp/38Dpobb7a71NdxutyorK3X06FEVFRWpqqpKnTp1sjI/gMAhPgDUydKlS2WM0Zo1a3Teeed5l5rfelm+fLmqqqq8+3s8nlpfw+PxKCQkRG3atFHbtm3VsmVLffPNN9bOAUBgcM8HAL9VVVUpLi5OYWFh+sc//lFr+5tvvqnHHntMb7zxhhITE3/xno/evXvrnXfekXTyno/t27dr3759at++vdVzAmAP8QHAb2+++aaGDx+u+fPna/r06bW2f//99+rUqZOGDh2qRYsWKT4+XrGxsercubOmTZum6upqzZ8/X9u3b9f777+vSy+9VNLJ33a57LLL1LFjR82YMUNdu3bVkSNH9Prrr+uZZ55RRESE7VMF0ABaBXoAAMEnKytLISEh+vOf/3zK7e3bt9f111+vNWvWaMaMGZKkyZMn6/jx45o6daoKCwt10UUX6a233vKGhyT16tVLn3zyiWbPnq2ZM2eqtLRUbrdbV155pUJCQqycG4CGx5UPAABgFTecAgAAq4gPAABgFfEBAACsIj4AAIBVxAcAALCK+AAAAFY1uvf5qK6u1qFDhxQRESGHwxHocQAAwBkwxqi0tFQxMTFq0eKXr200uvg4dOiQYmNjAz0GAACog4KCgl/9gMhGFx81b59cUFCgyMjIAE8DAADORElJiWJjY8/oYxAaXXzU/KglMjKS+AAAIMicyS0T3HAKAACsIj4AAIBVxAcAALCq0d3zcaaqqqr0008/BXqMRi8kJORXf+UJAACbgi4+jDHyeDz68ccfAz1KUGjRooXi4+MVEhIS6FEAAJAUhPFREx4dO3ZUeHg4b0T2C2resO3w4cOKi4vjzwoA0CgEVXxUVVV5w6Ndu3aBHicodOjQQYcOHdKJEyfUunXrQI8DAEBw3XBac49HeHh4gCcJHjU/bqmqqgrwJAAAnBRU8VGDHx+cOf6sAACNTVDGBwAACF7EBwAAsCqobjj9JV1mvGX1eAfnDavT83JycjRo0CClpKRo/fr19TwVAACNH1c+LFu6dKmmTJmiDz/8UF9//XWgxwEAwDriw6Jjx47p5Zdf1oQJE3Tdddfp+eef99n++uuvKyEhQWFhYbriiiu0fPlyORwOnzdUy8nJ0eWXX66wsDDFxsZq6tSpOnbsmN0TAQDgLDSZH7sEg5deekndu3dX9+7ddcstt2jKlCl68MEH5XA4dPDgQd1www269957dffdd2v79u26//77fZ6/c+dOXXPNNfrrX/+qrKwsfffdd5o8ebImT56sZcuWBeisAAD1zfatBD9X19sK/MGVD4uysrJ0yy23SJJ+//vf6+jRo3r33XclSU8//bS6d++uRx99VN27d9eYMWN0xx13+Dz/0Ucf1dixY5WamqqEhAQlJSXpiSee0IoVK3T8+HHbpwMAQJ0QH5bs3btXn3zyicaMGSNJatWqlUaPHq2lS5d6t/fv39/nOb/73e98Hm/dulXPP/+82rRp412uueYaVVdXKz8/386JAABwlvixiyVZWVk6ceKEfvOb33jXGWPUunVrFRUVyRhT6w3BjDE+j6urqzVu3DhNnTq11tePi4trmMEBAKhnxIcFJ06c0IoVK/TYY49pyJAhPtv++Mc/6sUXX9QFF1ygt99+22fbli1bfB736dNHu3btUteuXRt8ZgAAGgrxYcGbb76poqIi3XXXXYqKivLZdsMNNygrK0uvvPKKFi5cqAceeEB33XWXduzY4f1tmJorIg888IAuueQSTZo0Sffcc4/OOecc7d69W9nZ2XryySdtnxYAAHXSZOLDxt25dZWVlaWrr766VnhIJ698ZGRkqKioSGvWrNF9992nxx9/XAMHDlRaWpomTJggp9MpSerZs6c2btyotLQ0DRo0SMYYnX/++Ro9erTtUwIAoM6aTHw0Zm+88cZpt/Xp08d7b0efPn00YsQI77Y5c+aoU6dOCg0N9a7r37+/NmzY0HDDAgDQwIiPRuSpp55S//791a5dO23evFmPPvqoJk+eHOixAACoV8RHI7J//3498sgj+uGHHxQXF6f77rtPM2fODPRYAADUK7/e5yM9PV0Oh8Nncbvd3u3GGKWnpysmJkZhYWEaPHiwdu3aVe9DN1WLFi3SoUOHdPz4ce3bt08PPvigWrWiDwEATYvfbzJ20UUX6fDhw95l586d3m0LFizQwoULlZmZqby8PLndbqWkpKi0tLRehwYAAMHL7/ho1aqV3G63d+nQoYOkk1c9Fi9erLS0NI0aNUqJiYlavny5ysrKtHLlynod+n/ffAunx58VAKCx8Ts+9u/fr5iYGMXHx2vMmDH68ssvJUn5+fnyeDw+b6LldDqVnJysnJyc0369iooKlZSU+Cyn07p1a0lSWVmZv2M3W5WVlZKkli1bBngSAABO8uuGggEDBmjFihXq1q2bjhw5okceeURJSUnatWuXPB6PJMnlcvk8x+Vy6auvvjrt15w7d64eeuihMzp+y5Ytde6556qwsFCSFB4eXustyfH/qqur9d133yk8PJx7RwAAjYZf35GGDh3q/d8XX3yxBg4cqPPPP1/Lly/XJZdcIkmn/HySXwqEmTNnatq0ad7HJSUlio2NPe3+NTe41gQIflmLFi0UFxdHpAEAGo2z+r/D55xzji6++GLt379fI0eOlCR5PB5FR0d79yksLKx1NeTnnE6n9x08z4TD4VB0dLQ6duyon376qc6zNxchISFq0YIPLwYANB5nFR8VFRXavXu3Bg0apPj4eLndbmVnZ6t3796STt5vsHHjRs2fP79ehv25li1bch8DAABByK/4uP/++zV8+HDFxcWpsLBQjzzyiEpKSnT77bfL4XAoNTVVGRkZSkhIUEJCgjIyMhQeHq6xY8c21PwAACDI+BUf33zzjW666SZ9//336tChgy655BLl5uaqc+fOkqTp06ervLxcEydOVFFRkQYMGKANGzYoIiKiQYYHAADBx2Ea2RtBlJSUKCoqSsXFxYqMjAz0OAAAWNdlxlsBO3ZdPyXen+/f3IkIAACsIj4AAIBVxAcAALCK+AAAAFYRHwAAwCriAwAAWEV8AAAAq4gPAABgFfEBAACsIj4AAIBVxAcAALCK+AAAAFYRHwAAwCriAwAAWEV8AAAAq4gPAABgFfEBAACsIj4AAIBVxAcAALCK+AAAAFYRHwAAwCriAwAAWEV8AAAAq4gPAABgFfEBAACsIj4AAIBVxAcAALCK+AAAAFYRHwAAwCriAwAAWEV8AAAAq4gPAABgFfEBAACsIj4AAIBVxAcAALCK+AAAAFYRHwAAwCriAwAAWEV8AAAAq4gPAABgFfEBAACsIj4AAIBVxAcAALCK+AAAAFYRHwAAwCriAwAAWEV8AAAAq4gPAABgFfEBAACsIj4AAIBVxAcAALCK+AAAAFYRHwAAwCriAwAAWEV8AAAAq4gPAABgFfEBAACsOqv4mDt3rhwOh1JTU73rjDFKT09XTEyMwsLCNHjwYO3atets5wQAAE1EneMjLy9Pzz77rHr27OmzfsGCBVq4cKEyMzOVl5cnt9utlJQUlZaWnvWwAAAg+NUpPo4ePaqbb75Zzz33nM477zzvemOMFi9erLS0NI0aNUqJiYlavny5ysrKtHLlynobGgAABK86xcekSZM0bNgwXX311T7r8/Pz5fF4NGTIEO86p9Op5ORk5eTknPJrVVRUqKSkxGcBAABNVyt/n7B69Wpt27ZNeXl5tbZ5PB5Jksvl8lnvcrn01VdfnfLrzZ07Vw899JC/YwAAgCDl15WPgoIC3XvvvXrhhRcUGhp62v0cDofPY2NMrXU1Zs6cqeLiYu9SUFDgz0gAACDI+HXlY+vWrSosLFTfvn2966qqqrRp0yZlZmZq7969kk5eAYmOjvbuU1hYWOtqSA2n0ymn01mX2QEAQBDy68rHVVddpZ07d2rHjh3epV+/frr55pu1Y8cO/fa3v5Xb7VZ2drb3OZWVldq4caOSkpLqfXgAABB8/LryERERocTERJ9155xzjtq1a+ddn5qaqoyMDCUkJCghIUEZGRkKDw/X2LFj629qAAAQtPy+4fTXTJ8+XeXl5Zo4caKKioo0YMAAbdiwQREREfV9KAAAEIQcxhgT6CF+rqSkRFFRUSouLlZkZGSgxwEAwLouM94K2LEPzhtWp+f58/2bz3YBAABWER8AAMAq4gMAAFhFfAAAAKuIDwAAYBXxAQAArCI+AACAVcQHAACwivgAAABWER8AAMAq4gMAAFhFfAAAAKuIDwAAYBXxAQAArCI+AACAVcQHAACwivgAAABWER8AAMAq4gMAAFhFfAAAAKuIDwAAYBXxAQAArCI+AACAVcQHAACwivgAAABWER8AAMAq4gMAAFhFfAAAAKuIDwAAYBXxAQAArCI+AACAVcQHAACwivgAAABWER8AAMAq4gMAAFhFfAAAAKuIDwAAYBXxAQAArCI+AACAVcQHAACwivgAAABWER8AAMAq4gMAAFhFfAAAAKuIDwAAYBXxAQAArCI+AACAVa0CPQCAuuky462AHfvgvGEBO3ZzxeuNpoQrHwAAwCriAwAAWEV8AAAAq4gPAABgFfEBAACsIj4AAIBVxAcAALCK+AAAAFb5FR9LlixRz549FRkZqcjISA0cOFDr1q3zbjfGKD09XTExMQoLC9PgwYO1a9eueh8aAAAEL7/io1OnTpo3b562bNmiLVu26Morr9Qf/vAHb2AsWLBACxcuVGZmpvLy8uR2u5WSkqLS0tIGGR4AAAQfv+Jj+PDhuvbaa9WtWzd169ZNc+bMUZs2bZSbmytjjBYvXqy0tDSNGjVKiYmJWr58ucrKyrRy5cqGmh8AAASZOt/zUVVVpdWrV+vYsWMaOHCg8vPz5fF4NGTIEO8+TqdTycnJysnJOe3XqaioUElJic8CAACaLr/jY+fOnWrTpo2cTqfGjx+vV199VRdeeKE8Ho8kyeVy+ezvcrm8205l7ty5ioqK8i6xsbH+jgQAAIKI3/HRvXt37dixQ7m5uZowYYJuv/12ff75597tDofDZ39jTK11Pzdz5kwVFxd7l4KCAn9HAgAAQaSVv08ICQlR165dJUn9+vVTXl6eHn/8cT3wwAOSJI/Ho+joaO/+hYWFta6G/JzT6ZTT6fR3DAAAEKTO+n0+jDGqqKhQfHy83G63srOzvdsqKyu1ceNGJSUlne1hAABAE+HXlY9Zs2Zp6NChio2NVWlpqVavXq33339f69evl8PhUGpqqjIyMpSQkKCEhARlZGQoPDxcY8eObaj5AQBAkPErPo4cOaJbb71Vhw8fVlRUlHr27Kn169crJSVFkjR9+nSVl5dr4sSJKioq0oABA7RhwwZFREQ0yPAAACD4+BUfWVlZv7jd4XAoPT1d6enpZzMTAABowvhsFwAAYBXxAQAArCI+AACAVcQHAACwivgAAABWER8AAMAq4gMAAFhFfAAAAKuIDwAAYBXxAQAArCI+AACAVcQHAACwivgAAABWER8AAMCqVoEeoCF0mfFWwI59cN6wgB0bAIBgwJUPAABgFfEBAACsIj4AAIBVxAcAALCK+AAAAFYRHwAAwCriAwAAWEV8AAAAq4gPAABgFfEBAACsIj4AAIBVxAcAALCK+AAAAFYRHwAAwCriAwAAWEV8AAAAq4gPAABgFfEBAACsIj4AAIBVrQI9AOpPlxlvBezYB+cNC9ixAQDBhSsfAADAKuIDAABYRXwAAACriA8AAGAV8QEAAKwiPgAAgFXEBwAAsIr4AAAAVhEfAADAKuIDAABYRXwAAACriA8AAGAVHyyHoMcH6jUvvN5A8OPKBwAAsIr4AAAAVhEfAADAKuIDAABYRXwAAACriA8AAGAV8QEAAKwiPgAAgFXEBwAAsMqv+Jg7d6769++viIgIdezYUSNHjtTevXt99jHGKD09XTExMQoLC9PgwYO1a9eueh0aAAAEL7/iY+PGjZo0aZJyc3OVnZ2tEydOaMiQITp27Jh3nwULFmjhwoXKzMxUXl6e3G63UlJSVFpaWu/DAwCA4OPXZ7usX7/e5/GyZcvUsWNHbd26VZdffrmMMVq8eLHS0tI0atQoSdLy5cvlcrm0cuVKjRs3rv4mBwAAQems7vkoLi6WJLVt21aSlJ+fL4/HoyFDhnj3cTqdSk5OVk5Ozim/RkVFhUpKSnwWAADQdNU5PowxmjZtmi677DIlJiZKkjwejyTJ5XL57Otyubzb/tfcuXMVFRXlXWJjY+s6EgAACAJ1jo/Jkyfrs88+06pVq2ptczgcPo+NMbXW1Zg5c6aKi4u9S0FBQV1HAgAAQcCvez5qTJkyRa+//ro2bdqkTp06ede73W5JJ6+AREdHe9cXFhbWuhpSw+l0yul01mUMAAAQhPy68mGM0eTJk/XKK6/ovffeU3x8vM/2+Ph4ud1uZWdne9dVVlZq48aNSkpKqp+JAQBAUPPrysekSZO0cuVKrV27VhEREd77OKKiohQWFiaHw6HU1FRlZGQoISFBCQkJysjIUHh4uMaOHdsgJwAAAIKLX/GxZMkSSdLgwYN91i9btkx33HGHJGn69OkqLy/XxIkTVVRUpAEDBmjDhg2KiIiol4EBAEBw8ys+jDG/uo/D4VB6errS09PrOhMAAGjC+GwXAABgFfEBAACsIj4AAIBVxAcAALCK+AAAAFYRHwAAwCriAwAAWEV8AAAAq4gPAABgFfEBAACsIj4AAIBVxAcAALCK+AAAAFYRHwAAwCriAwAAWEV8AAAAq4gPAABgFfEBAACsIj4AAIBVxAcAALCK+AAAAFYRHwAAwCriAwAAWEV8AAAAq4gPAABgFfEBAACsIj4AAIBVxAcAALCK+AAAAFYRHwAAwCriAwAAWEV8AAAAq4gPAABgFfEBAACsIj4AAIBVxAcAALCK+AAAAFYRHwAAwCriAwAAWEV8AAAAq4gPAABgFfEBAACsIj4AAIBVxAcAALCK+AAAAFYRHwAAwCriAwAAWNUq0AMAAHA6XWa8FbBjH5w3LGDHbuq48gEAAKwiPgAAgFXEBwAAsIr4AAAAVhEfAADAKuIDAABYRXwAAACriA8AAGAV8QEAAKzyOz42bdqk4cOHKyYmRg6HQ6+99prPdmOM0tPTFRMTo7CwMA0ePFi7du2qr3kBAECQ8zs+jh07pl69eikzM/OU2xcsWKCFCxcqMzNTeXl5crvdSklJUWlp6VkPCwAAgp/fn+0ydOhQDR069JTbjDFavHix0tLSNGrUKEnS8uXL5XK5tHLlSo0bN+7spgUAAEGvXu/5yM/Pl8fj0ZAhQ7zrnE6nkpOTlZOTc8rnVFRUqKSkxGcBAABNV73Gh8fjkSS5XC6f9S6Xy7vtf82dO1dRUVHeJTY2tj5HAgAAjUyD/LaLw+HweWyMqbWuxsyZM1VcXOxdCgoKGmIkAADQSPh9z8cvcbvdkk5eAYmOjvauLywsrHU1pIbT6ZTT6azPMQAAQCNWr1c+4uPj5Xa7lZ2d7V1XWVmpjRs3KikpqT4PBQAAgpTfVz6OHj2qAwcOeB/n5+drx44datu2reLi4pSamqqMjAwlJCQoISFBGRkZCg8P19ixY+t1cAAAEJz8jo8tW7boiiuu8D6eNm2aJOn222/X888/r+nTp6u8vFwTJ05UUVGRBgwYoA0bNigiIqL+pgYAAEHL7/gYPHiwjDGn3e5wOJSenq709PSzmQsAADRRfLYLAACwivgAAABWER8AAMAq4gMAAFhFfAAAAKuIDwAAYBXxAQAArCI+AACAVcQHAACwivgAAABWER8AAMAq4gMAAFhFfAAAAKuIDwAAYBXxAQAArCI+AACAVcQHAACwivgAAABWER8AAMAq4gMAAFhFfAAAAKuIDwAAYBXxAQAArCI+AACAVcQHAACwivgAAABWER8AAMAq4gMAAFhFfAAAAKuIDwAAYBXxAQAArCI+AACAVcQHAACwivgAAABWER8AAMAq4gMAAFhFfAAAAKuIDwAAYBXxAQAArCI+AACAVcQHAACwivgAAABWER8AAMAq4gMAAFhFfAAAAKuIDwAAYBXxAQAArCI+AACAVcQHAACwivgAAABWER8AAMAq4gMAAFhFfAAAAKuIDwAAYBXxAQAArCI+AACAVQ0WH0899ZTi4+MVGhqqvn376oMPPmioQwEAgCDSIPHx0ksvKTU1VWlpadq+fbsGDRqkoUOH6uuvv26IwwEAgCDSIPGxcOFC3XXXXbr77rvVo0cPLV68WLGxsVqyZElDHA4AAASRVvX9BSsrK7V161bNmDHDZ/2QIUOUk5NTa/+KigpVVFR4HxcXF0uSSkpK6jxDdUVZnZ97ts5m7rPFedvHedvHedvHedsXjOdd8zxjzK/vbOrZt99+aySZzZs3+6yfM2eO6datW639Z8+ebSSxsLCwsLCwNIGloKDgV1uh3q981HA4HD6PjTG11knSzJkzNW3aNO/j6upq/fDDD2rXrt0p929IJSUlio2NVUFBgSIjI60eO5A4b867OeC8Oe/mIJDnbYxRaWmpYmJifnXfeo+P9u3bq2XLlvJ4PD7rCwsL5XK5au3vdDrldDp91p177rn1PZZfIiMjm9Vf1hqcd/PCeTcvnHfzEqjzjoqKOqP96v2G05CQEPXt21fZ2dk+67Ozs5WUlFTfhwMAAEGmQX7sMm3aNN16663q16+fBg4cqGeffVZff/21xo8f3xCHAwAAQaRB4mP06NH673//q4cffliHDx9WYmKi3n77bXXu3LkhDldvnE6nZs+eXevHQE0d5815NwecN+fdHATLeTuMOZPfiQEAAKgffLYLAACwivgAAABWER8AAMAq4gMAAFhFfAAAAKuIDwAAYFWDfbZLMPjmm2+0ZMkS5eTkyOPxyOFwyOVyKSkpSePHj1dsbGygRwQAoMlptlc+PvzwQ/Xo0UOvvvqqevXqpdtuu0233HKLevXqpddee00XXXSRNm/eHOgxA6KgoEB33nlnoMeod+Xl5frwww/1+eef19p2/PhxrVixIgBT2bF7924tW7ZMe/bskSTt2bNHEyZM0J133qn33nsvwNM1DF7v5vN6b9++Xfn5+d7HL7zwgi699FLFxsbqsssu0+rVqwM4XcOaMmWKPvjgg0CP4b9f/dzbJqpfv34mNTX1tNtTU1NNv379LE7UeOzYscO0aNEi0GPUq71795rOnTsbh8NhWrRoYZKTk82hQ4e82z0eT5M75xrr1q0zISEhpm3btiY0NNSsW7fOdOjQwVx99dXmqquuMq1atTLvvvtuoMesV7zezev17t27t3nvvfeMMcY899xzJiwszEydOtUsWbLEpKammjZt2pisrKwAT9kwav6OJyQkmHnz5pnDhw8HeqQz0mzjIzQ01OzZs+e023fv3m1CQ0MtTmTP2rVrf3FZtGhRk/uHeeTIkea6664z3333ndm/f78ZPny4iY+PN1999ZUxpml/Mxo4cKBJS0szxhizatUqc95555lZs2Z5t8+aNcukpKQEarwGwevdvF7v8PBw72vbu3dv88wzz/hsf/HFF82FF14YiNEanMPhMO+884659957Tfv27U3r1q3NiBEjzBtvvGGqqqoCPd5pNdv4iI+PN0uXLj3t9qVLl5r4+HiLE9lTU8oOh+O0S1P7h7ljx47ms88+81k3ceJEExcXZ7744osm/c0oMjLS7N+/3xhjTFVVlWnVqpXZunWrd/vOnTuNy+UK1HgNgte7eb3e7dq1M1u2bDHGnHztd+zY4bP9wIEDJiwsLBCjNTiHw2GOHDlijDGmsrLSvPTSS+aaa64xLVu2NDExMWbWrFnevw+NSbO95+P+++/X+PHjNXnyZK1du1a5ubn6+OOPtXbtWk2ePFkTJkzQ9OnTAz1mg4iOjta///1vVVdXn3LZtm1boEesd+Xl5WrVyvf+6r///e8aMWKEkpOTtW/fvgBNZleLFi0UGhqqc88917suIiJCxcXFgRuqAfB6n9RcXu+hQ4dqyZIlkqTk5GStWbPGZ/vLL7+srl27BmI0q1q3bq0bb7xR69ev15dffql77rlHL774orp37x7o0Wpptr/tMnHiRLVr106LFi3SM888o6qqKklSy5Yt1bdvX61YsUI33nhjgKdsGH379tW2bds0cuTIU253OBwyTezzBi+44AJt2bJFPXr08Fn/5JNPyhijESNGBGiyhtelSxcdOHDA+4/vRx99pLi4OO/2goICRUdHB2q8BsHr3bxe7/nz5+vSSy9VcnKy+vXrp8cee0zvv/++evToob179yo3N1evvvpqoMe0Ki4uTunp6Zo9e7beeeedQI9TS7O98iFJo0ePVm5ursrKyvTtt9/q22+/VVlZmXJzc5tseEjSX/7yFyUlJZ12e9euXfWf//zH4kQN7/rrr9eqVatOuS0zM1M33XRTkwuuGhMmTPDGtSQlJib6XBVYt26drrzyykCM1mB4vZvX6x0TE6Pt27dr4MCBWr9+vYwx+uSTT7RhwwZ16tRJmzdv1rXXXhvoMRtE586d1bJly9NudzgcSklJsTjRmXGYpvpfIAAAaJSa9ZUPAABgH/EBAACsIj4AAIBVxAcAALCK+AAAAFYRHwAAwCriAwAAWPV/NVozGl7xwbYAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib as plot # type: ignore\n", + "res3.plot(title = \"Abc\",kind=\"bar\");" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b3b85aae", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 121, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns # type: ignore\n", + "sns.barplot(res3)" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "id": "e4b5a2e1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[('Allahabad',\n", + " Name Age Address Qualification\n", + " 2 Gaurav 22 Allahabad MCA\n", + " 2 Gaurav 22 Allahabad MCA\n", + " 6 Dhiraj 12 Allahabad Bcom),\n", + " ('Kannuaj',\n", + " Name Age Address Qualification\n", + " 3 Anuj 32 Kannuaj Phd\n", + " 3 Anuj 32 Kannuaj Phd\n", + " 7 Hitesh 52 Kannuaj B.hons),\n", + " ('Kanpur',\n", + " Name Age Address Qualification\n", + " 1 Princi 24 Kanpur MA),\n", + " ('Nagpur',\n", + " Name Age Address Qualification\n", + " 0 Jai 27 Nagpur Msc)]" + ] + }, + "execution_count": 127, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(res3.groupby(\"Address\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aad711d0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 41cade8563d1a761c3661ab5ab7a05c4e8c544c0 Mon Sep 17 00:00:00 2001 From: KRISHNA DIPAYAN BHUNIA Date: Tue, 15 Apr 2025 16:26:33 +0530 Subject: [PATCH 6/9] password remove from pdf --- .../remove_password_pdf.ipynb | 95 +++++++++++++++++++ pyproject.toml | 16 ++++ 2 files changed, 111 insertions(+) create mode 100644 extra terrestial code/remove_password_pdf.ipynb create mode 100644 pyproject.toml diff --git a/extra terrestial code/remove_password_pdf.ipynb b/extra terrestial code/remove_password_pdf.ipynb new file mode 100644 index 0000000..b908bd5 --- /dev/null +++ b/extra terrestial code/remove_password_pdf.ipynb @@ -0,0 +1,95 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "82225013", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting pikepdf\n", + " Downloading pikepdf-9.7.0-cp312-cp312-macosx_14_0_arm64.whl.metadata (8.1 kB)\n", + "Collecting Pillow>=10.0.1 (from pikepdf)\n", + " Downloading pillow-11.2.1-cp312-cp312-macosx_11_0_arm64.whl.metadata (8.9 kB)\n", + "Collecting Deprecated (from pikepdf)\n", + " Downloading Deprecated-1.2.18-py2.py3-none-any.whl.metadata (5.7 kB)\n", + "Collecting lxml>=4.8 (from pikepdf)\n", + " Downloading lxml-5.3.2-cp312-cp312-macosx_10_9_universal2.whl.metadata (3.6 kB)\n", + "Requirement already satisfied: packaging in /Users/krishna/Github Projects/Python_Codes/.venv/lib/python3.12/site-packages (from pikepdf) (24.2)\n", + "Collecting wrapt<2,>=1.10 (from Deprecated->pikepdf)\n", + " Downloading wrapt-1.17.2-cp312-cp312-macosx_11_0_arm64.whl.metadata (6.4 kB)\n", + "Downloading pikepdf-9.7.0-cp312-cp312-macosx_14_0_arm64.whl (4.5 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m4.5/4.5 MB\u001b[0m \u001b[31m3.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n", + "\u001b[?25hDownloading lxml-5.3.2-cp312-cp312-macosx_10_9_universal2.whl (8.2 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m8.2/8.2 MB\u001b[0m \u001b[31m3.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n", + "\u001b[?25hDownloading pillow-11.2.1-cp312-cp312-macosx_11_0_arm64.whl (3.0 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.0/3.0 MB\u001b[0m \u001b[31m3.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n", + "\u001b[?25hDownloading Deprecated-1.2.18-py2.py3-none-any.whl (10.0 kB)\n", + "Downloading wrapt-1.17.2-cp312-cp312-macosx_11_0_arm64.whl (38 kB)\n", + "Installing collected packages: wrapt, Pillow, lxml, Deprecated, pikepdf\n", + "Successfully installed Deprecated-1.2.18 Pillow-11.2.1 lxml-5.3.2 pikepdf-9.7.0 wrapt-1.17.2\n" + ] + } + ], + "source": [ + "!pip install pikepdf" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9ce40807", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File not found. Check the path again.\n" + ] + } + ], + "source": [ + "import pikepdf # type: ignore\n", + "\n", + "# Input/output file paths\n", + "input_pdf = \"'/Users/krishna/Documents/pdf_password_remove/CIBIL REPORT KRISHNA 226202342.pdf'\"\n", + "output_pdf = \"'/Users/krishna/Documents/pdf_password_remove/removed password CIBIL REPORT KRISHNA 226202342.pdf'\"\n", + "password = \"KRIB19900631\" # replace with actual password\n", + "\n", + "try:\n", + " # Open the encrypted PDF with the password\n", + " with pikepdf.open(input_pdf, password=password) as pdf:\n", + " pdf.save(output_pdf)\n", + " print(\"Password removed successfully. Saved as:\", output_pdf)\n", + "\n", + "except pikepdf._qpdf.PasswordError:\n", + " print(\"Incorrect password. Unable to open the PDF.\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..3cd24cc --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,16 @@ +[project] +name = "krishna python codes" +version = "0.1.0" +description = "basic python code developed by krishna" +authors = [ + {name = "KRISHNA DIPAYAN BHUNIA",email = "krishnabhunia@gmail.com"} +] +readme = "README.md" +requires-python = ">=3.10" +dependencies = [ +] + + +[build-system] +requires = ["poetry-core>=2.0.0,<3.0.0"] +build-backend = "poetry.core.masonry.api" From 64caf769aa3dadfc1e4669956eb80362de24bb4b Mon Sep 17 00:00:00 2001 From: KRISHNA DIPAYAN BHUNIA Date: Tue, 15 Apr 2025 16:28:55 +0530 Subject: [PATCH 7/9] pdf password change --- .../remove_password_pdf.ipynb | 51 +++++++++---------- 1 file changed, 25 insertions(+), 26 deletions(-) diff --git a/extra terrestial code/remove_password_pdf.ipynb b/extra terrestial code/remove_password_pdf.ipynb index b908bd5..b42c743 100644 --- a/extra terrestial code/remove_password_pdf.ipynb +++ b/extra terrestial code/remove_password_pdf.ipynb @@ -10,45 +10,44 @@ "name": "stdout", "output_type": "stream", "text": [ - "Collecting pikepdf\n", - " Downloading pikepdf-9.7.0-cp312-cp312-macosx_14_0_arm64.whl.metadata (8.1 kB)\n", - "Collecting Pillow>=10.0.1 (from pikepdf)\n", - " Downloading pillow-11.2.1-cp312-cp312-macosx_11_0_arm64.whl.metadata (8.9 kB)\n", - "Collecting Deprecated (from pikepdf)\n", - " Downloading Deprecated-1.2.18-py2.py3-none-any.whl.metadata (5.7 kB)\n", - "Collecting lxml>=4.8 (from pikepdf)\n", - " Downloading lxml-5.3.2-cp312-cp312-macosx_10_9_universal2.whl.metadata (3.6 kB)\n", + "Requirement already satisfied: pikepdf in /Users/krishna/Github Projects/Python_Codes/.venv/lib/python3.12/site-packages (9.7.0)\n", + "Requirement already satisfied: Pillow>=10.0.1 in /Users/krishna/Github Projects/Python_Codes/.venv/lib/python3.12/site-packages (from pikepdf) (11.2.1)\n", + "Requirement already satisfied: Deprecated in /Users/krishna/Github Projects/Python_Codes/.venv/lib/python3.12/site-packages (from pikepdf) (1.2.18)\n", + "Requirement already satisfied: lxml>=4.8 in /Users/krishna/Github Projects/Python_Codes/.venv/lib/python3.12/site-packages (from pikepdf) (5.3.2)\n", "Requirement already satisfied: packaging in /Users/krishna/Github Projects/Python_Codes/.venv/lib/python3.12/site-packages (from pikepdf) (24.2)\n", - "Collecting wrapt<2,>=1.10 (from Deprecated->pikepdf)\n", - " Downloading wrapt-1.17.2-cp312-cp312-macosx_11_0_arm64.whl.metadata (6.4 kB)\n", - "Downloading pikepdf-9.7.0-cp312-cp312-macosx_14_0_arm64.whl (4.5 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m4.5/4.5 MB\u001b[0m \u001b[31m3.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n", - "\u001b[?25hDownloading lxml-5.3.2-cp312-cp312-macosx_10_9_universal2.whl (8.2 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m8.2/8.2 MB\u001b[0m \u001b[31m3.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n", - "\u001b[?25hDownloading pillow-11.2.1-cp312-cp312-macosx_11_0_arm64.whl (3.0 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.0/3.0 MB\u001b[0m \u001b[31m3.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n", - "\u001b[?25hDownloading Deprecated-1.2.18-py2.py3-none-any.whl (10.0 kB)\n", - "Downloading wrapt-1.17.2-cp312-cp312-macosx_11_0_arm64.whl (38 kB)\n", - "Installing collected packages: wrapt, Pillow, lxml, Deprecated, pikepdf\n", - "Successfully installed Deprecated-1.2.18 Pillow-11.2.1 lxml-5.3.2 pikepdf-9.7.0 wrapt-1.17.2\n" + "Requirement already satisfied: wrapt<2,>=1.10 in /Users/krishna/Github Projects/Python_Codes/.venv/lib/python3.12/site-packages (from Deprecated->pikepdf) (1.17.2)\n", + "Note: you may need to restart the kernel to use updated packages.\n", + "\u001b[31mERROR: Could not find a version that satisfies the requirement qpdf (from versions: none)\u001b[0m\u001b[31m\n", + "\u001b[0m\u001b[31mERROR: No matching distribution found for qpdf\u001b[0m\u001b[31m\n", + "\u001b[0mNote: you may need to restart the kernel to use updated packages.\n" ] } ], "source": [ - "!pip install pikepdf" + "%pip install pikepdf\n", + "%pip install qpdf" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "9ce40807", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "File not found. Check the path again.\n" + "ename": "AttributeError", + "evalue": "module 'pikepdf' has no attribute '_qpdf'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 10\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 9\u001b[0m \u001b[38;5;66;03m# Open the encrypted PDF with the password\u001b[39;00m\n\u001b[0;32m---> 10\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[43mpikepdf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43minput_pdf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpassword\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpassword\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m pdf:\n\u001b[1;32m 11\u001b[0m pdf\u001b[38;5;241m.\u001b[39msave(output_pdf)\n", + "File \u001b[0;32m~/Github Projects/Python_Codes/.venv/lib/python3.12/site-packages/pikepdf/_methods.py:397\u001b[0m, in \u001b[0;36mExtend_Pdf.open\u001b[0;34m(filename_or_stream, password, hex_password, ignore_xref_streams, suppress_warnings, attempt_recovery, inherit_page_attributes, access_mode, allow_overwriting_input)\u001b[0m\n\u001b[1;32m 396\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 397\u001b[0m stream \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mfilename_or_stream\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mrb\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 398\u001b[0m original_filename \u001b[38;5;241m=\u001b[39m Path(filename_or_stream)\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: \"'/Users/krishna/Documents/pdf_password_remove/CIBIL REPORT KRISHNA 226202342.pdf'\"", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 14\u001b[0m\n\u001b[1;32m 11\u001b[0m pdf\u001b[38;5;241m.\u001b[39msave(output_pdf)\n\u001b[1;32m 12\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPassword removed successfully. Saved as:\u001b[39m\u001b[38;5;124m\"\u001b[39m, output_pdf)\n\u001b[0;32m---> 14\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[43mpikepdf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_qpdf\u001b[49m\u001b[38;5;241m.\u001b[39mPasswordError:\n\u001b[1;32m 15\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIncorrect password. Unable to open the PDF.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "\u001b[0;31mAttributeError\u001b[0m: module 'pikepdf' has no attribute '_qpdf'" ] } ], From c2db09ffe1241f11f699cb35f097de2569b9fa00 Mon Sep 17 00:00:00 2001 From: KRISHNA DIPAYAN BHUNIA Date: Mon, 21 Apr 2025 13:44:10 +0530 Subject: [PATCH 8/9] valid braces code --- interview_question_important/interview1.ipynb | 56 +++++++++++++++++++ 1 file changed, 56 insertions(+) create mode 100644 interview_question_important/interview1.ipynb diff --git a/interview_question_important/interview1.ipynb b/interview_question_important/interview1.ipynb new file mode 100644 index 0000000..0a2dd83 --- /dev/null +++ b/interview_question_important/interview1.ipynb @@ -0,0 +1,56 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "8814dc88", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n" + ] + } + ], + "source": [ + "def is_valid_brace_order(s: str) -> bool:\n", + " stack = []\n", + " validbrace = {')':'(','}':'{',']':'['}\n", + " \n", + " for ch in s:\n", + " if ch in validbrace.values():\n", + " stack.append(ch)\n", + " elif ch in validbrace:\n", + " if not stack or stack.pop() != validbrace[ch]:\n", + " return False\n", + " return not stack\n", + "print(is_valid_brace_order(\"{[()]}\")) # True\n", + "print(is_valid_brace_order(\"{[(])}\")) # False" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 4acfc9d856fd993e272385de9c8c5e83f4bc4ab4 Mon Sep 17 00:00:00 2001 From: KRISHNA DIPAYAN BHUNIA Date: Mon, 21 Apr 2025 13:44:30 +0530 Subject: [PATCH 9/9] alingment --- interview_question_important/interview1.ipynb | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/interview_question_important/interview1.ipynb b/interview_question_important/interview1.ipynb index 0a2dd83..83bf637 100644 --- a/interview_question_important/interview1.ipynb +++ b/interview_question_important/interview1.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "8814dc88", "metadata": {}, "outputs": [ @@ -27,6 +27,7 @@ " if not stack or stack.pop() != validbrace[ch]:\n", " return False\n", " return not stack\n", + "\n", "print(is_valid_brace_order(\"{[()]}\")) # True\n", "print(is_valid_brace_order(\"{[(])}\")) # False" ]