Saravanan666/pypi-org huggingface dataset:
Package: quantuloop-simulator
Quantuloop Quantum Simulator Suite for HPCTheQuantuloop Quantum Simulator Suite for HPCis a collection of high-performance quantum computer simulators for theKet language. Since quantum algorithms explore distinct aspects of quantum computation to extract advantages, there is no silver bullet for the simulation of a quantum computer. The Quantuloop Quantum Simulator Suite for HPC offers three quantum simulators today, with new ones coming in the future. The simulators available today are:Quantuloop Sparse, which brings the Bitwise Representation (implemented in the KBW Sparse) for HPC. This is the only simulator that implements this simulation algorithm and it provides many benefits:Ready for multi-GPU systems, allowing you to scale up simulations as needed.Efficient execution time with the amount of superposition, providing faster simulations.Exact simulation of more than 100 qubitsdepending on the algorithm, making it ideal for larger simulations.Quantuloop Denseis a state vector simulator built with the NVIDIA cuQuantum SDK cuStateVec. It provides several advantages:Great scalability in multi-GPU systems, enabling large simulations to be run with ease.The perfect fit for most quantum algorithms, allowing you to simulate many different types of quantum circuits.By using the Quantuloop Quantum Simulator Suite for HPC, you can enjoy the following benefits:Faster simulation times, as the simulators are optimized for GPU-based computing.Higher scalability, as multi-GPU systems, can be used to run large simulations.Access to unique simulation algorithms, such as the Parallel Bitwise implemented in the Quantuloop Sparse simulator.Ability to simulate a wide range of quantum algorithms and circuits, allowing you to explore the potential of quantum computing.The use of this simulator is exclusively for Quantuloop's customers and partners. Contact your institution to get your access token or visithttps://quantuloop.com.InstallationInstalling using pip:pipinstall--index-urlhttps://gitlab.com/api/v4/projects/43029789/packages/pypi/simplequantuloop-simulatorAdd in poetry:poetrysourceaddquantuloophttps://gitlab.com/api/v4/projects/43029789/packages/pypi/simple--secondary
poetryaddquantuloop-simulatorUsageimportquantuloop_simulatorasqlimportketql.set_token(token="YOR.ACCESS.TOKEN",# Quantuloop Access Token is required to use the simulators)process=ket.Process(ql.get_simulator(num_qubits=182,simulator="sparse",# or "dense"precision=2,# optional, default 1gpu_count=4,# optional, default use all GPUs))CompatibilityThe following system requirements are necessary to run the Quantuloop Dense simulator:CUDA 12 or newer with compatible NVIDIA driverLinux x86_64 with glibc 2.18 or newerUbuntu 20.04 or newer.Red Hat Enterprise Linux 8 or newer.Python 3.8 or newerKet 0.7 or newerQuantuloop Dense is compatible only with CUDA architecture 70, 75, 80, and 86.By installing or using this package, you agree to the Quantuloop Quantum Simulator Suite EULA.All rights reserved (C) 2023 Quantuloop
Package: quantum6g
Quantum6G: Auto AI Advanced Quantum Neural Networks with 6G TechnologyQuantum6G is an automatic artificial intelligence library that combines quantum computing and 6G technologies to build advanced quantum neural networks. It provides a high-level interface for constructing, training, and evaluating quantum neural networks. This library was developed byQuantum PIYA.InstallationTo install the Quantum6G library, simply run the following command:pip install quantum6gGetting StartedHere is a simple example to get started with the Quantum6G library:from quantum6g import Quantum6GCreate a quantum neural networkquantum_6g = Quantum6G(output_unit=1, num_layers=4, epochs=2, loss='mse', input=4, batch_size=256, learning_rate=0.2)Build the modelquantum_6g = quantum_6g.build_model(X_train, y_train, X_test, y_test)Evaluate the modelprint("Accuracy: {:.2f}%".format(quantum_6g[1][1] * 100))
print("Loss: {:.2f}%".format(quantum_6g[1][0] * 100))Build and Fit Quantum6G_KNN --- from v1.2.5Vquantum_knn = Quantum6G_KNN(n_qubits=4, n_neighbors=6)
quantum_knn.fit(X_train, y_train)Evaluate the Quantum6G_KNN modelquantum_pred = quantum_knn.predict(X_test,y_test)
quantum_accuracy = accuracy_score(y_test, quantum_pred)
print(f"Accuracy of Quantum6G_KNN: {quantum_accuracy:.3f}")Build Quantum Model for QCNN (Quantum Convolutional Neural Network) --- from v1.3.0Vq_cnn = QCNN(
    input_shape=(2, 2, 1),
    output_neurons=10,
    loss_function="sparse_categorical_crossentropy",
    epochs=5,
    batch_size=32,
    optimizer="adam",
    n_layers=1,
    n_wires=4,
)
q_cnn_model = q_cnn.build_model()Evaluate the QCNN modelq_cnn.benchmark(q_cnn_model, x_train_resized[..., np.newaxis], y_train, x_test_resized[..., np.newaxis], y_test)DonateYou can donate for this project!ETH - ERC20: 0xa6F7170Ca63cf284A8ba6339b565445468E04Ff2BTC - Bech32: bc1qfek2lun4tc7d7zftz0v4auxc9dzn77h9xq9x26v02u6s3rgl7hesxt4r2hUSDT - TRC20: TWVcF24DjPnGfhegmJjBQw2iE4vxQBuYTYDocumentationFor more information on how to use the Quantum6G library, please refer to the documentation available at [the soon].ContributingWe welcome contributions to the Quantum6G library. If you would like to contribute, please fork the repository and make your changes, then submit a pull request.LicenseThe Quantum6G library is open source and released under the MIT license. For more information, please see theLICENSEfile.
Package: quantumania
A command line app for taking beautiful quantum notes.qlmgives you access to beautiful quantum notes on any machine.The name comes from the Arabic word for pen:قلمwhich makes use of the three letter rootq-l-mto cut, snip, prune, clip or truncate. So
try to keep those notes concise ;-)Basic Usagepip install quantumania
qlm connect 'username/repo'
echo '# My notes' > my_note.md
qlm add my_note.md
qlm show my_note.md$u42{8haO69Y7DRocF69dniotOAWEI06opV0D}
Package: quantum-blackbird
Blackbird is a quantum assembly language for continuous-variable quantum computation, that can be used to program Xanadu’s quantum photonics hardware and Strawberry Fields simulator.FeaturesThe Blackbird repository contains threeseparatepackages:src: The Blackbird grammar specification in enhanced Brackus-Naur formblackbird_python: to develop Blackbird parsers for integration with Python programsblackbird_cpp: libraries and header files needed to develop Blackbird
parsers for integration with C++ programsAll of these packages are independent, and can be installed separately without
depending on one-another.However, if the grammar is ever modified, there
is a command for updating the autogenerated parts of the Python and C++
parsers.In addition, this repository contains:example: Example Blackbird scriptsapps: Example Python/C++ applications using the above parsersGetting startedBlackbird is a development library, designed to easily integrate Blackbird code
into applications and interfaces.To get the Blackbird grammar installed and running on your system, begin at thegrammar installation guide. Then, familiarize yourself with the Blackbird’ssyntax and grammarfor specifying photonic quantum circuits. You can even generate Blackbird parsers for any target language supported
by ANTLR, including Java, C#, JavaScript, Go, and Swift.If you only want to develop an application that makes use of thePython parseror theC++ parser, you can go directly to those sections and their corresponding installation guides.How to citeIf you are doing research using Blackbird, please citeNathan Killoran, Josh Izaac, Nicolás Quesada, Ville Bergholm, Matthew Amy, and Christian Weedbrook.Strawberry Fields: A Software Platform for Photonic Quantum Computing2018.arXiv:1804.03159SupportSource Code:https://github.com/XanaduAI/BlackbirdIssue Tracker:https://github.com/XanaduAI/Blackbird/issuesIf you are having issues, please let us know by posting the issue on our Github issue tracker.LicenseBlackbird isfreeandopen source, released under the Apache License, Version 2.0.
Package: quantum-circuit-slicer
Quantum Circuit Slicer (QCS)This repo contains files to add a quantum circuit slicer to Qiksit. The slicer provides some useful functions for debugging quantum circuits.The circuit slicer includes:The addition of the "breakbarrier" object, which acts as a breakpoint for quantum circuits.Vslicer function to divide the circuit vertically.Hslicer to remove unused qubits in a particular slice.Gate tracking when you enter debugging mode by calling the startDebug function.Perform queries on a specific gate within a circuit.InstructionsInstallationTo use the circuit slicer, you need to have a working version of Qiskit (version 0.19.6 or higher)pip install quantum-circuit-slicerTestOnce the package is installed, try running the file test.py to make sure eveything is installed and working properly, and how to use the slicer.
Package: quantumcomputingsim
Quantum Computing SimulatorA python library to simulate quantum programs and circuits.Table of ContentsTable of ContentsGetting StartedPrerequisitesInstallingUsageAuthorsGetting StartedThese instructions will get you a copy of the project up and running on your local machine for development and testing purposes. Seedeploymentfor notes on how to deploy the project on a live system.PrerequisitesThis library is self contained, and optionally uses matplotlib for plotting graphs.InstallingThis library can be installed from pypi using pip:$ pip install quantumcomputingsimTo make sure everything installed properly, import the main and only module in python:from quantum import *UsageGo through example.ipynb for a comprehensive guide on using this librarySample workflow:entangler = qprogram(
    nqbits = 2,
    name = "Entangler"
)
entangler.addgates(0, [HGATE, CNOT0])
entangler.compile()Compiler result:Compiling Entangler...

