extendedmath

#! /usr/bin/env/ python
# -*-coding: utf-8-*-

import sys
from functools import wraps

def isInteger(function):
    @wraps(function)
    def wrapper(*args):
        if all(type(each) == int and each >= 0 for each in args):
            return function(*args)
        else:
            raise TypeError, "The given value must be positive integer, got %s"%(str(args) + " instead" if any(type(each) != int for each in args) else "negative integer instead")
    return wrapper

def manager(argument = None, entity = None):
    def decorator(function):
        @wraps(function)
        def wrapper(x):
            if x == 1:
                return [0, 1]
            else:
                for each in ([z for z in range(2, sys.getrecursionlimit()) if z % 2 == 0] if argument == "double" and x % 2 == 0 else
                             [z for z in range(2, sys.getrecursionlimit()) if z % 2 != 0] if argument == "double" and x % 2 != 0 else
                              sequense(isPrime, 2, sys.getrecursionlimit()) if argument == "prime" else
                              range(2, sys.getrecursionlimit()+1)):
                    x = float(x)/(factorial(each) if argument == "super"
                                 else superfactorial(each) if argument == "hyper"
                 else float(each))
                    if x != 1.0 and x > 1.0:
                        continue
                    elif x != 1.0 and x < 1.0:
                        if entity:
                            return False
                        else:
                            raise ValueError,"The given value is not correct!"
                    else:
                        if argument == "prime":
                            values = [each]
                            for var in range(1, sys.getrecursionlimit()):
                                if not isPrime(each+var):
                                    values.append(each+var)
                                    continue
                                else:
                                    return values
                                    break
                            break
                        else:
                            return True if entity else each
                            break
                return function(x)
        return wrapper
    return decorator

def factorions(argument = None):
    def decorator(function):
        @wraps(function)
        def wrapper(x, k):
            if k == 0:
                raise ValueError, "0-factorions cannot be defined!"
            else:
                factorion = 0
                number = tuple(str(x))
                for each in number:
                    factorion += (factorial(int(each)) if not argument else
                                  superfactorial(int(each)) if argument == "super" else
                                  hyperfactorial(int(each)) if argument == "hyper" else
                                  doublefactorial(int(each)) if argument == "double" else
                                  primorial(int(each)))
                    if x == factorion * k:
                        return True
                    else:
                        return False
        return wrapper
    return decorator

@isInteger
def factorial(x):
    result = lambda x: result(x-1) * x if x > 0 else 1
    return result(x)

@isInteger
def superfactorial(x):
    result = lambda x: result(x-1) * factorial(x) if x > 0 else 1
    return result(x)

@isInteger
def hyperfactorial(x):
    result = lambda x: result(x-1)* superfactorial(x) if x > 0 else 1
    return result(x)

@isInteger
def doublefactorial(x):
    result = lambda x: result(x-2) * x if x > 0 else 1
    return result(x)

@isInteger
def primorial(x):
    primes = 1
    for each in range(1, x+1):
        if isPrime(each):
            primes *= each
    return primes

@isInteger
@manager()
def antifactorial(x):
    return x

@isInteger
@manager("super")
def antisuperfactorial(x):
    return x

@isInteger
@manager("hyper")
def antihyperfactorial(x):
    return x

@isInteger
@manager("double")
def antidoublefactorial(x):
    return x

@isInteger
@manager("prime")
def antiprimorial(x):
    return(x)

@isInteger
@manager(None, True)
def isFactorial(x):
    return x

@isInteger
@manager("super", True)
def isSuperfactorial(x):
    return x

@isInteger
@manager("hyper", True)
def isHyperfactorial(x):
    return x

@isInteger
@manager("double", True)
def isDoublefactorial(x):
    return x

@isInteger
@manager("prime", True)
def isPrimorial(x):
    return(x)

@isInteger
def isPrime(x):
    if x == 0 or x == 1:
        return False
    else:
        for each in range(2,x+1):
            if x % each == 0 and x != each:
                return False
                break
            elif x % each == 0 and x == each:
                return True

@isInteger
def isFactorion(x):
    return isKFactorion(x, 1)

@isInteger
def isSuperfactorion(x):
    return isKSuperfactorion(x, 1)

@isInteger
def isHyperfactorion(x):
    return isKHyperfactorion(x, 1)

@isInteger
def isDoublefactorion(x):
    return isKDoublefactorion(x, 1)

@isInteger
def isPrimorion(x):
    return isKPrimorion(x, 1)

@isInteger
@factorions()
def isKFactorion(x,k):
    return x

@isInteger
@factorions("super")
def isKSuperfactorion(x,k):
    return x

@isInteger
@factorions("hyper")
def isKHyperfactorion(x,k):
    return x

@isInteger
@factorions("double")
def isKDoublefactorion(x,k):
    return x

@isInteger
@factorions("prime")
def isKPrimorion(x,k):
    return x

def sequence(function, valueFrom = 0, valueTo = 1, reverse = False):
    result = []
    seq = [function(x) for x in range(valueFrom, valueTo+1)]
    if False in seq:
        for index, value in enumerate(seq):
            if value:
                result.append(index+valueFrom)
    else:
        result = seq
    return result if not reverse else result[::-1]