Ejemplos de create_test_list en Python

Ejemplo n.º 1

Archivo: coopsort_run.py Proyecto: Gansakumar/opal

def run(param_file, problem):
    probInfos = problem.split('-')
    listSpecIndex = int(probInfos[0])
    if len(probInfos) > 1:
        listLength = int(probInfos[1])
    else:
        listLength = 4000
    if len(probInfos) > 2:
        numberOfRepeat = int(probInfos[2])
    else:
        numberOfRepeat = 1
    if len(probInfos) > 3:
        groupSize = int(probInfos[3])
    else:
        groupSize = 1
    params = read_params_from_file(param_file)
    if int(params['nothing']) != 0:
        return {'TIME': float("inf")}

    coopTreeFactory = CooperationTreeFactory(name="test factory")
    try:
        treeEncodedNumber = int(params['coopTree'])
    except:
        treeEncodedNumber = int(float(params['coopTree']))
    createTree = coopTreeFactory.createTreeFromEncodedNumber
    coopTree = createTree(name='coop tree',
                          encodedNumber=treeEncodedNumber,
                          radix=6)
    l = []
    for g in range(groupSize):
        l.append(create_test_list(listSpecs[listSpecIndex], listLength, 0))
    meanTime = 0.0
    for r in range(numberOfRepeat):
        sortingTime = 0.0
        for i in range(groupSize):
            l1 = list(l[i])
            tb = benchmarkTime()
            try:
                l1 = coopsort(l1, coopTree.getRoot())
            except:
                return {'TIME': float("inf")}
            te = benchmarkTime()
            sortingTime = sortingTime + (te - tb)
            del l1[:]
            del l1
        meanTime = meanTime + sortingTime

    measures = {'TIME': meanTime / numberOfRepeat}
    return measures

Ejemplo n.º 2

Archivo: coopsort_run.py Proyecto: demonalex1/opal

def run(param_file, problem):
    probInfos = problem.split('-')
    listSpecIndex = int(probInfos[0])
    if len(probInfos) > 1:
        listLength = int(probInfos[1])
    else:
        listLength = 4000
    if len(probInfos) > 2:
        numberOfRepeat = int(probInfos[2])
    else:
        numberOfRepeat = 1
    if len(probInfos) > 3:
        groupSize = int(probInfos[3])
    else:
        groupSize = 1
    params = read_params_from_file(param_file)
    if int(params['nothing']) != 0:
        return {'TIME': float("inf")}

    coopTreeFactory = CooperationTreeFactory(name="test factory")
    try:
        treeEncodedNumber = int(params['coopTree'])
    except:
        treeEncodedNumber = int(float(params['coopTree']))
    createTree = coopTreeFactory.createTreeFromEncodedNumber
    coopTree = createTree(name='coop tree',
                          encodedNumber=treeEncodedNumber,
                          radix=6)
    l = []
    for g in range(groupSize):
        l.append(create_test_list(listSpecs[listSpecIndex], listLength, 0))
    meanTime = 0.0
    for r in range(numberOfRepeat):
        sortingTime = 0.0
        for i in range(groupSize):
            l1 = list(l[i])
            tb = benchmarkTime()
            try:
                l1 = coopsort(l1, coopTree.getRoot())
            except:
                return {'TIME': float("inf")}
            te = benchmarkTime()
            sortingTime = sortingTime + (te - tb)
            del l1[:]
            del l1
        meanTime = meanTime + sortingTime

    measures = {'TIME': meanTime / numberOfRepeat}
    return measures

Ejemplo n.º 3

from coopsort import create_test_list
import sys

if len(sys.argv) > 1:
    listSpecs = eval(sys.argv[1])
else:
    listSpecs = [[8, 0.0125]]
if len(sys.argv) > 2:
    numberOfList = int(sys.argv[2])
else:
    numberOfList = 200
if len(sys.argv) > 3:
    listLengthUnit = int(sys.argv[3])
else:
    listLengthUnit = 20

generatedLists = {}
for listSpec in listSpecs:
    listType = listSpec[0]
    for k in range(numberOfList):
        n = listLengthUnit * (k + 1)
        #for n in [250, 500, 750, 1000, 1250, 1500, 1750, 2000]:
        listName = str(listSpec) + 'l' + str(n)
        generatedLists[listName] = create_test_list(listSpec, n, 0)
print generatedLists

Ejemplo n.º 4

Archivo: generate_performance_profiles.py Proyecto: Gansakumar/opal

for algoName in algorithms:
    coopTrees[algoName] = createAlgo(name='coopsort',
                                     methodSequence=algorithms[algoName])

