diff --git a/A1/execute-reservation.sh b/A1/execute-reservation.sh old mode 100644 new mode 100755 index 4675ba1..d83284d --- a/A1/execute-reservation.sh +++ b/A1/execute-reservation.sh @@ -1,15 +1,40 @@ #!/bin/bash #SBATCH --chdir /scratch/ancarola #SBATCH --nodes 1 #SBATCH --ntasks 1 #SBATCH --cpus-per-task 28 #SBATCH --mem 1G #SBATCH --partition serial #SBATCH --account cs307 #SBATCH --reservation CS307-ex echo STARTING AT `date` -./pi 28 100000000 +mkdir -p graphs + +outpi="graphs/outpi.dat" +outint="graphs/outint.dat" # integral output + +Ntr="1 2 4 8 16 32 48 64" +Nsamples=100000000 +a=0 +b=1 + +rm -f $outpi +rm -f $outint + +echo "N PI T" | tee $outpi + +for ntr in $Ntr; do + ./pi $ntr $Nsamples -t | tee -a $outpi +done + +echo "" + +echo "N a b INT T" | tee $outint + +for ntr in $Ntr; do + ./integral $ntr $Nsamples $a $b -t | tee -a $outint +done echo FINISHED at `date` diff --git a/A1/execute.sh b/A1/execute.sh index c447fa0..1dbb1cc 100755 --- a/A1/execute.sh +++ b/A1/execute.sh @@ -1,11 +1,36 @@ #!/bin/bash #SBATCH --nodes 1 #SBATCH --ntasks 1 #SBATCH --cpus-per-task 28 #SBATCH --mem 1G echo STARTING AT `date` -./pi 1 1000000 +mkdir -p graphs + +outpi="graphs/outpi.dat" +outint="graphs/outint.dat" # integral output + +Ntr="1 2 4 8 16 32 48 64" +Nsamples=100000000 +a=0 +b=1 + +rm -f $outpi +rm -f $outint + +echo "N PI T" | tee $outpi + +for ntr in $Ntr; do + ./pi $ntr $Nsamples -t | tee -a $outpi +done + +echo "" + +echo "N a b INT T" | tee $outint + +for ntr in $Ntr; do + ./integral $ntr $Nsamples $a $b -t | tee -a $outint +done echo FINISHED at `date` diff --git a/A1/execute_tasks-reservation.sh b/A1/execute_tasks-reservation.sh deleted file mode 100755 index c06f7e8..0000000 --- a/A1/execute_tasks-reservation.sh +++ /dev/null @@ -1,38 +0,0 @@ -#!/bin/bash -#SBATCH --chdir /scratch/ancarola -#SBATCH --nodes 1 -#SBATCH --ntasks 1 -#SBATCH --cpus-per-task 28 -#SBATCH --mem 1G -#SBATCH --partition serial -#SBATCH --account cs307 -#SBATCH --reservation CS307-ex - -echo STARTING AT `date` - -outpi="graphs/outpi.dat" -outint="graphs/outint.dat" # integral output - -Ntr="1 2 4 8 16 32 48 64" -Nsamples=100000000 -a=0 -b=1 - -rm -f $outpi -rm -f $outint - -echo "N PI T" | tee $outpi - -for ntr in $Ntr; do - ./pi $ntr $Nsamples -t | tee -a $outpi -done - -echo "" - -echo "N a b INT T" | tee $outint - -for ntr in $Ntr; do - ./integral $ntr $Nsamples $a $b -t | tee -a $outint -done - -echo FINISHED at `date` diff --git a/A1/execute_tasks.sh b/A1/execute_tasks.sh deleted file mode 100755 index 6276f26..0000000 --- a/A1/execute_tasks.sh +++ /dev/null @@ -1,34 +0,0 @@ -#!/bin/bash -#SBATCH --nodes 1 -#SBATCH --ntasks 1 -#SBATCH --cpus-per-task 28 -#SBATCH --mem 1G - -echo STARTING AT `date` - -outpi="graphs/outpi.dat" -outint="graphs/outint.dat" # integral output - -Ntr="1 2 4 8 16 32 48 64" -Nsamples=100000000 -a=0 -b=1 - -rm -f $outpi -rm -f $outint - -echo "N PI T" | tee $outpi - -for ntr in $Ntr; do - ./pi $ntr $Nsamples -t | tee $outpi -done - -echo "" - -echo "N a b INT T" | tee $outint - -for ntr in $Ntr; do - ./integral $ntr $Nsamples $a $b -t | tee $outint -done - -echo FINISHED at `date` diff --git a/A1/function.o b/A1/function.o deleted file mode 100644 index 4759f5b..0000000 Binary files a/A1/function.o and /dev/null differ diff --git a/A1/graphs/gengraphs.py b/A1/graphs/gengraphs.py index 0483ef2..ac44c84 100755 --- a/A1/graphs/gengraphs.py +++ b/A1/graphs/gengraphs.py @@ -1,74 +1,91 @@ #!/usr/bin/python import matplotlib.pyplot as plt import numpy as np from numpy import array import tikzplotlib N = 100000000 -beta = 60000 +beta = 50000 plt.style.use("ggplot") # 20 -> 0.95 # 30 -> 0.966666 # 50 -> 0.98 def speedup(n): p = 1.0 / (1 + (beta * (n-1)) / float(N)) return 1.0 / (1 - p + p / n) x = array([1, 2, 4, 8, 16, 32, 48, 64]) y = speedup(x) def speedup_T(Tref, T): return Tref / T -Tpi = [2.13, - 1.067, - 0.5361, - 0.2671, - 0.1532, - 0.1204, - 0.1201, - 0.09796] - -Tint = [1.061, - 0.5319, - 0.2659, - 0.1367, - 0.06818, - 0.06445, - 0.06495, - 0.06226] +# load data + +def loadvalue(line): + values = line.split(' ') # split into string set + values = [i for i in values if i != ''] # fliter null strings + pyarr = [] + for v in values: + pyarr.append(float(v)) + return (np.mean(pyarr), np.var(pyarr)) + +Tpi = [] +Tpiv = [] + +timespi = open("timespi") +for line in timespi: + (t,v) = loadvalue(line) + Tpi.append(t) + Tpiv.append(v) +timespi.close() + +Tint = [] +Tintv = [] + +timesint = open("timesint") +for line in timesint: + (t,v) = loadvalue(line) + Tint.append(t) + Tintv.append(v) +timesint.close() # good data #Tpi = array([2.131, 1.067, 0.5339, 0.2673, 0.1362, 0.1051, 0.1083, 0.1089]) #Tint = array([1.064, 0.5328, 0.2672, 0.1333, 0.06728, 0.06198, 0.05691, 0.05873]) Tpi = array(Tpi) Tint = array(Tint) Trefpi = Tpi[0] Trefint = Tint[0] Spi = speedup_T(Trefpi, Tpi) Sint = speedup_T(Trefint, Tint) fout = open("speedup.dat", "w") print("N Sth Spi Sint", file=fout) for (n, theor, spi, sint) in zip(x, y, Spi, Sint): print("%d %g %g %g" % (n, theor, spi, sint), file=fout) fout.close() +print("Times") +for (n, tpi, tpiv, tint, tintv) in zip(x, Tpi, Tpiv, Tint, Tintv): + print("%d $%.3g \pm %.3g$ $%.3g \pm %.3g$ " % (n, tpi, tpiv**0.5, tint, tintv**0.5)) + + plt.plot(x, y, 'o-', lw = 4.0, label='theor') plt.plot(x, Spi, 'o-', lw = 4.0, label='pi') plt.plot(x, Sint, 'o-', lw = 4.0, label='integral') plt.xlabel('Number of threads $n_{tr}$') plt.ylabel('Speed-up $S$') plt.grid(True) #plt.savefig('exectime.pgf', format='pgf') #tikzplotlib.save("theor_speedup.tex") plt.show() diff --git a/A1/graphs/measure.py b/A1/graphs/measure.py deleted file mode 100644 index 350ea23..0000000 --- a/A1/graphs/measure.py +++ /dev/null @@ -1,677 +0,0 @@ -import math -import numpy -import statistics -import scipy -import scipy.optimize - -def error_variance(*errs): - if len(errs) == 1: - return math.fabs(*errs) - - out = 0 - for err in errs: - out += err**2 - - return math.sqrt(out) - -def error_abs(*errs): - out = 0 - for err in errs: - out += math.fabs(err) - return out - -class Measure: - def __init__(self, v, e = 0.0, sig_digit = 3, **args): - self.v = float(v) - self.e = math.fabs(float(e)) - self.sig_digit = sig_digit - self.scient = False - - # format - if "format" in args: - self.format = args["format"] # !!! no control - elif "scient" in args and \ - isinstance(args["scient"], bool) and \ - args["scient"]: - self.scient = True - self.format = "%%.%d%s" % (sig_digit, 'e') - else: - self.format = "%%.%d%s" % (sig_digit, 'g') - - # std deviation, !! no control - self.errop = error_variance - if "stddev" in args: - self.errop = args["stddev"] - - def __str__(self): - return ("%s +- %s" % (self.format, self.format)) % (self.v, self.e) - - def __tuple__(self): - return (self.v, self.e) - - def __iadd__(self, m): - if isinstance(m, Measure): - self.v += m.v - self.e = self.errop(self.e, m.e) - else: - self.v += m - - return self - - def __isub__(self, m): - if isinstance(m, Measure): - self.v -= m.v - self.e = self.errop(self.e, m.e) - else: - self.v -= m - return self - - def __imul__(self, m): - if isinstance(m, Measure): - self.e = self.errop(self.v * m.e, self.e * m.v) - self.v *= m.v - else: - self.v *= m - self.e = self.errop(self.e * m) - - return self - - def __itruediv__(self, m): - if isinstance(m, Measure): - self.e = self.errop(self.e / m.v, self.v * m.e / m.v**2) - self.v /= m.v - else: - self.v /= m - self.e = self.errop(self.e / m) - - return self - - def __radd__(self, k): - return Measure(self.v + k, self.e, self.sig_digit, format = self.format) - - def __rsub__(self, k): - return Measure(k - self.v, self.e, self.sig_digit, format = self.format) - - def __rmul__(self, k): - return Measure(self.v * k, self.errop(self.e * k), self.sig_digit, format = self.format) - - def __rtruediv__(self, k): - return Measure(k / self.v, self.errop(k * self.e / self.v**2), self.sig_digit, format = self.format) - - def __add__(self, m): - if not isinstance(m, Measure): - return self.__radd__(m) - - return Measure(self.v + m.v, self.errop(self.e, m.e), min(self.sig_digit, m.sig_digit), scient = self.scient) - - def __sub__(self, m): - if not isinstance(m, Measure): - return Measure(self.v - m, self.e, self.sig_digit, scient = self.scient) - - return Measure(self.v - m.v, self.errop(self.e, m.e), min(self.sig_digit, m.sig_digit), scient = self.scient) - - def __mul__(self, m): - if not isinstance(m, Measure): - return self.__rmul__(m) - - return Measure(self.v * m.v, self.errop(self.v * m.e, self.e * m.v), min(self.sig_digit, m.sig_digit), scient = self.scient) - - def __truediv__(self, m): - if not isinstance(m, Measure): - return Measure(self.v / m, self.errop(self.e / m), self.sig_digit, scient = self.scient) - - return Measure(self.v / m.v, self.errop(self.e / m.v, self.v * m.e / m.v**2), min(self.sig_digit, m.sig_digit), scient = self.scient) - - def __pow__(self, r): - if not isinstance(r, int) and not isinstance(r, float): - raise TypeError("Measure: pow is only for int or float args") - - err = r * self.v**(r-1) * self.e - return Measure(self.v**r, self.errop(err), self.sig_digit, scient = self.scient) - - def __neg__(self): - return Measure(-self.v, self.e, self.sig_digit, scient = self.scient) - - def __eq__(self, m): - if isinstance(m, Measure): - return m.v == self.v and m.e == self.e - return self.v == m - - def __ne__(self, m): - if isinstance(m, Measure): - return m.v != self.v or m.e != self.e - return self.v != m - - - def __lt__(self, m): - if isinstance(m, Measure): - return self.v < m.v - return self.v < m - - def __le__(self, m): - if isinstance(m, Measure): - return self.v <= m.v - return self.v <= m - - def __gt__(self, m): - if isinstance(m, Measure): - return self.v > m.v - return self.v > m - - def __ge__(self, m): - if isinstance(m, Measure): - return self.v >= m.v - return self.v >= m - - def square(self): - return Measure(self.v**2, self.errop(2 * self.v * self.e), self.sig_digit, scient = self.scient) - - def sqrt(self): - return Measure(math.sqrt(self.v), self.e / (2 * math.sqrt(self.v)), self.sig_digit, scient = self.scient) - - def abs(self): - return Measure(math.fabs(self.v), self.e, self.sig_digit, scient = self.scient) - - def exp(self): - ex = math.exp(self.v) - return Measure(ex, self.errop(ex * self.e), self.sig_digit, scient = self.scient) - - def log(self): - return Measure(math.log(self.v), self.errop(self.e / self.v), self.sig_digit, scient = self.scient) - - def sin(self): - return Measure(math.sin(self.v), self.errop(math.cos(self.v) * self.e), self.sig_digit, scient = self.scient) - - def cos(self): - return Measure(math.cos(self.v), self.errop(math.sin(self.v) * self.e), self.sig_digit, scient = self.scient) - - def __float__(self): - return self.v - - def extr(self, coeff = 1.0): - return (self.v - self.e * coeff, self.v + self.e * coeff) - -# -# List wrapper -# - -class Array: - def __init__(self, arglist): - self.list = arglist - - def __getitem__(self, index): - return self.list[index] - - def append(self, obj): - self.list.append(obj) - -# -# Utils -# - -# print a line into stream -def print_line(stream, *measures, **kargs): - M = [] - for m in measures: - M.extend((m.format % m.v, m.format % m.e)) - - print(*M, file=stream, sep=" ", end="\n") - -# give list of proper max and min, see Measure.extr -def extremums(measures, coeff = 1.0): - down = [] - up = [] - - for m in measures: - e = m.extr(coeff) - down.append(e[0]) - up.append(e[1]) - - return (tuple(up), tuple(down)) - -def values(measures): - v = [] - for m in measures: - v.append(m.v) - - return tuple(v) - -# generate a list of measures -def genMeasures(values, error, sig_digit = 3): - out = [] - - for value in values: - out.append(Measure(value, error, sig_digit)) - - return out - -# generate a measure basing on min and max -def minMaxMeasure(m, M): - return Measure((float(M) + float(m))/2, (float(M) - float(m))/2) - -# return the maximal error -def maxError(measures): - M = 0 - for m in measures: - if (m.e > M): - M = m.e - return M - - -# TODO, don't remember -def computeRange(y, Y, x, X): - dy = Y - y - dx = (X - x).v - rm = (dy.v-dy.e)/dx - rp = (dy.v+dy.e)/dx - return ( (rm, Y.v - Y.e - rm * x.v), (rp, Y.v + Y.e - rp * x.v) ) - -# -# analysis instruments -# - -def polyfit(X, Y, deg = 1, **args): - - coeff = 1 - if "coeff" in args: - coeff = args["coeff"] - del args["coeff"] - - sig_digit = 8 - if "sig_digit" in args and isinstance(args["sig_digit"], int): - sig_digit = args["sig_digit"] - del args["sig_digit"] - - extX = extremums(X, coeff) - extY = extremums(Y, coeff) - - res = [None] * 4 - - # x down, y down - res[0] = numpy.polyfit(extX[0], extY[0], deg) - # x down, y up - res[1] = numpy.polyfit(extX[0], extY[1], deg) - # x up, y down - res[2] = numpy.polyfit(extX[1], extY[0], deg) - # x up, y up - res[3] = numpy.polyfit(extX[1], extY[1], deg) - - (centered, cov) = (None, None) - - try: - (centered, cov) = numpy.polyfit(values(X), values(Y), deg, None, False, None, True) - except: - centered = numpy.polyfit(values(X), values(Y), deg) - - # compute the nearest coefficients - coeff = [] - for i in range(deg + 1): - sample = (res[0][i], res[1][i], res[2][i], res[3][i]) - stddev = statistics.variance(sample) - if cov is not None: - stddev += cov[i, i] - coeff.append(Measure( \ - centered[i], \ - math.sqrt(stddev), \ - sig_digit \ - )) - - return coeff - -# fit a set of data -# basing on a general expression -# expr = expr(x, ...) -# where ... stands for the set of coefficients to deduce -def fit(X, Y, expr, p0 = None, **args): - - coeff = 1 - if "coeff" in args: - coeff = args["coeff"] - del args["coeff"] - - sig_digit = 8 - if "sig_digit" in args and isinstance(args["sig_digit"], int): - sig_digit = args["sig_digit"] - del args["sig_digit"] - - extX = extremums(X, coeff) - extY = extremums(Y, coeff) - - res = [None] * 4 - - # x down, y down - res[0] = scipy.optimize.curve_fit(expr, extX[0], extY[0], p0, **args)[0] - # x down, y up - res[1] = scipy.optimize.curve_fit(expr, extX[0], extY[1], p0, **args)[0] - # x up, y down - res[2] = scipy.optimize.curve_fit(expr, extX[1], extY[0], p0, **args)[0] - # x up, y up - res[3] = scipy.optimize.curve_fit(expr, extX[1], extY[1], p0, **args)[0] - # centered solution - centered, cov = scipy.optimize.curve_fit(expr, values(X), values(Y), p0, **args) - - # compute the nearest coefficients - coeff = [] - for i in range(len(res[0])): - sample = (res[0][i], res[1][i], res[2][i], res[3][i], centered[i]) - coeff.append(Measure( \ - centered[i], \ - math.sqrt(statistics.variance(sample) + cov[i,i]), \ - sig_digit \ - )) - - return coeff - -""" -def fit(X, Y, expr, p0 = None): - _X = values(X) - _Y = values(Y) - (res, pcov) = scipy.optimize.curve_fit(expr, _X, _Y, p0) - var = maxError(X)**2 + + maxError(Y)**2 - - out = [] - - for i in range(len(res)): - out.append(Measure(res[i], \ - #math.sqrt(pcov[i][i] + var), \ - math.sqrt(var), \ - 8)) - - return out -""" - - -def rawfit(X, Y, expr, p0 = None): - res = scipy.optimize.curve_fit(expr, X, Y, p0)[0] - return genMeasures(res, 0, 8) - -# -# file loading helpers -# - -def splitline(line, sep): - out = (line[:-1]).split(sep) - flag = False - while(not flag): - i = 0 - flag = False - while(i < len(out)): - if (out[i] == ''): - del out[i] - flag = True - else: - i += 1 - - return out - -class Visit: - def __init__(self, visitmap): - self.visitmap = visitmap - - if callable in visitmap: - self.callable = True - - def __call__(self, entry, *args, **kargs): - if (type(entry) in self.visitmap) : - return self.visitmap[type(entry)](entry, *args, **kargs) - elif self.callable and callable(entry): - return self.visitmap[callable](entry, *args, **kargs) - -class Line: - def __init__(self, line, sep): - # store original line - self.rawline = line - - # split line - self.splitted = splitline(line, sep) - - def __getitem__(self, index): - try: - return self.splitted[index] - except: - print("Error") - print("Involved line:", self.rawline) - print("Index out of bound:", index, ", Size of container:", len(self.splitted)) - return None; - - def is_comment(self): - return self.rawline == "" or (len(self.splitted) == 0) or self.rawline.startswith('#') - - def parse(self, columns, col_visit, uncertainty, unc_visit, sigdigit, sigd_visit, transform, transf_visit): - buff = [] - for index in range(len(columns)): - m = Measure(col_visit(columns, self, index), unc_visit(uncertainty, self, index), sigd_visit(sigdigit, index)) - if transform is not None: - m = transf_visit(m) - buff.append(m) - return buff - -class FirstLine(Line): - def __init__(self, line, sep): - Line.__init__(self, line, sep) - # verify whether the elements are all indexes or not - self.all_indexes = True - for elem in self.splitted: - try: - elem = float(elem) # try to convert to float - except: - pass # nothing happens - finally: - self.all_indexes = False - - def indicise(self, keylist): - for i in range(len(keylist)): - key = keylist[i] - if isinstance(key, str): - if key in self.splitted: - keylist[i] = self.splitted.index(key) - else: - raise Exception("Invalid argument: no key was found to match the input line to match", key) - elif isinstance(key, int): - pass - else: - keylist[i] = int(key) # try to convert it to an integer index - return keylist - -# -# Load a specified columns -# filename: input file name which you load the data -# *columns: name or index of the column containing the data to be loaded (!! indexes start from 0) -# **kargs: -# - uncertainty = -# - str: column which contains the uncertainty -# - float/int: constant uncertainty -# - tuple/list: apply the incertainty to the corresponding column in order of passed argument depending on the elements' type -# - transform = apply a functor once the data are loaded -# - functor: apply to all data -# - tuple/list: apply the functor to the corresponding column in order of passed argument (!! the array size must correspond, theelements must be functors) -# - sigdigit = significant digit needed to construct a Measure once the data are loaded -# - int: apply to all data -# - tuple/list: apply the significant digits to the corresponding column in order of passed argument (!! the array size must correspond, elements must be integers) -# - verbose = say everything is happening loading values (!! it must be convertible to a boolean) -# - sep = column separator character (!! it must be convertible to char) -# - -def loadMeasures(filename, *columns, **kargs): - - if len(columns) == 0: - raise Exception("Invalid argument: entering an empty column set") - - # initialize column visitor - col_visit = Visit({ int : lambda data, line, index: line[data], \ - list : lambda data, line, index: line[data[index]], \ - tuple : lambda data, line, index: line[data[index]] }) - - # determine uncertainty - uncertainty = 0.0 - if "uncertainty" in kargs: - uncertainty = kargs["uncertainty"] - - unc_visit = Visit({int : lambda data, line, index: line[data], \ - float : lambda data, line, index: data, \ - list : lambda data, line, index: line[data[index]], \ - tuple : lambda data, line, index: line[data[index]] }) - - # determine transform - transform = None # identity transformation - if "transform" in kargs: - transform = kargs["transform"] - - transf_visit = Visit({callable : lambda T, m, index: T(m), \ - list : lambda T, m, index: T[index](m), \ - tuple : lambda T, m, index: T[index](m) }) - - # determine significant digits - sigdigit = 3 - if "sigdigit" in kargs: - sigdigit = kargs["sigdigit"] - - sigd_visit = Visit({ int : lambda value, index: value, \ - list : lambda value, index: int(value[index]), \ - tuple : lambda value, index: int(value[index]) }) - - # enable/disable verbose mode - verbose = False - if "verbose" in kargs: - verbose = bool(kargs["verbose"]) - - # determine column separator character - sep = ' ' - if "sep" in kargs: - sep = str(kargs["sep"]) - - if verbose: - print("Opening file:", filename) - - # open file - f = open(filename, 'r') - - # skip first comment lines - firstline = FirstLine(f.readline(), sep) - while firstline.is_comment(): - firstline = FirstLine(f.readline(), sep) # get next line - - if verbose: - print("Processing first line:", firstline.rawline) - - # indicise inputs - columns = firstline.indicise(list(columns)) - - if verbose: - print("Reading columns:", columns) - - if len(columns) < 2: - columns = columns[0] - - if isinstance(uncertainty, list) or isinstance(uncertainty, tuple): - if len(uncertainty) != len(columns): - raise Exception("Invalid argument uncertainty: columns and uncertainty lists must correspond in size") - else: - uncertainty = firstline.indicise(list(uncertainty)) - - # create output list - out = [] - for i in range(len(columns)): - out.append([]) - - for rawline in f: - - if verbose: - print("Loading line:", rawline) - - line = Line(rawline, sep) - - if line.is_comment(): - continue # ignore - - buff = line.parse(columns, col_visit, uncertainty, unc_visit, sigdigit, sigd_visit, transform, transf_visit) - for i in range(len(buff)): - out[i].append(buff[i]) - - f.close() - - return tuple(out) - - -def _loadMeasures(filename, values, errors = 0.0, gain = 1.0, offset = 0.0, verbose = False, **args): - - f = open(filename, 'r') - - sig_digit = 3 - if "sig_digit" in args and isinstance(args["sig_digit"], int): - sig_digit = int(args["sig_digit"]) - del args["sig_digit"] - - firstline = None - if isinstance(values, str): - firstline = splitline(f.readline()) - values = firstline.index(values) - - errStr = False - - if isinstance(errors, str): - if firstline is None: - firstline = splitline(f.readline()) - errors = firstline.index(errors) - errStr = True - - gainStr = False - - if isinstance(gain, str): - if firstline is None: - firstline = splitline(f.readline()) - gain = firstline.index(gain) - gainStr = True - - offStr = False - - if isinstance(offset, str): - if firstline is None: - firstline = splitline(f.readline()) - offset = firstline.index(offset) - offStr = True - - out = [] - - if verbose: - print("File %s: loading columns (%d, %d)" % (filename, values, errors)) - - for line in f: - l = splitline(line) - - if line.startswith('#'): - continue # ignore - - try: - # evaluate error - err = 0 - if (errStr): - err = float(l[errors]) - else: - err = errors - - # evaluate gain scaling - g = 1.0 - if (gainStr): - g = float(l[gain]) - else: - g = gain - - # evaluate offset - off = 1.0 - if (offStr): - off = float(l[offset]) - else: - off = offset - - if values < len(l): - out.append(Measure(l[values], err, sig_digit, **args) * g + off) - - except ValueError: - print("Could not parse line", line, "Ignoring it") - - f.close() - - return out - - diff --git a/A1/graphs/speedup.dat b/A1/graphs/speedup.dat index 2a30c5b..c61b217 100644 --- a/A1/graphs/speedup.dat +++ b/A1/graphs/speedup.dat @@ -1,9 +1,9 @@ N Sth Spi Sint 1 1 1 1 -2 1.9988 1.99625 1.99474 -4 3.97855 3.97314 3.99022 -8 7.77245 7.97454 7.76152 -16 14.1119 13.9034 15.5617 -32 20.4333 17.691 16.4624 -48 20.9694 17.7352 16.3356 -64 19.4254 21.7436 17.0414 +2 1.999 1.96918 1.99839 +4 3.98211 4.00415 3.98269 +8 7.80934 7.99782 7.94212 +16 14.3929 15.6962 15.7183 +32 21.7219 18.8279 17.5911 +48 23.0865 20.7175 18.0524 +64 21.8886 20.3829 19.2437 diff --git a/A1/integral b/A1/integral deleted file mode 100755 index 766d0ca..0000000 Binary files a/A1/integral and /dev/null differ diff --git a/A1/pi b/A1/pi deleted file mode 100755 index a205e0b..0000000 Binary files a/A1/pi and /dev/null differ diff --git a/A1/test b/A1/test deleted file mode 100755 index 915bee1..0000000 Binary files a/A1/test and /dev/null differ