{"id":13438770,"url":"https://github.com/dpilger26/NumCpp","last_synced_at":"2025-03-20T06:31:22.818Z","repository":{"id":37431052,"uuid":"120571700","full_name":"dpilger26/NumCpp","owner":"dpilger26","description":"C++ implementation of the Python Numpy library","archived":false,"fork":false,"pushed_at":"2025-02-09T04:16:30.000Z","size":122150,"stargazers_count":3766,"open_issues_count":14,"forks_count":572,"subscribers_count":81,"default_branch":"master","last_synced_at":"2025-03-19T04:58:51.265Z","etag":null,"topics":["algorithms","c-plus-plus","cpp","data-structures","mathematical-functions","numerical-analysis","numpy","python","scientific-computing"],"latest_commit_sha":null,"homepage":"https://dpilger26.github.io/NumCpp","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/dpilger26.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE","code_of_conduct":"CODE_OF_CONDUCT.md","threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2018-02-07T06:14:23.000Z","updated_at":"2025-03-16T05:06:19.000Z","dependencies_parsed_at":"2023-02-09T14:15:15.510Z","dependency_job_id":"66f0fb1e-1061-459f-af95-98f85fded936","html_url":"https://github.com/dpilger26/NumCpp","commit_stats":{"total_commits":1096,"total_committers":7,"mean_commits":"156.57142857142858","dds":"0.18065693430656937","last_synced_commit":"5e40aab74d14e257d65d3dc385c9ff9e2120c60e"},"previous_names":[],"tags_count":23,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/dpilger26%2FNumCpp","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/dpilger26%2FNumCpp/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/dpilger26%2FNumCpp/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/dpilger26%2FNumCpp/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/dpilger26","download_url":"https://codeload.github.com/dpilger26/NumCpp/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":244358424,"owners_count":20440360,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["algorithms","c-plus-plus","cpp","data-structures","mathematical-functions","numerical-analysis","numpy","python","scientific-computing"],"created_at":"2024-07-31T03:01:08.292Z","updated_at":"2025-03-20T06:31:22.812Z","avatar_url":"https://github.com/dpilger26.png","language":"C++","readme":"![NumCpp logo](https://github.com/dpilger26/NumCpp/raw/master/docs/logo/NumCppLogo.png)\n\n[![GitHub watchers](https://img.shields.io/github/watchers/dpilger26/NumCpp.svg?style=social\u0026label=Watch\u0026maxAge=2592000)](https://GitHub.com/dpilger26/NumCpp/watchers/)\n[![GitHub stars](https://img.shields.io/github/stars/dpilger26/NumCpp.svg?style=social\u0026label=Star\u0026maxAge=2592000)](https://GitHub.com/dpilger26/NumCpp/stargazers/)\n[![GitHub forks](https://img.shields.io/github/forks/dpilger26/NumCpp.svg?style=social\u0026label=Fork\u0026maxAge=2592000)](https://GitHub.com/dpilger26/NumCpp/network/)\n\n![Build status](https://github.com/dpilger26/NumCpp/actions/workflows/Tests.yml/badge.svg)\n[![Codacy Badge](https://api.codacy.com/project/badge/Grade/ea24c08d892e4beebd46cfca260823c1)](https://app.codacy.com/manual/dpilger26/NumCpp?utm_source=github.com\u0026utm_medium=referral\u0026utm_content=dpilger26/NumCpp\u0026utm_campaign=Badge_Grade_Dashboard)\n[![Awesome](https://awesome.re/badge.svg)](https://awesome.re)\n[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/donate/?hosted_button_id=JDFK4DUMJJWYY)\n\n# NumCpp: A Templatized Header Only C++ Implementation of the [Python NumPy Library](http://www.numpy.org)\n\n## Author: David Pilger \u003cdpilger26@gmail.com\u003e\n\n## Version: ![GitHub tag (latest by date)](https://img.shields.io/github/tag-date/dpilger26/NumCpp.svg?color=blue\u0026label=Official%20Release\u0026style=popout)\n\n## License [![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://lbesson.mit-license.org/)\n\n## Testing\n\n**C++ Standards:**  \n[![C++17](https://img.shields.io/badge/C%2B%2B-17-blue.svg)](https://isocpp.org/std/the-standard)\n[![C++20](https://img.shields.io/badge/C%2B%2B-20-blue.svg)](https://isocpp.org/std/the-standard)\n[![C++23](https://img.shields.io/badge/C%2B%2B-23-blue.svg)](https://isocpp.org/std/the-standard)\n\n**Compilers:**  \nVisual Studio: 2022  \nGNU: 13.3, 14.2  \nClang: 18, 19  \n\n**Boost Versions:**  \n1.73+\n\n## [Documentation](https://dpilger26.github.io/NumCpp)\n\n## [GitHub](https://github.com/dpilger26/NumCpp)\n\n[![Star History Chart](https://api.star-history.com/svg?repos=dpilger26/NumCpp\u0026type=Date)](https://star-history.com/#dpilger26/NumCpp\u0026Date)\n\n## [Installation](https://github.com/dpilger26/NumCpp/tree/master/docs/markdown/Installation.md)\n\n## [Building](https://github.com/dpilger26/NumCpp/tree/master/docs/markdown/Building.md)\n\n## [Release Notes](https://github.com/dpilger26/NumCpp/tree/master/docs/markdown/ReleaseNotes.md)\n\n## From NumPy To NumCpp – A Quick Start Guide\n\nThis quick start guide is meant as a very brief overview of some of the things\nthat can be done with **NumCpp**.  For a full breakdown of everything available\nin the **NumCpp** library please visit the [Full Documentation](https://dpilger26.github.io/NumCpp).\n\n### CONTAINERS\n\nThe main data structure in **NumCpp** is the `NdArray`.  It is inherently a 2D array class, with 1D arrays being implemented as 1xN arrays.  There is also a `DataCube` class that is provided as a convenience container for storing an array of 2D `NdArray`s, but it has limited usefulness past a simple container.\n\n|                  **NumPy**                   |                      **NumCpp**                       |\n| :------------------------------------------: | :---------------------------------------------------: |\n| ```a = np.array([[1, 2], [3, 4], [5, 6]])``` | ```nc::NdArray\u003cint\u003e a = { {1, 2}, {3, 4}, {5, 6} }``` |\n|           ```a.reshape([2, 3])```            |                 ```a.reshape(2, 3)```                 |\n|          ```a.astype(np.double)```           |               ```a.astype\u003cdouble\u003e()```                |\n\n### INITIALIZERS\n\nMany initializer functions are provided that return `NdArray`s for common needs.\n\n|          **NumPy**          |                       **NumCpp**                       |\n| :-------------------------: | :----------------------------------------------------: |\n| ```np.linspace(1, 10, 5)``` |          ```nc::linspace\u003cdtype\u003e(1, 10, 5)```           |\n|    ```np.arange(3, 7)```    |             ```nc::arange\u003cdtype\u003e(3, 7)```              |\n|       ```np.eye(4)```       |                ```nc::eye\u003cdtype\u003e(4)```                 |\n|   ```np.zeros([3, 4])```    |              ```nc::zeros\u003cdtype\u003e(3, 4)```              |\n|                             |          ```nc::NdArray\u003cdtype\u003e(3, 4) a = 0```          |\n|    ```np.ones([3, 4])```    |              ```nc::ones\u003cdtype\u003e(3, 4)```               |\n|                             |          ```nc::NdArray\u003cdtype\u003e(3, 4) a = 1```          |\n|    ```np.nans([3, 4])```    |                  ```nc::nans(3, 4)```                  |\n|                             | ```nc::NdArray\u003cdouble\u003e(3, 4) a = nc::constants::nan``` |\n|   ```np.empty([3, 4])```    |              ```nc::empty\u003cdtype\u003e(3, 4)```              |\n|                             |            ```nc::NdArray\u003cdtype\u003e(3, 4) a```            |\n\n### SLICING/BROADCASTING\n\n**NumCpp** offers **NumPy** style slicing and broadcasting.\n\n|     **NumPy**      |                **NumCpp**                 |\n| :----------------: | :---------------------------------------: |\n|   ```a[2, 3]```    |               ```a(2, 3)```               |\n| ```a[2:5, 5:8]```  | ```a(nc::Slice(2, 5), nc::Slice(5, 8))``` |\n|                    |          ```a({2, 5}, {5, 8})```          |\n|   ```a[:, 7]```    |          ```a(a.rSlice(), 7)```           |\n|   ```a[a \u003e 5]```   |              ```a[a \u003e 5]```               |\n| ```a[a \u003e 5] = 0``` |         ```a.putMask(a \u003e 5, 0)```         |\n\n### RANDOM\n\nThe random module provides simple ways to create random arrays.\n\n|               **NumPy**                |                       **NumCpp**                       |\n| :------------------------------------: | :----------------------------------------------------: |\n|       ```np.random.seed(666)```        |              ```nc::random::seed(666)```               |\n|      ```np.random.randn(3, 4)```       |    ```nc::random::randN\u003cdouble\u003e(nc::Shape(3, 4))```    |\n|                                        |        ```nc::random::randN\u003cdouble\u003e({3, 4})```         |\n| ```np.random.randint(0, 10, [3, 4])``` | ```nc::random::randInt\u003cint\u003e(nc::Shape(3, 4), 0, 10)``` |\n|                                        |     ```nc::random::randInt\u003cint\u003e({3, 4}, 0, 10)```      |\n|       ```np.random.rand(3, 4)```       |     ```nc::random::rand\u003cdouble\u003e(nc::Shape(3,4))```     |\n|                                        |         ```nc::random::rand\u003cdouble\u003e({3, 4})```         |\n|      ```np.random.choice(a, 3)```      |             ```nc::random::choice(a, 3)```             |\n\n### CONCATENATION\n\nMany ways to concatenate `NdArray` are available.\n\n|             **NumPy**             |                **NumCpp**                 |\n| :-------------------------------: | :---------------------------------------: |\n| ```np.stack([a, b, c], axis=0)``` | ```nc::stack({a, b, c}, nc::Axis::ROW)``` |\n|    ```np.vstack([a, b, c])```     |        ```nc::vstack({a, b, c})```        |\n|    ```np.hstack([a, b, c])```     |        ```nc::hstack({a, b, c})```        |\n|   ```np.append(a, b, axis=1)```   |   ```nc::append(a, b, nc::Axis::COL)```   |\n\n### DIAGONAL, TRIANGULAR, AND FLIP\n\nThe following return new `NdArray`s.\n\n|        **NumPy**         |            **NumCpp**            |\n| :----------------------: | :------------------------------: |\n|   ```np.diagonal(a)```   |      ```nc::diagonal(a)```       |\n|     ```np.triu(a)```     |        ```nc::triu(a)```         |\n|     ```np.tril(a)```     |        ```nc::tril(a)```         |\n| ```np.flip(a, axis=0)``` | ```nc::flip(a, nc::Axis::ROW)``` |\n|    ```np.flipud(a)```    |       ```nc::flipud(a)```        |\n|    ```np.fliplr(a)```    |       ```nc::fliplr(a)```        |\n\n### ITERATION\n\n**NumCpp** follows the idioms of the C++ STL providing iterator pairs to iterate on arrays in different fashions.\n\n|      **NumPy**       |                     **NumCpp**                     |\n| :------------------: | :------------------------------------------------: |\n| ```for value in a``` | ```for(auto it = a.begin(); it \u003c a.end(); ++it)``` |\n|                      |             ```for(auto\u0026 value : a)```             |\n\n### LOGICAL\n\nLogical FUNCTIONS in **NumCpp** behave the same as **NumPy**.\n\n|          **NumPy**          |          **NumCpp**          |\n| :-------------------------: | :--------------------------: |\n| ```np.where(a \u003e 5, a, b)``` | ```nc::where(a \u003e 5, a, b)``` |\n|       ```np.any(a)```       |       ```nc::any(a)```       |\n|       ```np.all(a)```       |       ```nc::all(a)```       |\n| ```np.logical_and(a, b)```  | ```nc::logical_and(a, b)```  |\n|  ```np.logical_or(a, b)```  |  ```nc::logical_or(a, b)```  |\n|   ```np.isclose(a, b)```    |   ```nc::isclose(a, b)```    |\n|   ```np.allclose(a, b)```   |   ```nc::allclose(a, b)```   |\n\n### COMPARISONS\n\n|            **NumPy**             |                **NumCpp**                |\n| :------------------------------: | :--------------------------------------: |\n|       ```np.equal(a, b)```       |          ```nc::equal(a, b)```           |\n|                                  |               ```a == b```               |\n|     ```np.not_equal(a, b)```     |        ```nc::not_equal(a, b)```         |\n|                                  |               ```a != b```               |\n| ```rows, cols = np.nonzero(a)``` | ```auto [rows, cols] = nc::nonzero(a)``` |\n\n### MINIMUM, MAXIMUM, SORTING\n\n|          **NumPy**          |             **NumCpp**              |\n| :-------------------------: | :---------------------------------: |\n|       ```np.min(a)```       |          ```nc::min(a)```           |\n|       ```np.max(a)```       |          ```nc::max(a)```           |\n|     ```np.argmin(a)```      |         ```nc::argmin(a)```         |\n|     ```np.argmax(a)```      |         ```nc::argmax(a)```         |\n|  ```np.sort(a, axis=0)```   |  ```nc::sort(a, nc::Axis::ROW)```   |\n| ```np.argsort(a, axis=1)``` | ```nc::argsort(a, nc::Axis::COL)``` |\n|     ```np.unique(a)```      |         ```nc::unique(a)```         |\n|  ```np.setdiff1d(a, b)```   |      ```nc::setdiff1d(a, b)```      |\n|      ```np.diff(a)```       |          ```nc::diff(a)```          |\n\n### REDUCERS\n\nReducers accumulate values of `NdArray`s along specified axes. When no axis is specified, values are accumulated along all axes.\n\n|             **NumPy**             |                **NumCpp**                 |\n| :-------------------------------: | :---------------------------------------: |\n|          ```np.sum(a)```          |             ```nc::sum(a)```              |\n|      ```np.sum(a, axis=0)```      |      ```nc::sum(a, nc::Axis::ROW)```      |\n|         ```np.prod(a)```          |             ```nc::prod(a)```             |\n|     ```np.prod(a, axis=0)```      |     ```nc::prod(a, nc::Axis::ROW)```      |\n|         ```np.mean(a)```          |             ```nc::mean(a)```             |\n|     ```np.mean(a, axis=0)```      |     ```nc::mean(a, nc::Axis::ROW)```      |\n|     ```np.count_nonzero(a)```     |        ```nc::count_nonzero(a)```         |\n| ```np.count_nonzero(a, axis=0)``` | ```nc::count_nonzero(a, nc::Axis::ROW)``` |\n\n### I/O\n\nPrint and file output methods.  All **NumCpp** classes support a `print()` method and `\u003c\u003c` stream operators.\n\n|               **NumPy**               |                **NumCpp**                 |\n| :-----------------------------------: | :---------------------------------------: |\n|            ```print(a)```             |              ```a.print()```              |\n|                                       |           ```std::cout \u003c\u003c a```            |\n|  ```a.tofile(filename, sep=’\\n’)```   |      ```a.tofile(filename, '\\n')```       |\n| ```np.fromfile(filename, sep=’\\n’)``` | ```nc::fromfile\u003cdtype\u003e(filename, '\\n')``` |\n|      ```np.dump(a, filename)```       |        ```nc::dump(a, filename)```        |\n|        ```np.load(filename)```        |      ```nc::load\u003cdtype\u003e(filename)```      |\n\n### MATHEMATICAL FUNCTIONS\n\n**NumCpp** universal functions are provided for a large set number of mathematical functions.\n\n#### BASIC FUNCTIONS\n\n|         **NumPy**          |         **NumCpp**          |\n| :------------------------: | :-------------------------: |\n|      ```np.abs(a)```       |      ```nc::abs(a)```       |\n|      ```np.sign(a)```      |      ```nc::sign(a)```      |\n|  ```np.remainder(a, b)```  |  ```nc::remainder(a, b)```  |\n|   ```np.clip(a, 3, 8)```   |   ```nc::clip(a, 3, 8)```   |\n| ```np.interp(x, xp, fp)``` | ```nc::interp(x, xp, fp)``` |\n\n#### EXPONENTIAL FUNCTIONS\n\n|     **NumPy**     |     **NumCpp**     |\n| :---------------: | :----------------: |\n|  ```np.exp(a)```  |  ```nc::exp(a)```  |\n| ```np.expm1(a)``` | ```nc::expm1(a)``` |\n|  ```np.log(a)```  |  ```nc::log(a)```  |\n| ```np.log1p(a)``` | ```nc::log1p(a)``` |\n\n#### POWER FUNCTIONS\n\n|      **NumPy**       |      **NumCpp**       |\n| :------------------: | :-------------------: |\n| ```np.power(a, 4)``` | ```nc::power(a, 4)``` |\n|   ```np.sqrt(a)```   |   ```nc::sqrt(a)```   |\n|  ```np.square(a)```  |  ```nc::square(a)```  |\n|   ```np.cbrt(a)```   |   ```nc::cbrt(a)```   |\n\n#### TRIGONOMETRIC FUNCTIONS\n\n|    **NumPy**    |    **NumCpp**    |\n| :-------------: | :--------------: |\n| ```np.sin(a)``` | ```nc::sin(a)``` |\n| ```np.cos(a)``` | ```nc::cos(a)``` |\n| ```np.tan(a)``` | ```nc::tan(a)``` |\n\n#### HYPERBOLIC FUNCTIONS\n\n|    **NumPy**     |    **NumCpp**     |\n| :--------------: | :---------------: |\n| ```np.sinh(a)``` | ```nc::sinh(a)``` |\n| ```np.cosh(a)``` | ```nc::cosh(a)``` |\n| ```np.tanh(a)``` | ```nc::tanh(a)``` |\n\n#### CLASSIFICATION FUNCTIONS\n\n|     **NumPy**     |     **NumCpp**     |\n| :---------------: | :----------------: |\n| ```np.isnan(a)``` | ```nc::isnan(a)``` |\n| ```np.isinf(a)``` | ```nc::isinf(a)``` |\n\n#### LINEAR ALGEBRA\n\n|             **NumPy**              |               **NumCpp**               |\n| :--------------------------------: | :------------------------------------: |\n|      ```np.linalg.norm(a)```       |           ```nc::norm(a)```            |\n|         ```np.dot(a, b)```         |          ```nc::dot(a, b)```           |\n|       ```np.linalg.det(a)```       |        ```nc::linalg::det(a)```        |\n|       ```np.linalg.inv(a)```       |        ```nc::linalg::inv(a)```        |\n|    ```np.linalg.lstsq(a, b)```     |     ```nc::linalg::lstsq(a, b)```      |\n| ```np.linalg.matrix_power(a, 3)``` |  ```nc::linalg::matrix_power(a, 3)```  |\n| ```Np.linalg.multi_dot(a, b, c)``` | ```nc::linalg::multi_dot({a, b, c})``` |\n|       ```np.linalg.svd(a)```       |        ```nc::linalg::svd(a)```        |\n","funding_links":["https://www.paypal.com/donate/?hosted_button_id=JDFK4DUMJJWYY"],"categories":["Math","C++","Mathematics","C/C++程序设计"],"sub_categories":["资源传输下载"],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fdpilger26%2FNumCpp","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fdpilger26%2FNumCpp","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fdpilger26%2FNumCpp/lists"}