semvec/pypi-packages huggingface dataset:
fre 0.0.3
Function Regular Expression

# Functionnal Regular Expression : fre

**fre** permet d'utiliser les expressions régulières directement en python sans 
passer par les strings.

## Motivation

Utiliser les expressions régulières fait partie des choses basiques en 
ingéniérie logicielle et la plupart du temps cela se fait au travers de strings
qui sont parsées puis utilisées pour effectuer le matching avec d'autres 
chaines.

C'est pourquoi il y a **fre** qui permet de coder les expressions régulières 
directement en python sans phase de précompilation. On a donc un gain de 
performance à l'exécution. 

## Features

**fre** permet d'écrire les expressions régulières directement en python, soit
de manière purement fonctionnelle, soit avec des opérateurs.

#### Un exemple fonctionnel

```python
from fre.fnregex import charinterval, char

def match_lower(c: chr) -> bool:
    lower = charinterval(char('a'), char('z')) # utilisation de fonctions
    return lower(c).matched()
```

#### Le même avec les opérateurs

```python
from fre.opregex import a, z

def match_lower(c: chr) -> bool:
    lower = a - z # utilisation de l'opérateur d'interval
    return lower(c).matched()
```


**fre** expose deux fonctions principales : 

```python
def match(fnrx: FnRegex, inp: str) -> MatchResult:
    ...
```
```python
def fullmatch(fnrx: FnRegex, inp: str) -> FullMatchResult:
    ...
```

Ces deux fonctions prennent en premier paramètre une FnRegex construite soit de
manière fonctionnelle soit avec les opérateurs et en second paramètre la string
dont on veut savoir si la valeur correspond ou pas avec l'expression régulière. 

`fullmatch` au contraire de `match` demande à ce que la totalité de la string soit
en correspondance avec l'expression régulière. Alors que `match` elle ne demande
que le début soit correspondant. 

## Installation

#### Pypi

```bash
pip install fre
``` 

## Contribution

## Licence

**fre** est sous [licence MIT](LICENSE)
arith-lib 2.0.0
A set of functions for miscellaneous arithmetic calculation
Keywords: gcd lcm bezout pseudo prime miller rabin factorization divisor chinese remainder phi euler totient moebius base frobenius isqrt

## arith_lib: A set of functions for miscellaneous arithmetic calculation

### List of implemented functions

* **gcd(\*arg):**
Greatest common divisor of a set of integers

* **lcm(\*arg):**
Least common multiple of a set of integers

* **bezout(a, b):**
Provides a particular solution to diophantine equation a.u+b.v=gcd(a, b)

* **modulo_inv(a, b):**
Inverse of a modulo b

* **chinese_remainder(r, m):**
Solves the modular system:
   * x = r1 mod m1
   * x = r2 mod m2
   * ...
   * x = r_n mod m_n

* **gene_pseudo_prime():**
A generator which provides 2, 3, 5 and then all integers non multiple of 2, 3, 5

* **is_prime(n):**
Check for n primality. Miller-Rabin primality test is used

* **next_prime(n):**
Provides the first prime greater or equal to n

* **previous_prime(n)**
Provides the first prime smaller or equal to n

* **prime_factorization(n, frmt):**
Prime factorization of n

* **divisors(n):**
Provides all divisors of n

* **phi(n):**
Euler totient function

* **moebius(n):**
Moebius function

* **to_base(n, \*kwarg):**
Conversion from base 10 to base B

* **frobenius(\*A, n=None):**
Solves equation a1.x1 + a2.x2 + .. + ap.xp = n or finds
the greatest n for which this equation has no solution.
a1, a2, ... are positive integers.
x1, x2, ... are the unknowns, positive integers

* **isqrt(n)**
Provides the integer part of the square root of n
where n is an integer of any size

* **is_miller_rabin_witness(a, n)**
Return True if 'a' is a Miller-Rabin witness for n

* **get_random_prime(nbits, lessthan)**
Provides a random prime with exactly or at most 'nbits' bits

* **is_strong_pseudoprime(a, n)**
Return True is n is a strong pseudo prime to base 'a'


### Installation

pip install arith_lib


### Utilization

from arith_lib import \*

\>>> gcd(15, 20)
5