Saravanan666/pypi-org huggingface dataset:
Package: physapp
Librairie Python pour la physique appliquéeInstallationDans un terminal :pip install physappMise à jour :pipinstall--upgradephysappDépendancesCette librairie se base principalement sur les librairiesnumpy (>= 1.26.0),matplotlib (>= 3.8.0)etscipy (>= 1.11.0).Modulephysapp.base> Fonctions disponiblesderive(y, x)integrale(y, x, xinf, xsup)spectre_amplitude(y, t, T)spectre_RMS(y, t, T)spectre_RMS_dBV(y, t, T)> Exempleimportnumpyasnpimportmatplotlib.pyplotaspltfromphysappimportintegrale### IMPORTATION DES DONNEES ###t,u=np.loadtxt('scope.csv',delimiter=',',skiprows=2,unpack=True)### CALCULS ###f=125T=1/faire=integrale(u,t,0,T,plot_ax=plt)moy=aire/T### COURBES ###plt.plot(t,u)plt.axhline(moy,ls="--",color="C3")plt.text(0.65*T,moy+0.2,"Moy ={:.2f}V".format(moy),color="C3")plt.title("Valeur moyenne d'un signal périodique")plt.xlabel("t (s)")plt.ylabel("u (V)")plt.grid()plt.show()Modulephysapp.modelisationFonctions pour réaliser une modélisation d'une courbe expérimentale.> Fonctions classiquesFonctionDescriptionajustement_lineaire(x, y)$y=a\cdot x$ajustement_affine(x, y)$y=a\cdot x+b$ajustement_parabolique(x, y)$y=a\cdot x^2+b\cdot x+c$ajustement_exponentielle_croissante(x, y)$y=A\cdot(1-e^{-x/\tau})$ajustement_exponentielle_decroissante(x, y)$y = A\cdot e^{-x/\tau}$ajustement_exponentielle2_croissante(x, y)$y = A\cdot(1-e^{-kx})$ajustement_exponentielle2_decroissante(x, y)$y = A\cdot e^{-kx}$ajustement_puissance(x, y)$y=A\cdot x^n$> Réponses fréquentiellesajustement_ordre1_passe_bas_transmittance(f, T)ajustement_ordre1_passe_bas_gain(f, G)ajustement_ordre1_passe_bas_dephasage(f, phi)ajustement_ordre1_passe_haut_transmittanc(f, T)ajustement_ordre1_passe_haut_gain(f, G)ajustement_ordre1_passe_haut_dephasage(f, phi)ajustement_ordre2_passe_bas_transmittance(f, T)ajustement_ordre2_passe_haut_transmittance(f, T)ajustement_ordre2_passe_haut_dephasage(f, phi)ajustement_ordre2_passe_bande_transmittance(f, T)ajustement_ordre2_passe_bande_gain(f, G)ajustement_ordre2_passe_bande_dephasage(f, phi)> Exempleimportmatplotlib.pyplotaspltfromphysapp.modelisationimportajustement_paraboliquex=[0.003,0.141,0.275,0.410,0.554,0.686,0.820,0.958,1.089,1.227,1.359,1.490,1.599,1.705,1.801]y=[0.746,0.990,1.175,1.336,1.432,1.505,1.528,1.505,1.454,1.355,1.207,1.018,0.797,0.544,0.266]modele=ajustement_parabolique(x,y)print(modele)plt.plot(x,y,'+',label="Mesures")modele.plot()# Trace la courbe du modèle#modele.legend()                     # Affiche la légende du modèleplt.legend()plt.title("Trajectoire d'un ballon")plt.xlabel("x (m)")plt.ylabel("y (m)")plt.grid()plt.show()Résultat :Fonctionparaboliquey=a*x^2+b*x+ca=(-1.25±0.060)b=(2.04±0.11)c=(0.717±0.045)Intervalledeconfianceà95%sansincertitudessurxety.Modulephysapp.csvModule d'importation de tableau de données au format CSV à partir des logiciels Aviméca3, Regavi, ...> Fonctions disponiblesload_txt(fileName)load_avimeca3_txt(fileName)load_regavi_txt(fileName)load_regressi_txt(fileName)load_regressi_csv(fileName)load_oscillo_csv(filename)load_ltspice_csv(filename)save_txt(data, fileName)
Package: phys-benchmark
Only works on PHYS cluster & tests up to 4 nodes!Need the topology file in the directory where you execute the script. Benchmark results will be printed under filename Benchmark_Perfomance.png in the same directory where script was executed. Check progress by executing squeue -n bingo in terminal (when no jobs are running, results should be available)NEED TO LOAD ANACONDA/3/2020.2 ON PHYS CLUSTER PRIOR TO USING LIBNeed to login to cluster with ssh-o ServerAliveInterval=300 login@mpi because when terminal disconnects from cluster, process stops (wip).Execute the following:module load anaconda/3/2020.02python3from phys_benchmark import num_nodesnum_nodes( < # of nodes you want to test -- 4 nodes max > )exit()
Package: physbo
optimization tools for PHYsics based on Bayesian Optimization ( PHYSBO )Bayesian optimization has been proven as an effective tool in accelerating scientific discovery.
A standard implementation (e.g., scikit-learn), however, can accommodate only small training data.
PHYSBO is highly scalable due to an efficient protocol that employs Thompson sampling, random feature maps, one-rank Cholesky update and automatic hyperparameter tuning. Technical features are described inCOMBO's documentandPHYSBO's report(open access).
PHYSBO was developed based onCOMBOfor academic use.DocumentStable (master branch)English日本語Latest (develop branch)English日本語Required PackagesPython >= 3.6No longer tested with Python 3.6NumPySciPyInstallFrom PyPI (recommended)pip3installphysboFrom source (for developers)Update pip (>= 19.0)pip3install-UpipDownload or clone the github repositorygit clone https://github.com/issp-center-dev/PHYSBOInstall via pip# ./PHYSBO is the root directory of PHYSBO# pip install options such as --user are avaiablepip3install./PHYSBONote: Do notimport physboat the root directory of the repository becauseimport physbodoes not try to import the installed PHYSBO but one in the repository, which includes Cython codes not compiled.Uninstallpip3uninstallphysboUsage'examples/simple.py'is a simple example.LicensePHYSBO was developed based onCOMBOfor academic use.
This package is distributed under GNU General Public License version 3 (GPL v3) or later.
We hope that you cite the following reference when you publish the results using PHYSBO:“Bayesian optimization package: PHYSBO”, Yuichi Motoyama, Ryo Tamura, Kazuyoshi Yoshimi, Kei Terayama, Tsuyoshi Ueno, Koji Tsuda, Computer Physics Communications Volume 278, September 2022, 108405.Bibtex@misc{@article{MOTOYAMA2022108405,
title = {Bayesian optimization package: PHYSBO},
journal = {Computer Physics Communications},
volume = {278},
pages = {108405},
year = {2022},
issn = {0010-4655},
doi = {https://doi.org/10.1016/j.cpc.2022.108405},
author = {Yuichi Motoyama and Ryo Tamura and Kazuyoshi Yoshimi and Kei Terayama and Tsuyoshi Ueno and Koji Tsuda},
keywords = {Bayesian optimization, Multi-objective optimization, Materials screening, Effective model estimation}
}Copyright©2020- The University of Tokyo. All rights reserved.This software was developed with the support of "Project for advancement of software usability in materials science" of The Institute for Solid State Physics, The University of Tokyo.
Package: phys-const
This module provides physical constants in uniform format.[C], electron charge.q_e = 1.60217662e-19[J * s], Planks constant.h = 6.62e-34[m / s], speed of light.c = 299792458[kg], electron mass.m_e = 9.10938356e-31[m], electron radiusr_o = 2.8179403267e-15[K], room temperaturet_room = 273 + 23[J / K], Boltzmann constantk_b = 1.38064852e-23[F / m] = [A2 * s4 / (kg * m3)], permittivity of free spaceeps_0: float = 8.85418781e-12[eV / J] energy converterJoule_to_eV: float = 6.241509e18Converts pressure from [Torr] to [Pa]def torr_to_pa(torr):
return torr * 7.5006 * 1e-3Converts temperature from [deg C] to [deg K]def cels_to_kelv(cels: float) -> float:
return cels + 273.15floating point infinityinf = float('inf')linear interpolationdef interpolate(x_prev: float, x_tgt: float, x_next: float, y_prev: float, y_next: float) -> float:
    return y_prev + (y_next - y_prev) * (x_tgt - x_prev) / (x_next - x_prev)linear interpolation in arraydef interpolate_arr(x_arr: list[float], y_arr: list[float], x: float) -> float:
...radians to degrees converterdef rad_to_deg(deg: float) -> float:
    return deg * 180 / math.pidegrees to radians converterdef deg_to_rad(deg: float) -> float:
    return deg * math.pi / 180angle between two vectors. Result from 0 to 2Pi.def vector_angle(first_x: float, first_y: float, second_x: float, second_y: float) -> float:
    angle = math.atan2(second_y - first_y, second_x - first_x)
    if angle < 0:
        angle += math.tau
    return angleintegrate array by trapzdef integrate(x_arr: list[float], y_arr: list[float]) -> float:
...
Package: physconsts
PhysConstsA Python package that provides physical constants.  The code is being developed byMarc van der
Sluysof the department of Astrophysics at the Radboud University Nijmegen, the
Institute of Nuclear and High-Energy Physics (Nikhef), and the Institute for Gravitational and Subatomic
Physics (GRASP) at Utrecht University, all in The Netherlands.  The PhysConsts package can be used under the
conditions of theEUPL 1.2licence.InstallationThis package can be installed usingpip install physconsts.  This should automatically install the
dependency packages ``, if they haven't been installed already.  If you are
installing by hand, ensure that these packages are installed as well.Example use"""Example Python script using the PhysConsts package."""importphysconstsPhysConsts pagesPypi: PhysConsts Python packageGitHub: PhysConsts source codeReadTheDocs: PhysConsts documentationAuthor and licenceAuthor: Marc van der SluysContact:http://marc.vandersluys.nlLicence:EUPL 1.2References
Package: physdata
physdata========physdata is a python package to interface some online sources of physical data. It currently supports:- the `X-Ray Mass Attenuation Coefficients <https://www.nist.gov/pml/x-ray-mass-attenuation-coefficients>`_ NIST data- the `Stopping-Power & Range Tables for Electrons, Protons, and Helium Ions<https://www.nist.gov/pml/stopping-power-range-tables-electrons-protons-and-helium-ions>`_.For more information check the `GitHub repository <https://github.com/Dih5/physdata>`_.
Package: physDBD
Physics-based dynamic PCA for modeling stochastic reaction networks with TensorFlowThis is the source repo. for thephysDBDPython package. It allows the creation of physics-based machine learning models inTensorFlowfor modeling stochastic reaction networks.QuickstartInstall:pip install physDBDSee theexample notebook in the GitHub repo..Read thedocumentation.Further informationSee the project'sGitHub page.
Package: physical2logical
physical2logicalConvert CSS physical properties to logical.Converts margins, padding, and borders to logical values, allowing RTL and vertical languages to show correctly.Installpip install physical2logicalUsageusage: css2logical [-h] [-r | --recursive | --no-recursive] [-u | --update | --no-update] [-a | --analyze | --no-analyze] [-f FILENAME]  [-l LOG] [-p PATTERN] source

Convert CSS physical properties to logical

positional arguments:
  source                Path to source directory or one file. Required

optional arguments:
  -h, --help            show this help message and exit
  -r, --recursive, --no-recursive
                        Recursive process of all files from source directory. (default: True)
  -u, --update, --no-update
                        Update files. (default: False)
  -a, --analyze, --no-analyze
                        Dry Run - Create a report with all changes (without actual source file changes). (default: False)
  -f FILENAME, --filename FILENAME
                        Path to file where to save reports (used only with -a | --analyze flag). (default: "./report.html")
  -l LOG, --log LOG     Log Level: All: 0, Debug: 10, Info: 20, Warning: 30, Error: 40 (default: 0)
  -p PATTERN, --pattern PATTERN
                        Comma separated list of glob patterns (default: '*.scss, *.css')Based onhttps://gist.github.com/nyurik/d438cb56a9059a0660ce4176ef94576fReportExamplecss2logical -u ./src/scss/
Package: physical-const
Physical constants for PythonUSAGEconstant.name = name of the constant.symbol = symbol of the constant (some of them don't show up properly).value = constant value.unit = unit of the constantCONSTANTS- speed_of_light- permeability_of_free_space- permittivity_of_free_space- electron_charge- Planck_const- grav_const- Avogadro_const- mol_gas_const- Boltzmann_const- Stefan_const- Wien_const- electron_mass- electron_charge_mass- proton_mass- proton_charge_mass- neutron_mass- gravitational_field_strength- acceleration_due_to_gravity- atomic_massThe constant were sourced from:AQA "A Level Physics Data and Formulae"
Package: physical-device-manager
Copyright © 2016-2018SoftFIREandTU Berlin. Licensed underApache v2 License.Physical Device ManagerThe SoftFIRE Physical Device Manager provides reservation of physical
resources. For the third wave, experimenters may reserve UE(s) at the
Surrey test bed, and remotely control them using TeamViewer. The figure
below depicts the physical resource reservation process.For more information on how to use the physical resources visit thedocumentation.Technical RequirementsThe Physical Device Manager requires Python 3.5 or higher.Installation and configurationYou can install the Physical Device Manager using pip:pip install physical-device-managerand then start it with thephysical-device-managercommand.Or you can run it from source code by cloning the git repository,
installing the dependencies as specified in thesetup.pyfile and
executing thephysical-device-managerscript.The Physical Device Manager needs a configuration file present at/etc/softfire/physical-device-manager.ini. An example of the
configuration file can be foundhere.Issue trackerIssues and bug reports should be posted to the GitHub Issue Tracker of
this project.What is SoftFIRE?SoftFIRE provides a set of technologies for building a federated
experimental platform aimed at the construction and experimentation of
services and functionalities built on top of NFV and SDN technologies.
The platform is a loose federation of already existing testbed owned and
operated by distinct organizations for purposes of research and
development.SoftFIRE has three main objectives: supporting interoperability,
programming and security of the federated testbed. Supporting the
programmability of the platform is then a major goal and it is the focus
of the SoftFIRE’s Second Open Call.Licensing and distributionCopyright © [2016-2018] SoftFIRE projectLicensed under the Apache License, Version 2.0 (the “License”);you may not use this file except in compliance with the License. You may
obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an “AS IS” BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: physical_dualism
AboutPython library that approximates the natural frequency from stress via physical
dualism, and vice versa.This work is a part of the investigation within the research project[ON174027], supported by the Ministry for Science and Technology, Republic of
Serbia. This support is gratefully acknowledged.References[ON174027]“Computational Mechanics in Structural Engineering”InstallationTo install physical_dualism run:$ pip install physical_dualismUsage examplesQuick start:>>> from physical_dualism import approximate_natural_frequency_from_stress

>>> mode = 1
>>> a = 2310.0 # [mm] strip length
>>> sigma_cr = 19.4754 # [MPa] critical buckling stress
>>> ro = 10000.0 / 10**9 # [kg/mm**3] mass density

# Mass matrix expects mass density normalized to 1 [m] of length, even if everything is done in [mm]
>>> ro /= 10**3

# [rad/s] natural frequency approximated from critical buckling stress
>>> print "%.4f" % approximate_natural_frequency_from_stress(mode, a, sigma_cr, ro)
60.0179Please see thefsm_eigenvaluesource code for more examples.ContributeIf you find any bugs, or wish to propose new featuresplease let us know.If you’d like to contribute, simply forkthe repository, commit your changes
and send a pull request. Make sure you add yourself toAUTHORS.
Package: physical-propagation
Physical PropagationFor simplistic geometric acoustics we can use the information regarding the atmosphere and ground to determine nominal
acoustic losses that a spherical wave would experience as the signal moves through the atmosphere. This code originated
in the calculation of equivalent sources that were created as part of the Acoustic Repropagation TechniqueARTthat
was developed as part of the Rotorcraft Noise Model. The same de-propagation methods were employed by the Swiss Federal
Laboratories when they created a series of sources usingspherical harmonics.The author of this package took these elements, originating with a variety of ANSI standards and Acoustical Society of
America papers, and created a series of C++, Matlab, and C# codes to determine the nominal losses. These culminated in
the author'sdissertationregarding the de-propagation of measurements on a UH-1J (Huey).This package contains acoustic losses for:Spherical spreading (divergence) of spherical wavesAtmospheric absorptionGround reflectionAn additional code is available to trace theacoustic raythrough a media defined by a series of horizontal and vertical
temperature & wind speed gradients.This code is part of a series of packages that were developed from the C# codes for the purpose of providing a code
base for continued creation of acoustic propagation and perception.This code requiresPythonCoordinates, a package with measurable objects to assist in the calculation of the physical
losses and the location within the world and relative coordinates of the various objects.Physical Acoustic Propagation2023AprilInitial creation of the package and establishment of the repository on ELSZ.JulyBegan the process of updating the package to be converted to a public repository. Public Affairs clearance will be required prior to posting.Received public affairs clearance to put this code on Pypi.orgMIT LicenseCopyright (c) 2021 Frank Mobley, Gregory BowersPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.This software was cleared for public release with case number AFRL-2023-3282 on
10 July 2023. This clearance is value until 10 July 2026.
Package: physicalquantity
A simple library for working with physical quantities.Implements basic dimensional decomposition of physical quantities and provides
basic operations (adition, subtraction, multiplication, division, comparison)
for working with these quantities.Support for non-SI units is available but most operations will result in
implicit conversions to SI units. Use the as_absolute() or as_relative()
methods to convert back to the desired non-SI units.Note that while this library supports a wide range of the dimentional analysis
and related integrity artifacts of working with physical quantities, the prime
goal of this library isn’t the dimentional integrity of code, but instead the
unified serialization or rather serializisability of physical quantities.
Package: physical-sources
physical_sourcesThis is a collection of classes meant to provide access to acoustic source levels that were contained within the initial
release of the Counter Listener Acoustic Warfare Software (CLAWS). But with the changes to the releasibility of the code
and data from CLAWS, a number of classes were removed from the distribution.2023MayCreation of the packageAdded functions for the plotting of the surfaceMoved functions for calculating the harmonic series expansion from separate classes to functions in the harmonic series representationJuneUpdated the class for reading the EEG data to obtain a Waveform object from the selected channel within the listingRefactored the HarmonicSeries class to inherit from the ISphereSource interface.JulyRemoved the EEG structure from the physical sources as many of the information that we are interested in exploring exists within MNE.Increased versionRestructured the package to facilitate better inheritance and class structure, and increased the versioning. This included moving the data from the tests and the sources to new folder structure that assists with the definition of specific types of source definitions.Significant updates to the restructuring of the codeadded a UML diagram for the package to the README.md file
Package: physical-validation
physical_validation: A Python package to assess the physical validity of molecular simulation resultsphysical_validationis a package testing results obtained by molecular simulations for their physical validity.Please citeMerz PT, Shirts MR (2018) Testing for physical validity in molecular simulations. PLoS ONE 13(9): e0202764.https://doi.org/10.1371/journal.pone.0202764Merz et al., (2022). physical_validation: A Python package to assess the physical validity of molecular simulation results. Journal of Open Source Software, 7(69), 3981,https://doi.org/10.21105/joss.03981physical_validationincorporates the functionality ofcheckensemble.This software is developed in the Shirts group at University of Colorado in Boulder.DocumentationPlease checkhttps://physical-validation.readthedocs.iofor the full reference.
Package: physicl
PhysiCL is a Python module for writing physics simulations that utilize OpenCL to accelerate calculations. It includes:A Numpy-based code units systemA set of generic tools for writing simulations using pre-existing features, as well as writing your own featuresA collection of tools for writing simulations involving photons and scattering.There are a number of Jupyter notebooks in the examples folder that highlight the usage of PhysiCL. PhysiCL is best suited for scenarios where it can be parallelized, namely those involving few interactions between different objects.ContributingThere are a number of ways you can contribute. Current tasks include:Improving the quality and coverage of the documentation.Improving the testing coverage.Fixing bugs.Adding new features.
Package: physics
Welcome to physics!physicsis a simpleEducational librarywritten inPython.
It could be used for yourschool projects.Have you ever tried to define a number using errors? Calculating gravity?
Get a proportionality relation? Now, that’s possible andsimple.ContentsInstallationInstallation from pypi(usingpip) - Latest stable
versionFrom GithubUsing pipDownloading filesDocumentationFilesHow to contributeInstallationFrom PyPiJust usepip:pip install physicsOr if you want toupgradethe package:pip install --upgrade physicsFrom GithubUsing PipTry using that piece of code:pip install git+https://github.com/pyTeens/physics.gitOr if you want toupgradethe packagepip install --upgrade git+https://github.com/pyTeens/physics.gitDownloading filesIn primis(from Latin, “firstable”),clonethe repository:git clone https://github.com/pyTeens/physics.gitThen, change directory:cd physicsAnd finally, install thepackage:sudo python3 setup.py installFilesYou’ll find lots ofnot understandabledirectoryandfiles, so
here a list and definitions of them:physics-Main directoryphysics/__init__.py-Init file, it included all
classesphysics/errors.py-Errors classphysics/gravity.py-Gravity classphysics/numbers.py-Numbers classphysics/proportionality.py-Proportionality classHow to contributeIn primis(“firstable”), youmustread thecode of conductsand
thecontributing document, then askhearotto enter theorganization(pyTeens).Copyright(c) 2018pyTeens. All rights
reserved.
Package: physicscalc
physicscalcThis package consists of all different formulae used in physics for solving problems ,researching ,so on and so forthDevelopment Status:Under Development (Early release)Developed by:Vishal Balaji SivaramanInstallation:Use the package managerpipto install physicscalc.pipinstallphysicscalcTo import physicscalc:importphysicscalcLicense:MIT