Saravanan666/pypi-org huggingface dataset:
Package: algaestat
algaestat is a package to extract, transform and aggregate Algae cultivation data.
A series of proprietary and open-source instruments collected this data:
Burge Environmental MiProbe (Algae Probe), YSI (Algae Probe), HoboLink (Weather Data)
pH Meters.
Free from notebook entries are also accessible.
Cultivation data.
- Algae Pool Status including, levels, temperature.
- This package contains classes to:
- Query the WS Dynomodb (where the data is stored).
- Extract data from AWS Dynomodb,
- Transform and aggregate the data to relational tables or JSON formats.
- Export results as files (i.e. csv)
Package: algebra
AlgebraAlgebraic structuresNote:Algebra requires Python 3.6 or higher.Requirements and InstallationpipinstallalgebraSee alsothe instructions here.AlgebraThis package provides an algebra where the elements can be manipulated
in a natural way, with basic algebraic simplifications happening automatically.
It also support equality checking, which is conservative:
ifx == y, thenxis equal toy;
but ifx != y, then eitherxis different fromy, or it could not be
proven thatxis equal toy.As an example, let's create numbered elements.fromalgebraimportElementclassNumbered(Element):total=0def__init__(self):self.num=Numbered.totalNumbered.total+=1defrender(self,formatter):returnf'x{self.num}'Then instances ofNumberedcan be manipulated as follows.>>>x0=Numbered()>>>x1=Numbered()>>>x0==x0True>>>x0==x1False>>>x0+x1x0+x1>>>x0+x02*x0>>>x0+x1==x1+x0True>>>x0-x00>>>2+x02*1+x0>>>(2+x0)*x1(2*1+x0)*x1>>>(2+x0)*x1*00Create Your Own AlgebraComing soon.Function AlgebraComing soon.Create Your Own Function AlgebraComing soon.
Package: algebra-collections
Django Algebraic CalculatorAplikasi web penghitungan aljabar untuk kelompok 7 Pemrograman Berbasis Penggunaan Ulang, Universitas Brawijaya.Anggota205150400111052 - AURELIUS ALEXANDER VIRIYA205150407111019 - BAGAS RADITYA NUR LISTYAWAN205150407111025 - KHALIFFMAN RAHMAT HILAL205150407111016 - RIZAL AKBAR SYAH FAUZAN PUTRAInstallation & UsageWithout UIInstall on your project’s virtual environmentUse this following syntax to install the package:'pip install algebra-collections'Add ‘algebra_calculator’ to your Django project’s “setting.py” INSTALLED_APPS:INSTALLED_APPS = [
    ...
    'algebra_calculator',
]Import ‘algebra_calculator’ to your app’s ‘views.py’ in order to use the pre-made Linear Equations or develop other type of Algebraic EquationsExample using pre-made LinearEquations(linear.views file):from algebra_calculator import *def showXandYvalue():listOfChars = [‘X’, ‘Y’]
listOfExpressions = [“2X + 5Y = 10”, “3X + 2Y = 30”]result = LinearEquations.solve(2, listOfChars, listOfExpressions)for i in range(len(result)):printable(f”{listOfChars[i]}’s value is = {result}”)return HttpResponse(printable)Example developing other type of Algebraic Equations (commutative.views file):class CommutativeAlgebra(AlgebraFactory):def solve(…):
…
…def finishCommutativeAlgebra():result = CommutativeAlgebra.solve(…)return HttpResponse(result)With UIInstall on your project’s virtual environmentUse this following syntax to install the package:'pip install algebra-collections'Add ‘algebra_calculator’ and ‘ui’ to your Django project’s “setting.py” INSTALLED_APPS:INSTALLED_APPS = [
...
'algebra_calculator',
'ui',
]Include the poll URLconf in your project’s urls.py:urlpattern = [
    ...
    path('[your_pathing_here/]', include('ui.urls')),
]Access the Linear Equation’s UI by running server and using the following url:127.0.0.1:8000/[your_pathing_here]/TwoExpression_LinearEquations
Package: algebraIberoIA
algebraLinealLibrería que te permite utilizar funciones básicas de álgebra linealfunciones y cómo utilizarlaspedir_matriz(filas, columnas)
la función pedir_matriz te pedirá un valor por cada fila y columna, y agregará el valor a una matrizdeterminante(matriz, filas, columnas)
la función determinante retornará el valor del determinante de la matriz si ésta es cuadrada; si no, retornará la cadena de texto: "Solo se pueden obtener determinantes de matrices cuadradas"producto_escalar(escalar, matriz)
la función producto_escalar multiplicará cada valor en la matriz por un escalar, retornando como resultado la matriz resultantesuma_matrices(matriz1, matriz2)
la función suma_matrices retornará una sola matriz en la que los valores de las dos matrices en los parámetros se sumaronresta_matrices(matriz1, matriz2)
la función resta_matrices retornará una sola matriz en la que los valores de las dos matrices en los parámetros se restaron
Package: algebraic-data-type
Algebraic Data TypeTo install the packagepip install  algebraic-data-typeADT[To be written]Pattern Matchingfrom adt import Multimethod

 with Multimethod() as fib: 
        fib[1] = 1 
        fib[2] = 1 
        fib[int] =  lambda x: fib(x-1) + fib(x-2)TestTo run the tests, clone the repo and use pytest>>> git clone https://github.com/catethos/adt.git