Entangler
q0(0) ⮕  -----[ h ]--⌈ c0 c0 ⌉-------
q1(0) ⮕  ------------⌊ c0 c0 ⌋-------


Compilation of Entangler complete!and to run the program:entangler.run(graph = True)and view bloch spheres for qubits:plotbloch(HGATE * [0, 1])Authors@stealthypanda- Idea & Initial work
Package: quantumcore.storages
quantumcore.storagesis a collection of different storage mechanisms for various kinds
of data such as binary objects (files, images etc.), dictionary like documents and more.It will support backends like GridFS, S3, MongoDB and others.Change history0.009 - (2011/02/23)FileSystemStorage: added a copy() method. It takes a source filename and an
optional destination filename and copies a file0.008 - (2011/02/22)FileSystemStorage: sizeof() now returns bytes instead of KBFileSystemStorage: implemented get() as alias for __getitem__()0.007 - (????)initial releaseDownload
Package: quantumdata-sdk
Quantumdata sdkauth tokenwrite to me on rafalniewinski95@gmail.com 
if you want get access to our databasesimple usage:get companies:

    api = QuantumDataApi(API_TOKEN)
    response = api.get_companies()


get quotations:

    api = QuantumDataApi(API_TOKEN)
    response = api.get_quotations("KGHM")


