def buildNumbersOperator(expression):
digitLists = parseNumbersExpression(expression)
if len(digitLists) == 1:
return RPNGenerator.createGenerator(convertStringsToNumbers,
digitLists)
return RPNGenerator.createStringProduct(digitLists)
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 ) )
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
def getCumulativeListSumsOperator( n ):
return RPNGenerator( getCumulativeListSums( n ) )
def getCumulativeListRatiosOperator( n ):
return RPNGenerator( getCumulativeListRatios( n ) )
def getListDiffsOperator( n ):
return RPNGenerator( getListDiffs( n ) )
def getCumulativeListProductsOperator( n ):
return RPNGenerator( getCumulativeListProducts( n ) )
def filterOnFlagsOperator( n, k ):
return RPNGenerator.createGenerator( filterOnFlagsGenerator, [ n, k ] )
def getSlice( args, start, end ):
return RPNGenerator.createGenerator( getSliceGenerator, [ args, start, end ] )
def buildStepNumbersOperator(n):
return RPNGenerator.createGenerator(buildStepNumbersGenerator, [n])
def filterMin( n, k ):
return RPNGenerator.createGenerator( filterMinGenerator, [ n, k ] )
def permuteDigitsOperator(n):
return RPNGenerator.createPermutations(getMPFIntegerAsString(n))
def generateSquareDigitChainOperator(n):
return RPNGenerator.createGenerator(generateSquareDigitChainGenerator, [n])
def getMultipleRandomsGenerator( n ):
return RPNGenerator.createGenerator( getMultipleRandoms, n )
def getRandomIntegersGenerator( n, k ):
return RPNGenerator.createGenerator( getRandomIntegers, [ n, k ] )
def getSublist( args, start, count ):
return RPNGenerator.createGenerator( getSublistGenerator, [ args, start, count ] )
def getMultipleRandomsOperator(n):
return RPNGenerator.createGenerator(getMultipleRandoms, n)
def getNthReversalAdditionOperator(n, k):
return RPNGenerator(getNthReversalAdditionGenerator(n, k))
def filterOnFlags( n, k ):
return RPNGenerator.createGenerator( filterOnFlagsGenerator, [ n, k ] )
def collateOperator( n ):
return RPNGenerator( collate( n ) )
def getListPowerSetOperator( n ):
if isinstance( n, RPNGenerator ):
return RPNGenerator( getListPowerSet( list( n ) ) )
return RPNGenerator( getListPowerSet( n ) )
def getSliceOperator( args, start, end ):
return RPNGenerator.createGenerator( getSliceGenerator, [ args, start, end ] )
def filterMinOperator( n, k ):
return RPNGenerator.createGenerator( filterMinGenerator, [ n, k ] )
def enumerateList( args, k ):
return RPNGenerator.createGenerator( enumerateListGenerator, [ args, k ] )
def enumerateListOperator( args, k ):
return RPNGenerator.createGenerator( enumerateListGenerator, [ args, k ] )
def getDeBruijnSequenceOperator(n, k):
return RPNGenerator(createDeBruijnSequence(n, k))
def getSublistOperator( args, start, count ):
return RPNGenerator.createGenerator( getSublistGenerator, [ args, start, count ] )
def getCompositionsOperator(n, k):
return RPNGenerator(getCompositionsGenerator(n, k))
def getCumulativeListDiffsOperator( n ):
return RPNGenerator( getCumulativeListDiffs( n ) )
def getPartitionsWithLimitOperator(n, k):
if k > n:
k = n
return RPNGenerator(partitionsWithLimit(n, k))
def getCumulativeListMeansOperator( n ):
return RPNGenerator( getCumulativeListMeans( n ) )
def getIntegerPartitionsOperator(n):
return RPNGenerator(createIntegerPartitions(int(n)))
def getListRatiosOperator( n ):
return RPNGenerator( getListRatios( n ) )
def alternateSignsOperator( n ):
return RPNGenerator( alternateSigns( n, False ) )
def alternateSigns2Operator( n ):
return RPNGenerator( alternateSigns( n, True ) )
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 )
def getRandomIntegersOperator(n, k):
return RPNGenerator.createGenerator(getRandomIntegers, [n, k])
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 )