listSpec = benchmarkSpec['lists']['specs'][0]
listLengh = benchmarkSpec['lists']['unit length']
numberOfList = benchmarkSpec['lists']['number of list']
numberOfRepeat = benchmarkSpec['testing']['repeats']

cpuTime = {}
profiles = {}
for name, coopTree in coopTrees.iteritems():
    profiles[name] = []

for i in range(numberOfList):
    l = create_test_list(listSpec, listLength, 0)
    minTime = float('inf')
    cpuTime = {}
    for name, coopTree in coopTrees.iteritems():
        meanTime = 0.0
        for r in range(numberOfRepeat):
            l1 = list(l)
            if isfunction(coopTree):
                tb = benchmarkTime()
                l1 = coopTree(l1)
            else:
                tb = benchmarkTime()
                l1 = coopsort(l1, coopTree.getRoot())
            te = benchmarkTime()
            del l1[:]
            del l1

Ejemplo n.º 5

Archivo: benchmark_algorithms.py Proyecto: Gansakumar/opal

cpuTime = {}

listSpecs = benchmarkSpec['lists']['specs']
listLenghUnit = benchmarkSpec['lists']['unit length']
numberOfList = benchmarkSpec['lists']['number of list']
numberOfRepeat = benchmarkSpec['testing']['repeats']

for listSpec in listSpecs:
    listType = str(listSpec)
    cpuTime[listType] = {}
    for name, coopTree in coopTrees.iteritems():
        cpuTime[listType][name] = {}
    for k in range(numberOfList):
        n = listLengthUnit * (k + 1)
        l = create_test_list(listSpec, n, 0)
        for name, coopTree in coopTrees.iteritems():
            meanTime = 0.0
            for r in range(numberOfRepeat):
                l1 = list(l)
                if isfunction(coopTree):
                    tb = benchmarkTime()
                    l1 = coopTree(l1)
                else:
                    tb = benchmarkTime()
                    l1 = coopsort(l1, coopTree.getRoot())
                te = benchmarkTime()
                listIsSorted = verify_sorted_list(l1)
                if listIsSorted:
                    meanTime = meanTime + (te - tb)
                else:

Ejemplo n.º 6

Archivo: benchmark_algorithms.py Proyecto: demonalex1/opal

cpuTime = {}

listSpecs = benchmarkSpec['lists']['specs']
listLenghUnit = benchmarkSpec['lists']['unit length']
numberOfList = benchmarkSpec['lists']['number of list']
numberOfRepeat = benchmarkSpec['testing']['repeats']

for listSpec in listSpecs:
    listType = str(listSpec)
    cpuTime[listType] = {}
    for name, coopTree in coopTrees.iteritems():
        cpuTime[listType][name] = {}
    for k in range(numberOfList):
        n = listLengthUnit * (k + 1)
        l = create_test_list(listSpec, n, 0)
        for name, coopTree in coopTrees.iteritems():
            meanTime = 0.0
            for r in range(numberOfRepeat):
                l1 = list(l)
                if isfunction(coopTree):
                    tb = benchmarkTime()
                    l1 = coopTree(l1)
                else:
                    tb = benchmarkTime()
                    l1 = coopsort(l1, coopTree.getRoot())
                te = benchmarkTime()
                listIsSorted = verify_sorted_list(l1)
                if listIsSorted:
                    meanTime = meanTime + (te - tb)
                else:

Ejemplo n.º 7

Archivo: generate_performance_profiles.py Proyecto: demonalex1/opal

for algoName in algorithms:
    coopTrees[algoName] = createAlgo(name='coopsort',
                                     methodSequence=algorithms[algoName])

listSpec = benchmarkSpec['lists']['specs'][0]
listLengh = benchmarkSpec['lists']['unit length']
numberOfList = benchmarkSpec['lists']['number of list']
numberOfRepeat = benchmarkSpec['testing']['repeats']

cpuTime = {}
profiles = {}
for name, coopTree in coopTrees.iteritems():
    profiles[name] = []

for i in range(numberOfList):
    l = create_test_list(listSpec, listLength, 0)
    minTime = float('inf')
    cpuTime = {}
    for name, coopTree in coopTrees.iteritems():
        meanTime = 0.0
        for r in range(numberOfRepeat):
            l1 = list(l)
            if isfunction(coopTree):
                tb = benchmarkTime()
                l1 = coopTree(l1)
            else:
                tb = benchmarkTime()
                l1 = coopsort(l1, coopTree.getRoot())
            te = benchmarkTime()
            del l1[:]
            del l1