Example #1
0
def buildNumbersOperator(expression):
    digitLists = parseNumbersExpression(expression)

    if len(digitLists) == 1:
        return RPNGenerator.createGenerator(convertStringsToNumbers,
                                            digitLists)

    return RPNGenerator.createStringProduct(digitLists)
Example #2
0
def getListPermutationsWithRepeatsOperator( n, k ):
    if not isinstance( n, ( list, RPNGenerator ) ):
        raise ValueError( '\'get_repeat_permutations\' expects a list' )

    if len( n ) < k:
        raise ValueError( 'k must be greater than or equal to the length of list n' )

    return RPNGenerator( getListPermutationsWithRepeatsGenerator( n, k ) )
Example #3
0
        def evaluateOneArg(arg):
            if isinstance(arg, list):
                result = [evaluateOneArg(i) for i in arg]
            elif isinstance(arg, RPNGenerator):
                result = RPNGenerator.createChained(arg.getGenerator(), func)
            else:
                result = func(arg)

            return result
Example #4
0
def getCumulativeListSumsOperator( n ):
    return RPNGenerator( getCumulativeListSums( n ) )
Example #5
0
def getCumulativeListRatiosOperator( n ):
    return RPNGenerator( getCumulativeListRatios( n ) )
Example #6
0
def getListDiffsOperator( n ):
    return RPNGenerator( getListDiffs( n ) )
Example #7
0
def getCumulativeListProductsOperator( n ):
    return RPNGenerator( getCumulativeListProducts( n ) )
Example #8
0
def filterOnFlagsOperator( n, k ):
    return RPNGenerator.createGenerator( filterOnFlagsGenerator, [ n, k ] )
Example #9
0
def getSlice( args, start, end ):
    return RPNGenerator.createGenerator( getSliceGenerator, [ args, start, end ] )
Example #10
0
def buildStepNumbersOperator(n):
    return RPNGenerator.createGenerator(buildStepNumbersGenerator, [n])
Example #11
0
def filterMin( n, k ):
    return RPNGenerator.createGenerator( filterMinGenerator, [ n, k ] )
Example #12
0
def permuteDigitsOperator(n):
    return RPNGenerator.createPermutations(getMPFIntegerAsString(n))
Example #13
0
def generateSquareDigitChainOperator(n):
    return RPNGenerator.createGenerator(generateSquareDigitChainGenerator, [n])
Example #14
0
def getMultipleRandomsGenerator( n ):
        return RPNGenerator.createGenerator( getMultipleRandoms, n )
Example #15
0
def getRandomIntegersGenerator( n, k ):
    return RPNGenerator.createGenerator( getRandomIntegers, [ n, k ] )
Example #16
0
def getSublist( args, start, count ):
    return RPNGenerator.createGenerator( getSublistGenerator, [ args, start, count ] )
Example #17
0
def getMultipleRandomsOperator(n):
    return RPNGenerator.createGenerator(getMultipleRandoms, n)
Example #18
0
def getNthReversalAdditionOperator(n, k):
    return RPNGenerator(getNthReversalAdditionGenerator(n, k))
Example #19
0
def filterOnFlags( n, k ):
    return RPNGenerator.createGenerator( filterOnFlagsGenerator, [ n, k ] )
Example #20
0
def collateOperator( n ):
    return RPNGenerator( collate( n ) )
Example #21
0
def getListPowerSetOperator( n ):
    if isinstance( n, RPNGenerator ):
        return RPNGenerator( getListPowerSet( list( n ) ) )

    return RPNGenerator( getListPowerSet( n ) )
Example #22
0
def getSliceOperator( args, start, end ):
    return RPNGenerator.createGenerator( getSliceGenerator, [ args, start, end ] )
Example #23
0
def filterMinOperator( n, k ):
    return RPNGenerator.createGenerator( filterMinGenerator, [ n, k ] )
Example #24
0
def enumerateList( args, k ):
    return RPNGenerator.createGenerator( enumerateListGenerator, [ args, k ] )
Example #25
0
def enumerateListOperator( args, k ):
    return RPNGenerator.createGenerator( enumerateListGenerator, [ args, k ] )
Example #26
0
def getDeBruijnSequenceOperator(n, k):
    return RPNGenerator(createDeBruijnSequence(n, k))
Example #27
0
def getSublistOperator( args, start, count ):
    return RPNGenerator.createGenerator( getSublistGenerator, [ args, start, count ] )
Example #28
0
def getCompositionsOperator(n, k):
    return RPNGenerator(getCompositionsGenerator(n, k))
Example #29
0
def getCumulativeListDiffsOperator( n ):
    return RPNGenerator( getCumulativeListDiffs( n ) )
Example #30
0
def getPartitionsWithLimitOperator(n, k):
    if k > n:
        k = n

    return RPNGenerator(partitionsWithLimit(n, k))
Example #31
0
def getCumulativeListMeansOperator( n ):
    return RPNGenerator( getCumulativeListMeans( n ) )
Example #32
0
def getIntegerPartitionsOperator(n):
    return RPNGenerator(createIntegerPartitions(int(n)))
Example #33
0
def getListRatiosOperator( n ):
    return RPNGenerator( getListRatios( n ) )
Example #34
0
def alternateSignsOperator( n ):
    return RPNGenerator( alternateSigns( n, False ) )
Example #35
0
def alternateSigns2Operator( n ):
    return RPNGenerator( alternateSigns( n, True ) )
Example #36
0
def permuteListsOperator( lists ):
    for i in lists:
        if not isinstance( i, ( list, RPNGenerator ) ):
            raise ValueError( '\'permute_lists\' expects a list of lists' )

    return RPNGenerator.createProduct( lists )
Example #37
0
def getRandomIntegersOperator(n, k):
    return RPNGenerator.createGenerator(getRandomIntegers, [n, k])
Example #38
0
def permuteLists( lists ):
    for i in lists:
        if not isinstance( i, ( list, RPNGenerator ) ):
            raise ValueError( '\'permute_lists\' expects a list of lists' )

    return RPNGenerator.createProduct( lists )