>>> cd adt/

>>> pytest
Package: algebraics
Algebraic NumbersLibraryUse when you need exact arithmetic, speed is not critical, and rational numbers aren't good enough.Example:usealgebraics::prelude::*;usealgebraics::RealAlgebraicNumberasNumber;lettwo=Number::from(2);// 2 is a rational numberassert!(two.is_rational());// 1/2 is the reciprocal of 2letone_half=two.recip();// 1/2 is also a rational numberassert!(one_half.is_rational());// 2^(1/4)letroot=(&two).pow((1,4));// we can use all the standard comparison operatorsassert!(root!=Number::from(3));assert!(root<Number::from(2));assert!(root>Number::from(1));// we can use all of add, subtract, multiply, divide, and remainderletsum=&root+&root;letdifference=&root-Number::from(47);letproduct=&root*&one_half;letquotient=&one_half/&root;letremainder=&root%&one_half;// root is not a rational numberassert!(!root.is_rational());// the calculations are always exactassert_eq!((&root).pow(4),two);// lets compute 30 decimal places of rootletscale=Number::from(10).pow(30);letscaled=&root*scale;letdigits=scaled.into_integer_trunc();assert_eq!(digits.to_string(),1_18920_71150_02721_06671_74999_70560u128.to_string());// get the minimal polynomialletother_number=root+two.pow((1,2));assert_eq!(&other_number.minimal_polynomial().to_string(),"2 + -8*X + -4*X^2 + 0*X^3 + 1*X^4");// works with really big numbersletreally_big=Number::from(1_00000_00000i64).pow(20)+Number::from(23);assert_eq!(&really_big.to_integer_floor().to_string(),"100000000000000000000000000000000000000000000\000000000000000000000000000000000000000000000\000000000000000000000000000000000000000000000\000000000000000000000000000000000000000000000\000000000000000000023")Python supportUsing algebraics from Python:python3-mpipinstallalgebraicsfromalgebraicsimportRealAlgebraicNumbersqrt_2=2**(RealAlgebraicNumber(1)/2)assertsqrt_2*sqrt_2==2Using algebraics in your own Rust project:[dependencies.algebraics]version="0.3"Developing algebraics:cargoinstallmaturin
maturindevelop--cargo-extra-args="--features python-extension"
Package: algebraMathGenerator
Algebra generator that can easily create algebra equations in the Ax + b = C format. It can also solve equations in Ax + b = C. Right now, only the operations, '-' and '+' are supportedGetting StartedThe following is an example of how to create a algebra math equation. ThealgebraMathGenerator.generateAlgebraEquation()will return a class, so you can get the equation by adding a.equationafter it.importalgebraMathGeneratorequationClass=algebraMathGenerator.generateAlgebraEquation(operation="+")print(equationClass.equation)# returns equationYou can solve equations withalgebraMathGenerator.solveAlgebraEquation(equation : class). The equation variable should be a class returned fromalgebraMathGenerator.generateAlgebraEquation()importalgebraMathGeneratorequationClass=algebraMathGenerator.generateAlgebraEquation(operation="+")answer=algebraMathGenerator.solveAlgebraEquation(equationClass)print(equationClass.equation)# returns an equationprint(answer)# returns the answer to the equation aboveYou can even loop through the generate method to produce a bunch of equations and their answers!DocumentationClassalgebraMathGenerator2 functionsFunction:.generateAlgebraEquation(operation : str).equation- returns the equation Example:2x + 4 = 6.variable- returns the variable Example:x.operation- returns the operation done Example:+.equalsTo- returns the number the equation is equal to. Example:6.coeffecient- returns the number mutiplied by the variable Example:2.constant- returns the constant term in the equation. Example:4ReturnsclassobjectFunction:solveAlgebraEquation(equation : class)Input should be of type.generateAlgebraEquation()ReturnsfloatvalueChange Log0.0.3 (04/23/2020)Updating documentation
Package: algebra.py
algebraInstall withPyPipip install algebra.pyHow to useImportingfromalgebra.componentsimporttermInitializingNote: to see the output shown in the comments you will need to runprint()orstr()at the answerNote:Do not use j as a variable.it is being used for complex number handlingterm1=term('2x')# 2x#exponent in termsterm2=term('2x²')# 2x²term3=term('2x2')# also works#supports multiple variablesterm4=term('2x2y3')# 2x²y³# suports negative coefficientsterm5=term('-2x3')# -2x³#supports complex exponents and coefficientsterm6=term('2x2+2j')# 2x²⁺²ⁱterm7=term('3+1jx3')# (3+1j)x³Accesssing propertiest1=term('2x3+2jy4+3j')# 2x³⁺²ⁱy⁴⁺³ⁱ# coefficientt1.coefficiente# 2# variablest1.variables# list of the variables,in alphabetic ordert1.variables[0].letra# xt1.variables[0].exponente# (3+2j)Supported Operationssumsubstraction is supported the same waysum1=term('2x')+term('3x')# 5xsum2=term('2x')+term('2y')# 2x + 2y# supports integer,float or decimal sumssum3=term('3x')+4# 3x + 4# supports complex sumssum4=term('3x2+1j')+term('3x3+2j')# 3x²⁺¹ⁱ + 3x³⁺²ⁱ#supports sums with complex numberssum5=term('3x2+1j')+5-2j# 3x²⁺¹ⁱ + (5-2j)multiplicationmul1=term('2x')*4# 8xmul2=term('2x')*term('3x')# 6x²mul3=term('2x')*term('3y')# 6xymul4=term('2xy')*term('3yz')# 6xy²zmul5=term('3x1+3j')*term('3x')# 9x²⁺³ⁱmul6=term('3x1+3j')*(2+1j)# (6+3j)x¹⁺³ⁱmul7=term('3x1+3j')*term('3x2+4j')#9x³⁺⁷ⁱdivisiondiv1=term('4x')/2# 2xdiv2=term('4x')/term('2x')# 2div3=term('4x2')/term('4x')# xdiv4=term('4x')/term('4x2')# xᐨ¹div5=term('4x2')/term('4x2')# 1Exponentiationexp1=term('2x')**2#4x²exp2=term('2x')**-1# 0.5xᐨ¹exp2=term('2x')**term('2x')# not supportedexp3=term('2x')**2.5# 5.656854249492381x⁵ᐟ²polynomsexamplepol1=term('2x')+term('3y')# 2x + 3ypol2=term('2x')-2# 2x - 2# polynom propertiespol2.variables# list of termspol2.variables[0]# 2xpol2.variables[1]# -2# sumpol4=pol1+pol2#  4x + 3y - 2# multiplicationpol5=pol1*pol2# 4x² + 6xy + -4x + -6y'# exponentiationpol6=pol1**2# 4x² + 12xy + 9y²pol7=pol1**2.5# non-integer powers are not yet supportedpol8=pol1**pol2# not supporteddiv1=pol1/2# x + 1.5ydiv2=pol1/term('2x')# 1 + 1.5xᐨ¹ydiv3=pol1/pol2# not supportedsubstituting numbers to the variablesterm1=term('2y')pol1=term('2x')+term('3y')term1.plot(y=2)# 4pol1.plot(x=2,y=3)# 13# univ sets every variable which does not has a value to its valuepol1.plot(univ=5)# 25 (x=5,y=5)pol1.plot(x=2,univ=4)# 16 (only replaces y,x is set to 2)accessing properties on termst1=term('2x²y')t1.coefficiente# acceses the coefficient (2)t1.variables# accesses the list of variables (returns [x²,y])t1.variables[0].letra# xt1.variables[0].exponente# 2accessing properties on polynomst1=term('2x²y')t2=2p1=t1+t2# 2x²y + 2p1.variables# [term(2x²y),2]foriinp1:print(i)#  iterating a polynom iterates over the list of terms#  it contains# term() objects cannot be iterated overpolynoms support sum, substraction, multiplication and exponents as terms do.have fun!
Package: algeria
🇩🇿 Algeria 🇩🇿Algeria is a Python library that allows you to calculate the (clé) and RIP (Relevé d'Identité Postal) of a given CCP (Compte de Chèque Postal) number account. It provides a simple and convenient way to obtain the clé and rip values for CCP accounts. Please note that additional features may be added to the library in the future. You can check features section for any updates.Contributions are welcome! If you would like to contribute to the development of the Algeria library, feel free to submit pull requests or open issues on the GitHub repository.💡 FeaturesClé (Compte de Chèque Postal) calculation.RIP (Relevé d'Identité Postal) calculation.RIP's Clé calculation.Deposit fees calculationCheckout fees calculation📌 InstalationYou can install the "algeria" library using pip:pipinstallalgeriaIf you want to use the development version:pipinstallgit+https://github.com/mouh2020/algeria.git📚 UsageCCP class :The CCP class provides methods to calculate the (clé) and (RIP) for a given CCP account number.InitializationTo create an instance of the CCP class, pass the CCP account number as a string to the constructor:fromalgeria.ccpimportCCPccp_account=CCP("1234567890")Calculating the cléTo calculate the clé of the CCP account, use the get_cle method:cle=ccp_account.get_cle()print("Clé CCP:",cle)Calculating the ripTo calculate the rip of the CCP account, including the first 8 digits "00799999", use the get_rip method:rip=ccp_account.get_rip()print("RIP:",rip)Calculating the cle of the ripTo calculate only the clé of the rip, use the get_rip_cle method:rip_cle=ccp_account.get_rip_cle()print("RIP Clé:",rip_cle)Transaction class :The Transaction class provides methods to calculate the fees of a deposit or checkout amount.InitializationTo create an instance of the Transaction class, pass the amount as a float to the constructor:fromalgeria.ccpimportTransactiontransaction=Transaction(2000000)Calculating the fees of a deposit transactionTo calculate the fees of a deposit transaction, use the get_deposit_fees method:transaction_fees=transaction.get_deposit_fees()print("Deposit fees:",transaction_fees)Calculating the fees of a checkout transactionTo calculate the fees of a checkout transaction, use the get_checkout_fees method:checkout_fees=transaction.get_checkout_fees()print("Checkout fees:",checkout_fees)ExampleHere's an example demonstrating the usage of the "algeria" library :fromalgeria.ccpimportCCP,Transactionccp_account=CCP("1234567890")cle=ccp_account.get_cle()print("Clé CCP:",cle)// 45rip=ccp_account.get_rip()print("RIP:",rip)// 0079999912345678906rip_cle=ccp_account.get_rip_cle()print("RIP Clé:",rip_cle)// 06transaction=Transaction(2000000)deposit_fees=transaction.get_deposit_fees()print("Deposit fees:",deposit_fees)// 4818checkout_fees=transaction.get_checkout_fees()print("Checkout fees:",checkout_fees)// 9018💡 NoteThe algorithms extracted from the web app providedhereafter testing them.🚀 About MeA self-taught Python programmer who enjoys developing simple scripts, bots, and automation tools.
Package: algmonbody
the Algmon Body libcompany introhttps://algmon.com/lib introhttps://algmon.com/docs/infra/introlib source codegithubgiteehttps://gitee.com/algmon/public/tree/master/src/algmon-brainlib features(for human and env)3D & 4D & 5D time & space modelingsequence & position motion computation & simulationstatic & dynamic interaction among objectsdependenciesthe licenseThis package is released under the Apache License v2
Package: algmonbrain
the Algmon Brain libcompany introhttps://algmon.com/lib introhttps://algmon.com/docs/infra/introlib source codegithubgiteehttps://gitee.com/algmon/public/tree/master/src/algmon-brainlib featuresintents simulation in deepsingle neural re-modelingneural network design & training & prediction at scaledependenciesthe licenseThis package is released under the Apache License v2
Package: algmoninfra
the Algmon Infra libcompany introhttps://algmon.com/lib introhttps://algmon.com/docs/infra/introlib source codegithubgiteehttps://gitee.com/algmon/public/tree/master/src/algmon-brainlib featuresbe stableat scalein intelligentdependenciesthe licenseThis package is released under the Apache License v2
Package: algmonpositiveflow
Algmon PositiveFlow toolkitcompany introhttps://algmon.com/toolkit introhttps://algmon.com/docs/infra/introfeaturesfocus ONLY on upper level applications & apisFAST prototyping for pocs and engineering projectseasy BABY Code for everyone to read, understand and writedependend python packagesalgmonbrain for brain support(algmon) ➜ pip install algmonbrainalgmonbody for body support(algmon) ➜ pip install algmonbodyalgmoninfra for computation infra support(algmon) ➜ pip install algmoninfrahow to publishpython -m build(optional) twine upload -r testpypi dist/*twine upload --skip-existing dist/*how to installpip install -r requirements.txthow to testhow to runpython main.pythe licenseApache License v2
Package: algnuth
![travis](https://travis-ci.org/louisabraham/algnuth.svg?branch=master)Algebraic Number Theory packageLouis AbrahamandYassir AkramInstallationpip install –upgrade algnuthor get the development version with:pip install –upgrade git+https://github.com/louisabraham/algnuthFeatures### Jacobi symbol` pycon >>> from algnuth.jacobi import jacobi >>> jacobi(3763, 20353)-1`### Solovay-Strassen primality test` pycon >>> from algnuth.jacobi import solovay_strassen >>> p = 12779877140635552275193974526927174906313992988726945426212616053383820179306398832891367199026816638983953765799977121840616466620283861630627224899026453 >>> q = 12779877140635552275193974526927174906313992988726945426212616053383820179306398832891367199026816638983953765799977121840616466620283861630627224899027521 >>> n = p * q >>> solovay_strassen(p) True >>> solovay_strassen(q) True >>> solovay_strassen(n) False `### Quadratic forms` pycon >>> from algnuth.quadratic import * >>>display_classes(-44)x^2 + 11⋅y^2 2⋅x^2 + 2⋅xy + 6⋅y^2 3⋅x^2 - 2⋅xy + 4⋅y^2 3⋅x^2 + 2⋅xy + 4⋅y^2 >>>display_primitive_forms(-44)x^2 + 11⋅y^2 3⋅x^2 - 2⋅xy + 4⋅y^2 3⋅x^2 + 2⋅xy + 4⋅y^2 >>>display_ambiguous_classes(-44)x^2 + 11⋅y^2 2⋅x^2 + 2⋅xy + 6⋅y^2 >>>display(*reduced(18,-10,2)) 2⋅x^2 + 2⋅xy + 6⋅y^2 `### Real polynomials` pycon >>> from algnuth.polynom import Polynomial >>> P =Polynomial([0]* 10 +[-1,0, 1]) >>> print(P)X^12-X^10>>> P(2) 3072 >>> P.disc 0 >>> P.sturm() # Number of distinct real roots 3 >>> P.r1 # Number of real roots with multiplicity 12 `### Modular arithmetic` pycon >>> P =Polynomial([1,2, 3]) >>> Pmodp = P % 41 >>> print(Pmodp ** 3) 27⋅X^6+13⋅X^5+22⋅X^4+3⋅X^3+21⋅X^2+6⋅X+1 >>>print((P** 3) % 41) 27⋅X^6+13⋅X^5+22⋅X^4+3⋅X^3+21⋅X^2+6⋅X+1 `### Polynomial division` pycon >>> A =Polynomial([1,2, 3, 4]) % 7 >>> B =Polynomial([0,1, 2]) % 7 >>> print(A) 4⋅X^3+3⋅X^2+2⋅X+1 >>> print(B) 2⋅X^2+X >>> print(A % B) 5⋅X+1 >>> print(A // B) 2⋅X+4 >>>print((A// B) * B + A % B) 4⋅X^3+3⋅X^2+2⋅X+1 `### Berlekamp’s factorization algorithm` pycon >>> P =Polynomial([0,1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]) >>> Pmodp = P % 41 >>>print(Polynomial.ppfactors(Pmodp.factor()))12⋅(X+31)⋅X⋅(X^2+40⋅X+24)⋅(X^2+36⋅X+13)⋅(X^6+34⋅X^5+26⋅X^4+13⋅X^3+25⋅X^2+26⋅X+35)`### Unique Factorization of Ideals` pycon >>> from algnuth.ideals import factorIdeals >>>factorIdeals(Polynomial([4,0, 0,1]))X^3+4 mod 2 = X^3 (2) = (2,α)^3X^3+4 mod 3 =(X+1)^3(3) = (3,α+1)^3X^3+4 mod 5 =(X+4)⋅(X^2+X+1)(5) = (5,α+4)⋅(5,α^2+α+1) `
Package: algoaid
algoaidA collection of useful tools for students taking an introductory course in algorithms and data structures.InstallationpipinstallalgoaidFeaturesTime complexity analysis of functionsGraphsRepresent: [weighted] [un]directed, disjoint-set/union findEasy to input a graphRun basic graph algorithms (DFS, BFS, MST, Dijkstra's and more)Visualise resultsVersatile Min/Max-heap withdecrease/increasekey functionalityModulesTime complexity:analyseGraph class:GraphPriority queues:MinHeap,MaxHeapUsage: Time Complexity AnalysisAnalyse time complexity of a function with a single parameter:1. Importfromalgoaidimportanalyse2. Define a Functiondeff(n):j=1whilej*j<n:j+=13. Analyseanalyse(f)Example ResultUsage: GraphsConstruct various types of graphs and run a selection of popular graph algorithms:1. ImportfromalgoaidimportGraph2. Declare the Graph (each line represents an edge)edges="""0..2 60..1 10..5 2...2..5 4"""Syntax:Undirected:[node1]..[node2] [weight (optional)]Directed:[from]..[to] [weight (optional)]Disjoint-set:[parent]..[child]3. Construct the Graph# construct undirected graphg=Graph(edges,type=Graph.GraphType.GRAPH)# construct directed graphg=Graph(edges,type=Graph.GraphType.DI_GRAPH)# construct disjoint setg=Graph(edges,type=Graph.GraphType.DISJOINT_SET)4. Display the Graphg.display("My Graph")5. Run Algorithms# Run DFS from node 0g.dfs_tree("0")# Run BFS from node 0g.bfs_tree("0")# Compute MST (requires a weighted undirected graph)g.mst_tree()# Run Dijkstra's algorithm from node 0 (requires a weighted graph)g.dijkstra_tree("0")# Topological sorting (requires a directed graph)g.topological_sort()# Find with path compression (requires disjoint-set)g.show_find("6")# Union (requires disjoint-set)g.show_union("9","11")Example Results
Package: algoauditor
Lethai LibraryThe library, named "lethai", provides a standard library to interact with the services provided by Lethical.ai.Getting StartedGenerate API KeySteps to followCreate an account on Lethical.aiClick on API Keys on the side panelClick "add key" buttonProvide tags to the key if needed (They will help you identify and filter the keys for your reference)Choose the access level for the keyClick on generateA key will be displayed on the screen please copy it and store it safely for future usage.NOTE: The key will only be shown once. This is for security purposesInstallationpip3 install lethaiUsageThe various features provided by our library include the following:Discrimination detection
-NLG models
Package: algobacktest
Algo Backtest PackageApplying significance test to backtestingGet historical data from Yahoo FinanceUse default technical analysis strategies for practiceApply significance test to backtest results with Monte Carlo simulationsQuick usageimport algobacktest.Backtest as algobt

bt = algobt.Test()
bt.prices = algobt.getprice('AAPL')
bt.positions = algobt.getsma(bt.prices)
bt.run()
bt.plot_significance()
print(f'Backtested strategy return: {round(bt.strategy_return,2)}')