semvec/pypi-packages huggingface dataset:
nrc-adams-py 0.0.3
Python Class connect to NRC ADAMS API

Class for Python Interaction with NRC Adams API.

https://www.nrc.gov/site-help/developers/wba-api-developer-guide.pdf

Adams.nrc.gov contains hundreds of thousands of full-text documents that the NRC has released since November 1, 1999, and several hundred new documents are added each day.

The following document libraries at adams.nrc.gov are available to the APIs:

*Public Library. Contains all image and text documents that the NRC has made public since November 1, 1999—over 800,000 full-text documents, and over 60,000 packages (virtual containers of related documents). This collection includes publicly available regulatory guides, NUREG-series reports, inspection reports, Commission documents, correspondence, and other regulatory and technical documents written by NRC staff, contractors, and licensees. The Public Library is available through both the Content Search API and the Advanced Search API.

*Legacy Public Library. Contains over 1.9 million bibliographic records (some with abstracts and full text) that the NRC made public before November 1999. The Legacy Public Library is available only through the Advanced Search API.

Data will change over the co urse of the day as the NRC issues new documents. For this reason counts may vary and may age quickly, depending on site activity and time.

Search result sets for all APIs in this guide are limited to 1,000 results. If more than 1,0000 documents match the search criteria, then the following will occur:

*only the first 1,000 matches will be returned,

*the . . . field in the result set will be set to LocalizedMessage{key='search.documents.limit.exceed.message', params=[1000]} and

*the . . .field in the result set will be set to 1000.
lazynumpy 0.0.1
A wrapper around numpy that does lazy evaluations to optimize for chained matrix multiplication


[![Build Status](https://travis-ci.org/kennethgoodman/lazy_numpy.svg?branch=master)](https://travis-ci.org/kennethgoodman/lazy_numpy)
[![codecov](https://codecov.io/gh/kennethgoodman/lazy_numpy/branch/master/graph/badge.svg)](https://codecov.io/gh/kennethgoodman/lazy_numpy)

# lazynumpy
a lazy evaluated wrapper around numpy

What is gained?

* Chained matrix multiplication will be minimized by keeping the values of the other arrays in memory and solving the associative problem that minimizes the number of computations.
  - only keeps one copy of each matrix [Memory optimization in progress]
* Allow partial matrix returns withou calculating the entire matrix [In Progress]


If you have three matrices with dimensions as below there are two ways to do the matrix multiplication to find the answer:

<a href="https://www.codecogs.com/eqnedit.php?latex=A_{1000\&space;*\1}&space;*&space;B_{1\&space;*\1000}&space;*&space;C_{1000\&space;*\1000}&space;=&space;D_{1000\&space;*\1000}" target="_blank"><img src="https://latex.codecogs.com/gif.latex?A_{1000\&space;*\1}&space;*&space;B_{1\&space;*\1000}&space;*&space;C_{1000\&space;*\1000}&space;=&space;D_{1000\&space;*\1000}" title="A_{1000\ *\1} * B_{1\ *\1000} * C_{1000\ *\1000} = D_{1000\ *\1000}" /></a>

Either:

<a href="https://www.codecogs.com/eqnedit.php?latex=[1]\&space;\&space;(A_{1000\&space;*\1}&space;*&space;B_{1\&space;*\1000})&space;*&space;C_{1000\&space;*\1000}&space;=&space;D_{1000\&space;*\1000}" target="_blank"><img src="https://latex.codecogs.com/gif.latex?[1]\&space;\&space;(A_{1000\&space;*\1}&space;*&space;B_{1\&space;*\1000})&space;*&space;C_{1000\&space;*\1000}&space;=&space;D_{1000\&space;*\1000}" title="[1]\ \ (A_{1000\ *\1} * B_{1\ *\1000}) * C_{1000\ *\1000} = D_{1000\ *\1000}" /></a>

or

<a href="https://www.codecogs.com/eqnedit.php?latex=[2]\&space;\&space;A_{1000\&space;*\1}&space;*&space;(B_{1\&space;*\1000}&space;*&space;C_{1000\&space;*\1000})&space;=&space;D_{100\10001000}" target="_blank"><img src="https://latex.codecogs.com/gif.latex?[2]\&space;\&space;A_{1000\&space;*\1}&space;*&space;(B_{1\&space;*\1000}&space;*&space;C_{1000\&space;*\1000})&space;=&space;D_{100\10001000}" title="[2]\ \ A_{1000\ *\1} * (B_{1\ *\1000} * C_{1000\ *\1000}) = D_{100\10001000}" /></a>

[1] will take `1000 * 1 * 1000` operations to calculate `A * B` plus `1000 * 1000 * 1000` operations to calculate `(A * B) * C`. The total sum to calculate `A * B * C` is equal to `1000^3 + 1000^2`.

[2] will take `1 * 1000 * 1000` operations to calculate `B * C` plus `1000 * 1 * 1000` operations to calculate `A * (B * C)`. The total sum to calculate `A * B * C` is equal to `1000^2 + 1000^2` which means the optimal multiplication order will be ~500 faster.

If you run [the simple example](https://github.com/kennethgoodman/lazynumpy/blob/master/examples/simple_faster_calculation.py) you should see a significant speed up. On my computer there is a 50x speedup with only three matrix calculations.