semvec/pypi-packages huggingface dataset:
sphinx-demo 0.0.1
A lightweight example directive to make it easy to demonstrate code / results.
Requires Python: >=3.7
Keywords: documentation,sphinx

# sphinx-demo

A small Sphinx extension to create examples of source markup and the result of rendering it in your documentation.
This is useful if you wish to demonstrate the functionality of a new directive or role in Sphinx.

🚨**This is very alpha software**🚨: It is packaged primarily for convience and not heavily tested. Use at your own risk!

## Installation

You can install `sphinx-demo` with `pip`:

```bash
pip install sphinx-demo
```

## Usage

See [the `sphinx-demo` documentation](https://ebp-sphinx-demo.readthedocs.io/en/latest/) for more information.

## Develop

To develop this extension, follow these steps:

1. **Clone the repository locally**

   ```console
   $ git clone https://github.com/executablebooks/sphinx-demo
   $ cd sphinx-demo
   ```
2. **Install pre-commit hooks**

   ```console
   $ pre-commit install
   ```
3. **Install development and documentation dependencies**

   ```console
   $ pip install -e .[sphinx]
   ```

The codebase for this package is in `src/sphinx_demo`.
Documentation is in `docs/`.

This package has no testing infrastructure, so be careful when using it!
If it becomes more complex or with more features, we may add more testing around it in the future.
For not it is packaged for convenience and re-use across EBP repositories.

## Build the documentation

The documentation is currently not hosted anywhere, so if you'd like to preview the documentation "live", run the following command:

```console
pip install -e .[sphinx]
sphinx-build docs docs/_build/html
```

Then browse the HTML files in `docs/_build/html` to see the rendered documentation.
ansys-sherlock 0.1.dev0
A Python wrapper for Ansys Sherlock
Requires Python: >=3.7

PySherlock Project Overview
---------------------------
ANSYS Sherlock is a reliability physics-based electronics design tool that provides
fast and accurate life predictions for electronic hardware at the component, 
board and system levels in early stage design.
The PySherlock library provides Pythonic access to Sherlock's functions, enabling
users to automate and customize their specific workflows.
Below is a list of the currently supported features:

* Launch a Sherlock gRPC server and a Sherlock client

.. * Import ECAD files and generate project reports
.. * Define life cycle events and profiles
.. * Generate a stackup and update a stackup layer
.. * Update a project parts list
.. * Perform layer view operations such as updating a component's location
.. * Export a 3D model, material definitions and material assignments for integration with ANSYS Workbench
.. * Execute one or more analyses

Installation
------------
.. Include installation directions.  Note that this README will be
.. included in your PyPI package, so be sure to include ``pip``
.. directions along with developer installation directions.  For example.

Install PySherlock with:

.. code::

   pip install ansys-sherlock-core

Alternatively, clone and install in development mode with:

.. code::

   git clone https://github.com/pyansys/pysherlock
   pip install -e .


Documentation and Issues
------------------------
Documentation link will be provided here once the documentation site becomes available.


Getting Started
---------------
Launch Sherlock Locally
^^^^^^^^^^^^^^^^^^^^^^^
.. code::

    from ansys.sherlock.launcher import launcher
    launcher.launch_sherlock()

This automatically searches for the latest local version of Sherlock, and launches the Sherlock gRPC server on port 9090. It also launches a Sherlock client connected to the same port.

Alternatively you can start the Sherlock gRPC server on a different port by using the ``port`` parameter. For example:

.. code::

    from ansys.sherlock.launcher import launcher
    launcher.launch_sherlock(port=9092)

.. Example Usage
.. -------------

.. .. code:: python


.. Testing
.. -------
.. You can feel free to include this at the README level or in CONTRIBUTING.md


License
-------
``PySherlock`` is licensed under the MIT license.

This module allows users access to existing Sherlock functionalities and requires a legally licensed local copy of Ansys.

Please visit `Ansys <http://www.ansys.com>`_ for more information on getting a licensed copy.
inverselap 1.3.2
Provides a variety of numerical inversion methods for the inverse Laplace transform

## Numerical inversion of Laplace transform

1.Use the following statement to import



	from inverselap import inverse


### One-dimensional Laplace inversion

Take a one-dimensional function as an example


	def fs_1d(s):
	    return 1/(s+1)


2.1 method Gaver-Stehfest

Use the following statement for inversion: inverse.GS_1d(f,t,M), f means functon, t meanstime parameter， M means the number of nodes, M is a positive even number while 14, 16 and 18 are recommended



	inverse.GS_1d(f,1,18)


2.2 method Euler

Use the following statement for inversion: inverse.Euler_1d(f,t,M), f means functon, t meanstime parameter， M means the number of nodes, M is a positive number while 17 and 19 are recommended


	inverse.Euler_1d(fs_1d,1,19)


2.3 method Talbot

Use the following statement for inversion: inverse.Talbot_1d(f,t,M), f means functon, t meanstime parameter, M means the number of nodes, M is a positive number while 21 is recommended


	inverse.Talbot_1d(fs_1d,1,21)


### Two-dimensional Laplace inversion

Take a rwo-dimensional function as an example


	def fs_2d(s1,s2):
	    return 1/(s1+1)/(s2+2)


3.1 method series

Use the following statement for inversion: inverse.series_2d(f,t1,t2,N,c1,c2), f means functon, t1 and t2 mean time parameter, N means the number of nodes, N is a positive number while 64 and 128 is recommended, c1 and c2 should be larger than the s1 and s2 where the value fs_2d(s1,s2) is infinite if possible. 


	inverse.series_2d(fs_2d,1,1,128,0,-1)


3.2 method partial

Use the following statement for inversion: inverse.Partial_2d(f,t1,t2,N,par1,par2), f means functon, t1 and t2 mean time parameter, N means the number of nodes, N is a positive number while 64 and 128 is recommended, alpha1 and alpha1 should be the s1 and s2 where the value fs_2d(s1,s2) is infinite if possible. 


	inverse.Partial_2d(fs_2d,1,1,128,-1,-2)


3.3 mtehod Talbot

Use the following statement for inversion: inverse.Talbot_2d(f,t1,t2,M), f means functon, t1 and t2 mean time parameter, M means the number of nodes, M is a positive number while 21 is recommended


	inverse.Talbot_2d(fs_2d,1,1,18)



3.4 mtehod Euler

Use the following statement for inversion: inverse.Euler_2d(f,t1,t2,M), f means functon, t1 and t2 mean time parameter, M means the number of nodes, M is a positive number while 17 and 19 are recommended


	inverse.Euler_2d(fs_2d,1,1,21)


3.5 method epsilon

Use the following statement for inversion: inverse.epsilon(f,t1,t2,alpha1,alpha2), f means functon, t1 and t2 mean time parameter, alpha1 and alpha1 should be the s1 and s2 where the value fs_2d(s1,s2) is infinite if possible. 



	inverse.inverse.epsilon(fs_2d,1,1,-1,-1)