get reports:

    api = QuantumDataApi(API_TOKEN)
    response = api.get_reports("KGHM")
Package: quantum-dataset
Quantum DatasetA collection of measurements on quantum devices.The data for the QuantumDataset is attached to the github release namedTest, seehttps://github.com/QuTech-Delft/quantum_dataset/releases/tag/TestExample usagefrom quantumdataset import QuantumDataset
quantum_dataset=QuantumDataset(data_directory=None)
quantum_dataset.list_tags()

dataset = quantum_dataset.load_dataset('allxy', 0)
quantum_dataset.plot_dataset(dataset)

quantum_dataset.generate_overview_page(quantum_dataset.data_directory / 'overview')
Package: quantum-decomp
Tool for decomposing unitary matrix into quantum gatesThis is a Python tool which takes a unitary matrix and returns
a quantum circuit implementing it as Q# code, Cirq circuit, or Qiskit circuit.Installingpip install quantum-decompExample>>>importnumpy,quantum_decomp>>>SWAP=numpy.array([[1,0,0,0],[0,0,1,0],[0,1,0,0],[0,0,0,1]])>>>print(quantum_decomp.matrix_to_qsharp(SWAP,op_name='Swap'))operationSwap(qs:Qubit[]):Unit{CNOT(qs[1],qs[0]);CNOT(qs[0],qs[1]);CNOT(qs[1],qs[0]);}>>>print(quantum_decomp.matrix_to_cirq_circuit(SWAP))0:───@───X───@───│││1:───X───@───X───>>>print(quantum_decomp.matrix_to_qiskit_circuit(SWAP))┌───┐┌───┐q_0:┤X├──■──┤X├└─┬─┘┌─┴─┐└─┬─┘q_1:──■──┤X├──■──└───┘Seeexample.ipynbfor more examples and instructions how to
use this tool.ReferencesThis tool was inspired byMicrosoft Q# Coding Contestand was implemented as part of online course "Applications of Quantum Mechanics" at MIT.See thispaperfor detailed description
of the algorithm and further references to papers with algorithms.Blog postabout the tool.
Package: quantumdiceware
Generate truly random diceware passphrases.FeaturesSimulates dice rolls by gathering quantum data.Includes the complete standard Diceware wordlist.Generate passphrases from custom wordlists.Python 3.6 is required.UsageInstall$ pip install quantumdicewareGenerate a Passphrase$ qdgGenerate five Passphrases and save them to output.txt$ qdg -c 5 > output.txtGenerate two Passphrases that are eight words long$ qdg -c 2 -w 8DocumentationFor more in-line help, run:$ qdg -hQDG’s documentation lives atqdg.readthedocs.ioSeeThe Diceware Passphrase Home Pageto learn more about Diceware.MetaJustin M. Sloan -justinsloan.comPublic Domain. SeeLICENSE.txtfor more information.https://github.com/justinsloan/qdg
Package: quantum-distance-based-classifier
The Quantum Distance-based classifier is a technique inspired by the classical k-Nearest Neighbors that leverage quantum properties to perform prediction. The package has been implemented in Qiskit.```
    from quantum_distance_based_classifier.quantum_distance_based_classifier import QuantumDistaceBasedClassifier
    from sklearn import preprocessing
    from sklearn.datasets import load_iris
    from sklearn.preprocessing import StandardScaler
    import numpy as np


    X, y = load_iris(return_X_y=True)

    n_features = 2
    X = X[:, :n_features] # Keep only n_features

    # Standardize and normalize the features
    X = StandardScaler().fit_transform(X)
    X = preprocessing.normalize(X, axis=1)

    # Initialize variables to store sampled instances
    sampled_X = []
    sampled_y = []

    # Loop through each class to sample instances
    for class_label in np.unique(y):
        class_indices = np.where(y == class_label)[0]
        sampled_indices = np.random.choice(class_indices, size=instances_per_class, replace=False)
        sampled_X.extend(X[sampled_indices])
        sampled_y.extend(y[sampled_indices])

    # Convert lists to numpy arrays
    sampled_X = np.array(sampled_X)
    sampled_y = np.array(sampled_y)

    qdbc = QuantumDistaceBasedClassifier()
    qdbc.fit(sampled_X, sampled_y)
    result = qdbc.predict(sampled_X[0])
    print(f"Classification result: {result}")
    ```
