nt.py

Go to the documentation of this file.

# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.0
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.
 
from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _nt
else:
    import _nt
 
try:
    import builtins as __builtin__
except ImportError:
    import __builtin__
 
def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
 
 
def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr
 
 
def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr
 
 
def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper
 
 
class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
 
 
class SwigPyIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 
    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _nt.delete_SwigPyIterator
 
    def value(self):
        return _nt.SwigPyIterator_value(self)
 
    def incr(self, n=1):
        return _nt.SwigPyIterator_incr(self, n)
 
    def decr(self, n=1):
        return _nt.SwigPyIterator_decr(self, n)
 
    def distance(self, x):
        return _nt.SwigPyIterator_distance(self, x)
 
    def equal(self, x):
        return _nt.SwigPyIterator_equal(self, x)
 
    def copy(self):
        return _nt.SwigPyIterator_copy(self)
 
    def next(self):
        return _nt.SwigPyIterator_next(self)
 
    def __next__(self):
        return _nt.SwigPyIterator___next__(self)
 
    def previous(self):
        return _nt.SwigPyIterator_previous(self)
 
    def advance(self, n):
        return _nt.SwigPyIterator_advance(self, n)
 
    def __eq__(self, x):
        return _nt.SwigPyIterator___eq__(self, x)
 
    def __ne__(self, x):
        return _nt.SwigPyIterator___ne__(self, x)
 
    def __iadd__(self, n):
        return _nt.SwigPyIterator___iadd__(self, n)
 
    def __isub__(self, n):
        return _nt.SwigPyIterator___isub__(self, n)
 
    def __add__(self, n):
        return _nt.SwigPyIterator___add__(self, n)
 
    def __sub__(self, *args):
        return _nt.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
 
# Register SwigPyIterator in _nt:
_nt.SwigPyIterator_swigregister(SwigPyIterator)
class Basics(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def greatest_power(self, n, p):
        return _nt.Basics_greatest_power(self, n, p)
 
    def op_gcd(self, x, y):
        return _nt.Basics_op_gcd(self, x, y)
 
    def __init__(self):
        _nt.Basics_swiginit(self, _nt.new_Basics())
    __swig_destroy__ = _nt.delete_Basics
 
# Register Basics in _nt:
_nt.Basics_swigregister(Basics)
class PrimalityTest(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def is_prime(self, n):
        return _nt.PrimalityTest_is_prime(self, n)
 
    def compute_miller_rabin(self, d, n):
        return _nt.PrimalityTest_compute_miller_rabin(self, d, n)
 
    def miller_rabin_prime(self, n, iters):
        return _nt.PrimalityTest_miller_rabin_prime(self, n, iters)
 
    def miller_rabin(self, iters, min_val, max_val):
        return _nt.PrimalityTest_miller_rabin(self, iters, min_val, max_val)
 
    def witness(self, n, d, a, s):
        return _nt.PrimalityTest_witness(self, n, d, a, s)
 
    def AKS(self, n):
        return _nt.PrimalityTest_AKS(self, n)
 
    def jacobian_number(self, a, n):
        return _nt.PrimalityTest_jacobian_number(self, a, n)
 
    def solovoy_strassen(self, p, iters):
        return _nt.PrimalityTest_solovoy_strassen(self, p, iters)
 
    def mod_mul(self, a, b, m):
        return _nt.PrimalityTest_mod_mul(self, a, b, m)
 
    def mod_pow(self, a, b, m):
        return _nt.PrimalityTest_mod_pow(self, a, b, m)
 
    def carmichael_num(self, n):
        return _nt.PrimalityTest_carmichael_num(self, n)
 
    def ETF(self, n):
        return _nt.PrimalityTest_ETF(self, n)
 
    def __init__(self):
        _nt.PrimalityTest_swiginit(self, _nt.new_PrimalityTest())
    __swig_destroy__ = _nt.delete_PrimalityTest
 
# Register PrimalityTest in _nt:
_nt.PrimalityTest_swigregister(PrimalityTest)
class PrimalityGen(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def sieve_of_eratosthenes(self, n):
        return _nt.PrimalityGen_sieve_of_eratosthenes(self, n)
 
    def __init__(self):
        _nt.PrimalityGen_swiginit(self, _nt.new_PrimalityGen())
    __swig_destroy__ = _nt.delete_PrimalityGen
 
# Register PrimalityGen in _nt:
_nt.PrimalityGen_swigregister(PrimalityGen)
class Logarithms(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def pollard_rho_log(self, a, b, m):
        return _nt.Logarithms_pollard_rho_log(self, a, b, m)
 
    def BSGS(self, a, b, m):
        return _nt.Logarithms_BSGS(self, a, b, m)
 
    def __init__(self):
        _nt.Logarithms_swiginit(self, _nt.new_Logarithms())
    __swig_destroy__ = _nt.delete_Logarithms
 
# Register Logarithms in _nt:
_nt.Logarithms_swigregister(Logarithms)
class Factorization(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def pollard_rho(self, n):
        return _nt.Factorization_pollard_rho(self, n)
 
    def __init__(self):
        _nt.Factorization_swiginit(self, _nt.new_Factorization())
    __swig_destroy__ = _nt.delete_Factorization
 
# Register Factorization in _nt:
_nt.Factorization_swigregister(Factorization)
BITS = _nt.BITS
BYTE_LIMIT = _nt.BYTE_LIMIT
class RC4(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def byte_swap(self, a, b):
        return _nt.RC4_byte_swap(self, a, b)
 
    def trad_swap(self, a, b):
        return _nt.RC4_trad_swap(self, a, b)
 
    def XOR_swap(self, a, b):
        return _nt.RC4_XOR_swap(self, a, b)
 
    def KSA(self, key, S, swap_type):
        return _nt.RC4_KSA(self, key, S, swap_type)
 
    def PRGA(self, S, plaintext, ciphertext, swap_type):
        return _nt.RC4_PRGA(self, S, plaintext, ciphertext, swap_type)
 
    def store_hash(self, plaintext, hashtext, swap_type):
        return _nt.RC4_store_hash(self, plaintext, hashtext, swap_type)
 
    def compute(self, key, plaintext, hashtext, swap_type):
        return _nt.RC4_compute(self, key, plaintext, hashtext, swap_type)
 
    def __init__(self):
        _nt.RC4_swiginit(self, _nt.new_RC4())
    __swig_destroy__ = _nt.delete_RC4
 
# Register RC4 in _nt:
_nt.RC4_swigregister(RC4)
class Cipher(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def caesar(self, plaintext, key):
        return _nt.Cipher_caesar(self, plaintext, key)
 
    def keyword_encode(self, key):
        return _nt.Cipher_keyword_encode(self, key)
 
    def keyword(self, plaintext, encoded_text):
        return _nt.Cipher_keyword(self, plaintext, encoded_text)
 
    def __init__(self):
        _nt.Cipher_swiginit(self, _nt.new_Cipher())
    __swig_destroy__ = _nt.delete_Cipher
 
# Register Cipher in _nt:
_nt.Cipher_swigregister(Cipher)