def __generate_input_graph(argstr, cleanup_generated_input):
"""Generate a graph from the specified string of arguments and return the file it is saved in."""
global __input_graph_to_cleanup
try:
if cleanup_generated_input:
input_graph = random_tmp_filename(10, 'input')
args = (argstr + ' -mqto ' + input_graph).split()
__input_graph_to_cleanup = input_graph
else:
args = (argstr + ' -mqt').split()
input_graph = generate_input(args, get_output_name_only=True)
__input_graph_to_cleanup = None
errstr = "unknown error"
ret = generate_input(args)
except Exception, errstr:
ret = -1
def __generate_input_graph(argstr, cleanup_generated_input):
"""Generate a graph from the specified string of arguments and return the file it is saved in."""
global __input_graph_to_cleanup
try:
if cleanup_generated_input:
input_graph = random_tmp_filename(10, 'input')
args = (argstr + ' -mqto ' + input_graph).split()
__input_graph_to_cleanup = input_graph
else:
args = (argstr + ' -mqt').split()
input_graph = generate_input(args, get_output_name_only=True)
__input_graph_to_cleanup = None
errstr = "unknown error"
ret = generate_input(args)
except Exception, errstr:
ret = -1
fmt = 'got %u variations, now adding %u complete graphs for a total of %u variations'
print fmt % (len(variations), len(edges), len(variations) + len(edges))
# add the complete graphs
for e in edges:
v = ceil(vertices_in_complete_undirected_graph(e))
e = edges_in_complete_undirected_graph(v)
variations.append((e, v))
# compute expected size
tot_sz = 0
max_sz = 0
for (e, v) in variations:
# per edge size cost is chars for two vertices, an edge weight, and spacing
my_sz = (e * (2 * len(str(v)) + 8 + 3))
max_sz = max(max_sz, my_sz)
tot_sz += my_sz
tot_sz /= (1024 * 1024 * 1024)
max_sz /= (1024 * 1024)
print 'aggregate input size is %uGB (max input file size is %uMB)' % (
int(tot_sz), int(max_sz))
# generate the graphs
for i in range(1, num_versions + 1):
ifl = get_path_to_project_root() + 'input/nperf-%u.inputs' % i
print 'generating inputs for ' + ifl
for (e, v) in variations:
argstr = '--dont-generate -q -l %s -n %u %u' % (ifl, e, v)
generate_input(argstr.split())
def main(argv=sys.argv[1:]):
usage = """usage: %prog [options] NUM_VERTICES
Uses generate_input.py to generate a variety of edge densities for a given
number of vertices. The edge densities used will be the maximum edge density
(-m) down to 0.0 (excluded unless -z is specified) in steps of -d.
Example: Generate 5 inputs and log them to the corr.inputs file with correctness
values for 10 vertices and for densities 1.0, 0.75, 0.5, and 0.25:
%prog -n5 -g '-l ../input/corr.inputs -c' 10"""
parser = OptionParser(usage)
parser.add_option("-d", "--density-interval",
type="float", default=0.25, metavar="D",
help="spacing between inputs in terms of the edge density interval [default: %default]")
parser.add_option("-g", "--generate-input",
metavar="GEN_ARGS", default="",
help="extra arguments to pass to generate_input.py")
parser.add_option("-m", "--max-density",
type="float", default=1.0, metavar="D",
help="maximum edge density [default: %default]")
parser.add_option("-n", "--num-runs-per-edge-density",
type="int", default=1, metavar="n",
help="number of inputs to generate for each edge density [default: %default]")
parser.add_option("-z", "--zero",
action="store_true", default=False,
help="generate zero-density (spanning tree) graphs too")
(options, args) = parser.parse_args(argv)
if len(args) < 1:
parser.error("missing NUM_VERTICES")
elif len(args) > 1:
parser.error("too many arguments")
try:
v = int(args[0])
if v <= 0:
parser.error('NUM_VERTICES must be at least 1')
except ValueError:
parser.error('NUM_VERTICES must be an integer')
di = options.density_interval
if di < 0.0 or di > 1.0:
parser.error('-d must be between 0 and 1 inclusive')
n = options.num_runs_per_edge_density
if n < 0:
parser.error('-n must be greater than or equal to 0')
d = options.max_density
if d < 0.0 or d > 1.0:
parser.error('-d must be between 0 and 1 inclusive')
extra_args = options.generate_input
while d >= 0.0:
if d == 0 and not options.zero:
break
e = get_edges_from_density(v, d)
for _ in range(n):
args = ('-n %u %s %u' % (e, extra_args, v)).split()
try:
ret = generate_input(args)
except Exception, errstr:
print >> sys.stderr, 'fan_gen failed: ' + errstr
return -1
if ret != 0:
print >> sys.stderr, 'fan_gen failed'
return -1
d -= di
from generate_input import generate_input
container = [
(13, 2, 2, 2, 1, 2), # (6,10)
(5, 1, 3, 4, 1, 2), # (1,0)
(17, 4, 12, 5, 15, 3) # (-1,-1)
]
container = generate_input(323)
def twoPcalc(pX, pY, p):
if (pY == 0):
return 'inf'
# lambda
gL = (3 * pow(pX, 2) + A) * pow(2 * pY, p - 2, p)
# Nue
gN = pY - (gL * pX)
# P coordinates
x3 = pow(gL, 2) - (2 * pX)
y3 = (-gL * x3) - gN
return (x3 % p, y3 % p)
def dblAdd(pX, pY, qX, qY, p):
if pY == (-qY % p):
return 'inf'
# lambda
gL = (qY - pY) * pow(qX - pX, p - 2, p)
# Nue
gN = pY - gL * pX
def main(argv=sys.argv[1:]):
usage = """usage: %prog [options] NUM_VERTICES
Generates input for evaluating performance at different edge densities for a given |V|."""
parser = OptionParser(usage)
parser.add_option("-a", "--additive-step-type",
action="store_true", default=False,
help="use additive stepping between numbers of vertices [default: multiplicative]")
parser.add_option("-l", "--min",
type="float", default=4.0,
help="minimum edge:vertex ratio to generate a graph for [default: %default]")
parser.add_option("-n", "--num-per-step",
type="int", default=1, metavar="n",
help="number of inputs to generate for each step [default: %default]")
parser.add_option("-s", "--step",
type="float", default=2.0,
help="step amount between edge:vertex ratios (see -a) [default: %default]")
parser.add_option("-u", "--max",
type="float", default=1500.0,
help="maximum edge:vertex ratio to generate a graph for [default: %default]")
(options, args) = parser.parse_args(argv)
if len(args) < 1:
parser.error("missing NUM_VERTICES")
elif len(args) > 1:
parser.error("too many arguments")
try:
num_verts = int(args[0])
inputs_list_file = get_path_to_project_root() + 'input/density-%u.inputs' % num_verts
except ValueError:
parser.error('NUM_NUM_VERTSERTICES must be a positive integer')
if num_verts < 1:
parser.error('NUM_VERTICES must be at least 1')
if options.min < 1 or options.min > options.max:
parser.error('-l must be in the range [1, max]')
max_edges = edges_in_complete_undirected_graph(num_verts)
max_ratio = max_edges / num_verts
if options.max < 1:
parser.error('-u must be at least 1')
elif options.max > max_ratio:
fmt = 'max edge:vertex ratio for %u vertices is %.1f, but -u specified a ratio of %u'
parser.error(fmt % (num_verts, max_ratio, options.max))
if options.additive_step_type:
if options.step < 1.0:
parser.error('-s must be greater than or equal to 1 when -a is used')
elif options.step <= 1.0:
parser.error('-s must be greater than 1 when -a is not used')
d = options.min
while True:
for _ in range(options.num_per_step):
num_edges = int(d * num_verts)
# stay within a complete graph, but round up to one if we get very close
if num_edges > max_edges or (num_edges/float(max_edges)) > 0.995:
num_edges = max_edges
d = options.max + 1 # stop after this iteration
args = '-p1 -l %s -n %u %u' % (inputs_list_file, num_edges, num_verts)
try:
print 'generating new input: ' + args
ret = generate_input(args.split())
except Exception, errstr:
print >> sys.stderr, 'generate_density_inputs failed for: ' + args + ': ' + str(errstr)
return -1
if ret != 0:
print >> sys.stderr, 'generate_density_inputs failed for: ' + args
return -1
if d >= options.max:
break
if options.additive_step_type:
d += options.step
else:
d *= options.step
if d > options.max:
d = options.max
for p in poms:
e = int(get_edges_from_percent_of_max(v, p))
density = e / float(v)
if density > 55 and density < 135 and v < 500:
what = 'skipped: '
else:
what = 'added: '
variations.append( (e, v) )
print '%sv=%u pom=%.2f e=%u => density=%.2f' % (what, v, p, e, e/float(v))
# compute expected size
tot_sz = 0
max_sz = 0
for (e, v) in variations:
# per edge size cost is chars for two vertices, an edge weight, and spacing
my_sz = (e * (2 * len(str(v)) + 8 + 3))
max_sz = max(max_sz, my_sz)
tot_sz += my_sz
tot_sz /= (1024 * 1024)
max_sz /= (1024 * 1024)
print 'aggregate input size is %uMB (max input file size is %uMB)' % (int(tot_sz), int(max_sz))
# generate the graphs
for i in range(1, num_versions+1):
ifl = get_path_to_project_root() + 'input/cperf-%u.inputs' % i
print 'generating inputs for ' + ifl
for (e, v) in variations:
argstr = '--dont-generate -q -l %s -n %u %u' % (ifl, e, v)
generate_input(argstr.split())
def main(argv=sys.argv[1:]):
usage = """usage: %prog [options]
Generates input for part 2 of the project en masse.
Examples:
Generate inputs for 2D vertex placement in powers of 2 up to and including
10000 vertices (10 inputs for each step):
%prog -d2 -u10000 -n10
Generate inputs for random edge weights in steps of 10 vertices up to and
including 100 vertices (1 input for each step):
%prog -a -s10 -u100"""
parser = OptionParser(usage)
parser.add_option("-a", "--additive-step-type",
action="store_true", default=False,
help="use additive stepping between numbers of vertices [default: multiplicative]")
parser.add_option("-d", "--dims",
type="int", default=0,
help="number of dimensions to use; 0 => use random edge weights [default: %default]")
parser.add_option("-g", "--go",
action="store_true", default=False,
help="run right away rather than generating inputs")
parser.add_option("-l", "--min",
type="int", default=1,
help="minimum number of vertices to generate a graph for [default: %default]")
parser.add_option("-n", "--num-per-step",
type="int", default=1, metavar="n",
help="number of inputs to generate for each step [default: %default]")
parser.add_option("-s", "--step",
type="float", default=2.0,
help="step amount between vertex sizes (see -a) [default: %default]")
parser.add_option("-u", "--max",
type="int", default=1024,
help="maximum number of vertices to generate a graph for [default: %default]")
(options, args) = parser.parse_args(argv)
if len(args) > 1:
parser.error("too many arguments")
if options.dims == 0:
what = '-e 0.0,1.0'
else:
what = '-v %u,0.0,1.0' % options.dims
if options.min < 1 or options.min > options.max:
parser.error('-l must be in the range [1, max]')
if options.max < 1:
parser.error('-u must be at least 1')
if options.additive_step_type:
if options.step < 1.0:
parser.error('-s must be greater than or equal to 1 when -a is used')
elif options.step <= 1.0:
parser.error('-s must be greater than 1 when -a is not used')
v = options.min
while True:
for _ in range(options.num_per_step):
if not options.go:
args = '-p15 %s %u' % (what, int(v))
try:
print 'generating new input: ' + args
ret = generate_input(args.split())
except Exception, errstr:
print >> sys.stderr, 'generate_weight_inputs failed for: ' + args + ': ' + str(errstr)
return -1
if ret != 0:
print >> sys.stderr, 'generate_weight_inputs failed for: ' + args
return -1
else:
cmd = get_path_to_tools_root() + 'run_test.py'
cmd += " -G '-p15 %s %u' -n1" % (what, int(v))
if os.system(cmd) != 0:
print >> sys.stderr, 'generate_weight_inputs GO mode failed for: ' + cmd
return -1
if v >= options.max:
break
if options.additive_step_type:
v += options.step
else:
v *= options.step
if v > options.max:
v = options.max
def main(argv=sys.argv[1:]):
usage = """usage: %prog [options] NUM_VERTICES
Generates input for evaluating performance at different edge densities for a given |V|."""
parser = OptionParser(usage)
parser.add_option(
"-a",
"--additive-step-type",
action="store_true",
default=False,
help=
"use additive stepping between numbers of vertices [default: multiplicative]"
)
parser.add_option(
"-l",
"--min",
type="float",
default=4.0,
help=
"minimum edge:vertex ratio to generate a graph for [default: %default]"
)
parser.add_option(
"-n",
"--num-per-step",
type="int",
default=1,
metavar="n",
help="number of inputs to generate for each step [default: %default]")
parser.add_option(
"-s",
"--step",
type="float",
default=2.0,
help=
"step amount between edge:vertex ratios (see -a) [default: %default]")
parser.add_option(
"-u",
"--max",
type="float",
default=1500.0,
help=
"maximum edge:vertex ratio to generate a graph for [default: %default]"
)
(options, args) = parser.parse_args(argv)
if len(args) < 1:
parser.error("missing NUM_VERTICES")
elif len(args) > 1:
parser.error("too many arguments")
try:
num_verts = int(args[0])
inputs_list_file = get_path_to_project_root(
) + 'input/density-%u.inputs' % num_verts
except ValueError:
parser.error('NUM_NUM_VERTSERTICES must be a positive integer')
if num_verts < 1:
parser.error('NUM_VERTICES must be at least 1')
if options.min < 1 or options.min > options.max:
parser.error('-l must be in the range [1, max]')
max_edges = edges_in_complete_undirected_graph(num_verts)
max_ratio = max_edges / num_verts
if options.max < 1:
parser.error('-u must be at least 1')
elif options.max > max_ratio:
fmt = 'max edge:vertex ratio for %u vertices is %.1f, but -u specified a ratio of %u'
parser.error(fmt % (num_verts, max_ratio, options.max))
if options.additive_step_type:
if options.step < 1.0:
parser.error(
'-s must be greater than or equal to 1 when -a is used')
elif options.step <= 1.0:
parser.error('-s must be greater than 1 when -a is not used')
d = options.min
while True:
for _ in range(options.num_per_step):
num_edges = int(d * num_verts)
# stay within a complete graph, but round up to one if we get very close
if num_edges > max_edges or (num_edges / float(max_edges)) > 0.995:
num_edges = max_edges
d = options.max + 1 # stop after this iteration
args = '-p1 -l %s -n %u %u' % (inputs_list_file, num_edges,
num_verts)
try:
print 'generating new input: ' + args
ret = generate_input(args.split())
except Exception, errstr:
print >> sys.stderr, 'generate_density_inputs failed for: ' + args + ': ' + str(
errstr)
return -1
if ret != 0:
print >> sys.stderr, 'generate_density_inputs failed for: ' + args
return -1
if d >= options.max:
break
if options.additive_step_type:
d += options.step
else:
d *= options.step
if d > options.max:
d = options.max
from generate_input import main as generate_input
import sys, time
if len(sys.argv) != 2:
print 'usage: gather_correctness.py LOG_FN'
sys.exit(-1)
# get the file to read inputs from
logfn = sys.argv[1]
ds = DataSet.read_from_file(InputSolution, logfn)
# compute correctness for each input
inputs = ds.dataset.keys() # Input objects
inputs.sort()
on = 0
for i in inputs:
on += 1
# figure out how to generate the graph and where it will be sotred
argstr = '-mt ' + i.make_args_for_generate_input()
input_graph = generate_input(argstr.split(), get_output_name_only=True)
print time.ctime(time.time()) + ' input # ' + str(
on) + ' => gathering correctness data for ' + argstr
# generate the graph
generate_input(argstr.split())
# compute the weight for the graph
get_and_log_mst_weight_from_checker(input_graph,
force_recompute=False,
inputslogfn=logfn)
from data import DataSet, InputSolution
from check_output import get_and_log_mst_weight_from_checker
from generate_input import main as generate_input
import sys, time
if len(sys.argv) != 2:
print 'usage: gather_correctness.py LOG_FN'
sys.exit(-1)
# get the file to read inputs from
logfn = sys.argv[1]
ds = DataSet.read_from_file(InputSolution, logfn)
# compute correctness for each input
inputs = ds.dataset.keys() # Input objects
inputs.sort()
on = 0
for i in inputs:
on += 1
# figure out how to generate the graph and where it will be sotred
argstr = '-mt ' + i.make_args_for_generate_input()
input_graph = generate_input(argstr.split(), get_output_name_only=True)
print time.ctime(time.time()) + ' input # ' + str(on) + ' => gathering correctness data for ' + argstr
# generate the graph
generate_input(argstr.split())
# compute the weight for the graph
get_and_log_mst_weight_from_checker(input_graph, force_recompute=False, inputslogfn=logfn)
seq = []
for i in range(k):
seq.append(a % n)
a = pow(a, 2, n)
for x in seq:
if gcd(n, x - 1) > 1:
p = gcd(n, x - 1)
q = int(n / p)
if q != 1:
found = True
break
i += 1
return p, q
def gcd(a, b):
if (b == 0):
return a
else:
return gcd(b, a % b)
l = generate_input("323")
for x in l:
N, e, d = x[0], x[1], x[2]
print("input: ", N, e, d)
print(mr(N, e, d))
def main(argv=sys.argv[1:]):
usage = """usage: %prog [options]
Generates input for part 2 of the project en masse.
Examples:
Generate inputs for 2D vertex placement in powers of 2 up to and including
10000 vertices (10 inputs for each step):
%prog -d2 -u10000 -n10
Generate inputs for random edge weights in steps of 10 vertices up to and
including 100 vertices (1 input for each step):
%prog -a -s10 -u100"""
parser = OptionParser(usage)
parser.add_option(
"-a",
"--additive-step-type",
action="store_true",
default=False,
help=
"use additive stepping between numbers of vertices [default: multiplicative]"
)
parser.add_option(
"-d",
"--dims",
type="int",
default=0,
help=
"number of dimensions to use; 0 => use random edge weights [default: %default]"
)
parser.add_option("-g",
"--go",
action="store_true",
default=False,
help="run right away rather than generating inputs")
parser.add_option(
"-l",
"--min",
type="int",
default=1,
help=
"minimum number of vertices to generate a graph for [default: %default]"
)
parser.add_option(
"-n",
"--num-per-step",
type="int",
default=1,
metavar="n",
help="number of inputs to generate for each step [default: %default]")
parser.add_option(
"-s",
"--step",
type="float",
default=2.0,
help="step amount between vertex sizes (see -a) [default: %default]")
parser.add_option(
"-u",
"--max",
type="int",
default=1024,
help=
"maximum number of vertices to generate a graph for [default: %default]"
)
(options, args) = parser.parse_args(argv)
if len(args) > 1:
parser.error("too many arguments")
if options.dims == 0:
what = '-e 0.0,1.0'
else:
what = '-v %u,0.0,1.0' % options.dims
if options.min < 1 or options.min > options.max:
parser.error('-l must be in the range [1, max]')
if options.max < 1:
parser.error('-u must be at least 1')
if options.additive_step_type:
if options.step < 1.0:
parser.error(
'-s must be greater than or equal to 1 when -a is used')
elif options.step <= 1.0:
parser.error('-s must be greater than 1 when -a is not used')
v = options.min
while True:
for _ in range(options.num_per_step):
if not options.go:
args = '-p15 %s %u' % (what, int(v))
try:
print 'generating new input: ' + args
ret = generate_input(args.split())
except Exception, errstr:
print >> sys.stderr, 'generate_weight_inputs failed for: ' + args + ': ' + str(
errstr)
return -1
if ret != 0:
print >> sys.stderr, 'generate_weight_inputs failed for: ' + args
return -1
else:
cmd = get_path_to_tools_root() + 'run_test.py'
cmd += " -G '-p15 %s %u' -n1" % (what, int(v))
if os.system(cmd) != 0:
print >> sys.stderr, 'generate_weight_inputs GO mode failed for: ' + cmd
return -1
if v >= options.max:
break
if options.additive_step_type:
v += options.step
else:
v *= options.step
if v > options.max:
v = options.max
def main(argv=sys.argv[1:]):
usage = """usage: %prog [options] NUM_VERTICES
Uses generate_input.py to generate a variety of edge densities for a given
number of vertices. The edge densities used will be the maximum edge density
(-m) down to 0.0 (excluded unless -z is specified) in steps of -d.
Example: Generate 5 inputs and log them to the corr.inputs file with correctness
values for 10 vertices and for densities 1.0, 0.75, 0.5, and 0.25:
%prog -n5 -g '-l ../input/corr.inputs -c' 10"""
parser = OptionParser(usage)
parser.add_option(
"-d",
"--density-interval",
type="float",
default=0.25,
metavar="D",
help=
"spacing between inputs in terms of the edge density interval [default: %default]"
)
parser.add_option("-g",
"--generate-input",
metavar="GEN_ARGS",
default="",
help="extra arguments to pass to generate_input.py")
parser.add_option("-m",
"--max-density",
type="float",
default=1.0,
metavar="D",
help="maximum edge density [default: %default]")
parser.add_option(
"-n",
"--num-runs-per-edge-density",
type="int",
default=1,
metavar="n",
help=
"number of inputs to generate for each edge density [default: %default]"
)
parser.add_option("-z",
"--zero",
action="store_true",
default=False,
help="generate zero-density (spanning tree) graphs too")
(options, args) = parser.parse_args(argv)
if len(args) < 1:
parser.error("missing NUM_VERTICES")
elif len(args) > 1:
parser.error("too many arguments")
try:
v = int(args[0])
if v <= 0:
parser.error('NUM_VERTICES must be at least 1')
except ValueError:
parser.error('NUM_VERTICES must be an integer')
di = options.density_interval
if di < 0.0 or di > 1.0:
parser.error('-d must be between 0 and 1 inclusive')
n = options.num_runs_per_edge_density
if n < 0:
parser.error('-n must be greater than or equal to 0')
d = options.max_density
if d < 0.0 or d > 1.0:
parser.error('-d must be between 0 and 1 inclusive')
extra_args = options.generate_input
while d >= 0.0:
if d == 0 and not options.zero:
break
e = get_edges_from_density(v, d)
for _ in range(n):
args = ('-n %u %s %u' % (e, extra_args, v)).split()
try:
ret = generate_input(args)
except Exception, errstr:
print >> sys.stderr, 'fan_gen failed: ' + errstr
return -1
if ret != 0:
print >> sys.stderr, 'fan_gen failed'
return -1
d -= di
import os
import re
from generate_input import generate_input
from done import solve
import time
MY_NUMS = '323'
if __name__ == '__main__':
input_lists = generate_input(MY_NUMS)
correct = 0
total = 0
for input_list in input_lists:
# convert to tuple
input_tuple = tuple(input_list)
# get result from solve
time_start = time.time() * 1000
local_result = solve(*input_tuple)
time_end = time.time() * 1000
time_dur = round(time_end - time_start, 4)
# print local result
print(f"solve{input_tuple}")
print(f" = {local_result}")
print(f" Computation took {time_dur}ms")
# ask sage what the answer should be
print(' Checking against Sage....')
stream = os.popen(