Package: quantum-dynamics
Thequantum_dynamicspackage contains tools for simulation of 1D
time-dependent Schrödinger equation. The package allows for simulation of 1D
model potentials and time-dependent external interactions, e.g., an laser
electric field in the dipole approximation.This package has been created as a reference solution to an exercise in the
computational physics course at Tampere University of Technology in Spring
2018.The key numerical methods behind the package are:finite-difference approximation of the laplacian operator with Dirichlet
boundary conditions at the endpoints of the simulation gridexponential mid-point rule for the time-evolution operatorkrylov-subspace based implementation of the matrix exponentialUpon successful installation, two executables are copied to your PATH:qdyn_laserplot_time_evolutionqdyn_laserThis simulates the electron in 1D soft coulomb potential (“1D hydrogen”) under
laser electric field with sin^2 envelope and cosine carrier wave. Please
consult the help of the script for all options:qdyn_laser--help.After a successful simulation, an outputfile of HDF5-format is created. It
contains the following datasets and groupscoordinate_gridThe gridpoints of the coordinate space used in the calculation.savetimesThe times corresponding to the saved wavefunction values in the file.wavefunctionA 2D array of values of the wavefunction. The first index corresponds tocoordinate_gridand the second index tosavetimes.final_wavefunctionWavefunction values at the end of the simulation.laserThe laser electric field foralltimesteps. First column is times, second
the laser electric field values.tise_hamiltonianThe time-independent part of the Hamiltonian matrix. It’s saved as a sparse
matrix and can be loaded withquantum_dynamics.utils.load_sparse_matrixlike:from quantum_dynamics.utils import load_sparse matrix
import h5py

with h5py.File("myfile.h5", "r") as f:
    H0 = load_sparse_matrix(f['tise_hamiltonian'])plot_time_evolutionThis can be used to visualize the time-evolved density calcualted withqdyn_laser. For usage instructions, please seeplot_time_evolution--help.AuthorsJanne Solanpää
Package: quantumflow
QuantumFlow: A Quantum Algorithms Development ToolkitA cross-compiler for gate based models of quantum computingTutorialSource CodeIssue TrackerAPI DocumentationInstallationTo install the latest stable release:$ pip install quantumflowIn addition, install all of the external quantum libraries that QuantumFlow can interact with (such as cirq, qiskit, braket, ect.):$ pip install quantumflow[ext]To install the latest code from github ready for development:$ git clone https://github.com/gecrooks/quantumflow.git
$ cd quantumflow
$ pip install -e .[dev]
Package: quantum-gateway
Query a Quantum GatewayThis library allows a Verizon FiOS Quantum Gateway to be queried. It uses therequestslibrary to authenticate, log in, and query the web interface of the gateway.UsagePlease note for G1100 devices: as of the Firmware version 02.02.00.13 and UI version v1.0.388 https is the only way to get to the admin console. This is using a self signed cert as well. The code now defaults to https and ignores the self signed cert warning.# Importfromquantum_gatewayimportQuantumGatewayScanner# Connect to gateway via HTTPSgateway=QuantumGatewayScanner('192.168.1.1','your_password_here')# Or, connect to gateway via HTTPgateway=QuantumGatewayScanner('192.168.1.1','your_password_here',False)# Property is set to True if we successfully logged in, otherwise Falsegateway.success_init# Get list of all connected devices' MAC addressesgateway.scan_devices()# Get specific device's namegateway.get_device_name('mac address of device here')NotesTested on Verizon FiOS-provided gateway:UI Version:v1.0.388UnknownUnknownFirmware Version:02.02.00.133.1.0.123.1.1.17Model Name:FiOS-G1100FiOS-G3100FiOS-G3100Hardware Version:1.0311041104Please open a Githubissueor reply to the Home Assistant forumpostif you encounter any problems. Thanks!
Package: quantumgrid
AboutExterior Complex Scaled Finite-Element Element Discrete Variable
Representation grid for general physics problems. In other words,
quantumGrid is a package for solving a 1-D Schrödinger equation
for an arbitrary potential.MotivationThis python package was created for a graduate course in time-dependent
quantum mechanics at UC Davis. Given the ease of programming in python,
generality and usefulness of a Finite Element Method - Discrete
Variable Representation (FEM-DVR) grid for solving the Schrödinger
equation and simple scattering problems, we wanted to go open source
and provide this numerical tool for others in the name of science!DocumentationFor a more details in using quantumGrid, checkout our manual here:https://quantumgrid.readthedocs.io.History0.0.1 (2020-05-31)First release on PyPI.
Package: quantumics
QuantumicsQuantumics is a python library that remove the risk post by the Neven's Law, recent and future developments in Computer Science and Technology by abstracting away the effect of the diversity of QPUs, CPUs manufacturers.Quantumics code(written mainly in python) enables you to run your code on different processors and then pick the most efficient processors to use for different algorithms in your code. Thus, optimizing computational speed of the global process. One code format works for all types of processors and future processors that may develop in the field of classical computing and quantum computing.You can learn more about Quantumics on our website in the link belowhttps://www.quantumics.netWhy you or your organization need this APIProcessing Unit Agnostic(QPU/CPU)Manufacturer Agnostic(DWave/IBM/Microsoft)Lowers Organization Risks due to Processing Unit's DisruptionWho needs this APIQuantum ScientistsMachine Learning EngineersNanotechnologists and BionanotechnologistsDevelopers Interested in taking developing on processing unit agnostic Quantum and Classical applicationsOrganisations with need for fast big data processing unitExamplesApplications of this APIOptimizations ProblemsMachine Learning ProblemsQuantum Computing Business SolutionsNanotechnology and Bionanotechnology SolutionsSynthetic Biology and PharmaceuticalsQuantum Finance Solutions
Package: quantum-image-classifier
Quantum image classifierData useYou can generate synthetic data by calling the functiongenerate_synthetic_data(n_dim: int, n_clusters: int, m_samples: int)implemented indata_generator.py. You have to be aware that, in order to Nearest Centroid to work,n_dimhas to be power of 2.
This function returns a set of m_samples vectors X with a set of labels y associated with the vector in the same possition on X. Example:X, y = generate_synthetic_data(8, 4, 250)
train_X = X[:200]
train_y = y[:200]
test_X = X[200:]
test_y = y[200:]If you want, you can also use the MNIST dataset with a PCA function used to reduce the dimension to n components callingget_MNIST(n_components)implemented indata_loader.py. Same as with the synthetic data, you have to be aware to use only an power of 2 to make Nearest Centroid work. Example:train_X, train_y, test_X, test_y = get_MNIST(8)ClassifiersNearest centroidOnce you get the data, you need to create the object NearestCentroid with the training dataset that you want. After that, you can call the functionpredict(self, X: np.ndarray)owned by the defined object. Example:train_X, train_y, test_X, test_y = get_MNIST(8)
nearest_centroid = NearestCentroid(train_X, train_y, n_dim)
labels_predicted = nearest_centroid.predict(test_X)
Package: quantum-inferno
quantum-infernoQuantized Information Entropy, Nth OctaveCaveat Emptor: Early Release Dev VersionDescriptionComputes standardized time-frequency representations (TFRs) for power, information, and entropy,
built on the Gabor wavelets with minimal time-frequency uncertainty with
logarithmic constant-Q base 2 (binary) scales and frequency bands of quantized order N.All algorithms are based on FFTs for computational efficiency.
The short-term Fourier transform (STFT) is included as the baseline TFR.
Algorithms for the Continuous Wavelet Transform (CWT), Discrete Wavelet Transform (DWT),
and Stockwell Transform (STX) are provided.Refer to the open access publications:Garcés, M.A. Quantized Information in Spectral Cyberspace. Entropy 2023, 25, 419Garcés, M.A. Quantized Constant-Q Gabor Atoms for
Sparse Binary Representations of Cyber-Physical Signatures. Entropy 2020, 22, 936Garcés, M.A. On Infrasound Standards, Part 1 Time, Frequency, and Energy Scaling.
Inframatics 2013, 2, 13-35Recommended background reading in chronological order:Gabor, D. Theory of Communication, Part 3. Electr. Eng. 1946, 93, 445–457.Shannon, C.E. The Mathematical Theory of Communication; University of Illinois Press: Urbana, IL, USA, 1998; [1949 first ed].Harris, F. J. On the Use of Windows for Harmonic Analysis with the Discrete Fourier Transform, Proceedings of the IEEE, 1978, 66 (1), 51-83.Cohen, L. Time-Frequency Analysis, Prentice-Hall, NI 07458, 1995.Stockwell, R. G., Mansina, L, and R. P. Lowe. Localization of the Complex Spectrum: The S Transform. Signal Processing, IEEE Transactions, 1996, 44 no. 4, 998-1001.Mallat, S. A Wavelet Tour of Signal Processing: The Sparse Way, 3rd ed.; Academic Press: Cambridge, MA, USA, 2009 [1998 first ed].Installationpipinstallquantum-infernoMore details will be placed in theInstallation guide.ExamplesFull examples can be found in theexamples documentation.API DocumentationCheck theAPI Documentation.ResourcesFound an issue? Submit abug report.MIT License