class W_AbstractObjectWithIdentityHash(W_Object): """Object with explicit hash (ie all except small ints and floats).""" _attrs_ = ['hash'] #XXX maybe this is too extreme, but it's very random hash_generator = rrandom.Random() UNASSIGNED_HASH = sys.maxint hash = UNASSIGNED_HASH # default value def setchar(self, n0, character): raise NotImplementedError() def gethash(self): if self.hash == self.UNASSIGNED_HASH: self.hash = hash = intmask(self.hash_generator.genrand32()) // 2 return hash return self.hash def invariant(self): return isinstance(self.hash, int) def _become(self, w_other): self.hash, w_other.hash = w_other.hash, self.hash
def entry_point(argv): # Adjust the amount of work we do based on command-line arguments. # NUM_INPUTS increases the number of loop iterations. # INPUT_LENGTH increases the amount of work done per loop iteration. NUM_INPUTS = 1000 INPUT_LENGTH = 50 if len(argv) > 1: NUM_INPUTS = int(argv[1]) if len(argv) > 2: INPUT_LENGTH = int(argv[2]) if len(argv) > 3: raise RuntimeError("too many arguments") # Build up the regex pattern. # Target pattern: (a|b)*a(a|b){20}a(a|b)* # For now we use the same pattern every time, but it must be # dynamically constructed or it gets eliminated at compile-time. prefix = Sequence(Repetition(Alternative(Char("a"), Char("b"))), Char("a")) suffix = Sequence(Char("a"), Repetition(Alternative(Char("a"), Char("b")))) pattern = prefix for _ in xrange(20): pattern = Sequence(pattern, Alternative(Char("a"), Char("b"))) pattern = Sequence(pattern, suffix) # Generate "random input" to match against the pattern. # Ideally this would come from the outside world, but stdio # on pypy.js doesn't seem to work just yet. print "Generating", NUM_INPUTS, "strings of length", INPUT_LENGTH, "..." inputs = [None] * NUM_INPUTS r = rrandom.Random(42) for i in xrange(len(inputs)): s = [] for _ in xrange(INPUT_LENGTH): if r.random() > 0.5: s.append("a") else: s.append("b") inputs[i] = "".join(s) # Run each input string through the regex. # Time how long it takes for the total run. print "Matching all strings against the regex..." ts = clock() for i in xrange(len(inputs)): # No output, we just want to exercise the loop. matched = match(pattern, inputs[i]) tdiff = clock() - ts print "Done!" print "Matching time for %d strings: %f" % (len(inputs), tdiff) print "Performed %f matches per second." % (len(inputs) / tdiff,) return 0
class W_AbstractObjectWithIdentityHash(W_Object): """Object with explicit hash (ie all except small ints and floats).""" _attrs_ = ['hash'] repr_classname = "W_AbstractObjectWithIdentityHash" hash_generator = rrandom.Random() UNASSIGNED_HASH = sys.maxint hash = UNASSIGNED_HASH # default value def fillin(self, space, g_self): self.hash = g_self.get_hash() def setchar(self, n0, character): raise NotImplementedError() def gethash(self): if self.hash == self.UNASSIGNED_HASH: self.hash = hash = intmask(self.hash_generator.genrand32()) // 2 return hash return self.hash def invariant(self): return isinstance(self.hash, int) def become(self, w_other): if not self.can_become(w_other): return False if self.is_same_object(w_other): return False self._become(w_other) return True def can_become(self, w_other): # TODO -- what about become: with a Float and a CompiledMethod etc.? # We might be in trouble regarding W_LargePositiveInteger1Word, too. return self.__class__ is w_other.__class__ def _become(self, w_other): assert isinstance(w_other, W_AbstractObjectWithIdentityHash) self.hash, w_other.hash = w_other.hash, self.hash
if isnan(x): return NAN if x == INFINITY: return INFINITY if x == -INFINITY: return 0 return math.exp(x) import time from rpython.rlib import rrandom random = rrandom.Random(int(time.time())) # 15.8.2.14 @w_return def js_random(this, args): return random.random() # 15.8.1.1 E = math.e # 15.8.1.2 LN10 = math.log(10) # 15.8.1.3
def __init__(self, space, w_anything): self._rnd = rrandom.Random() self.seed(space, w_anything)
def run(n, qry): ksize = max(2, n) rg = rrandom.Random() a = [] for i in xrange(n): #b = [r_ushort(int(rg.random() * pow(2, 15) - 1)) for elem0 in xrange(32)] b = [int(rg.random() * pow(2, 15) - 1) for elem0 in xrange(32)] # b.sort() TimSort(b).sort() # a.append(b) a.append([r_ushort(elem) for elem in b]) # a.append(d) #a = [TimSort([r_ushort(int(rg.random() * pow(2, 15) - 1)) for elem0 in xrange(32)]).sort() for elem1 in xrange(n)] # print 'short add', a[0][0] + a[0][0] u = p = 0 Atmp = range(6) dna = 'atgcgc' qsort(Atmp, dna) print 'qsort', Atmp, [dna[elem] for elem in Atmp] for i in xrange(1): x = [0] * 32 y = [0] * 32 # for j in xrange(32): # x[j] = rg.random() # y[j] = rg.random() #x = [rg.random() for elem in xrange(32)] #y = [rg.random() for elem in xrange(32)] #x = [intmask(elem) for elem in [r_ushort(0)] * 32] #x = map(intmask, [0] * 32) y = [intmask(elem) for elem in xrange(32)] #rgs = range(32) #y = map(intmask, rgs) #x = y = [0] * 32 u, p = mannwhitneyu(x, y, True) p = pearson(x, y) print 'p value is', u, p print k2n('ta' * 12), intmask(int('123')) test_seq = 'tgatcgctgtagctgatgctcatgctatgctatcgtagtcgtgctagctagcatcgatcgatcgctagaaacagctgcgtatctatctatatatatattaggagaatgtgagaga' test_n = seq2n(test_seq) # for i in test_n: # print 'seq2n test', i canopy(a) print [r_uint(elem) for elem in test_n] buck = [[r_ushort(0) for elem0 in xrange(pow(scale, ksize))] for elem1 in xrange(len(qry))] f0 = open(qry, 'r') f1 = open(qry, 'r') seqs0 = parse(f0) seqs1 = parse(f1) for seq0, seq1 in izip([seqs0, seqs1]): # print seq0.seq, seq1.seq print 'test seq2n' # print [nb for nb in seq2n(seq0.seq)] kmc(seq0.seq, buck[0], ksize, scale) kmc(seq1.seq, buck[0], ksize, scale) f0.close() f1.close() print [intmask(elem) for elem in buck[0][:15]] '''
from rpython.rlib import rmmap from rpython.rlib.listsort import TimSort from rpython.rlib import listsort #from struct import pack from time import time, sleep import gc from heapq import heappush, heappop, heapreplace, heapify # define some constant number MIN = 7 #MIN = 13 MED = 23 MAX = 41 random = rrandom.Random(10).random # swap 2 selected elem in a list def swap(x, i, j): x[i], x[j] = x[j], x[i] # in-place sort def insort(x, l, r, key=lambda x: x): for i in xrange(l, r): v = x[i] pivot = key(v) j = i - 1
def init(self, seed): self.sthread = rstacklet.StackletThread() self.random = rrandom.Random(seed)
from rpython.rlib import rrandom, rarithmetic from pycket.prims.expose import default, expose, expose_val from pycket import values, values_parameter from pycket import vector as values_vector from pycket.error import SchemeException # XXX for now just always use a global rng rng = rrandom.Random() @expose("random") def random(args): if not args: # random flonum return values.W_Flonum(rng.random()) a1 = args[0] if isinstance(a1, values.W_Fixnum): upper = a1.value return values.W_Fixnum(int(rng.random() * upper)) if isinstance(a1, values.W_PseudoRandomGenerator): return values.W_Flonum(rng.random()) raise SchemeException("random: invalid arguments") @expose(["flrandom", "unsafe-flrandom"], [values.W_PseudoRandomGenerator]) def flrandom(gen): return values.W_Flonum(rng.random())
# Neil Schemenauer <*****@*****.**> # # Modifications to the original (Armin Rigo): # * import random from PyPy's lib, which is Python 2.2's plain # Python implementation # * print a doc about how to start the Translator import sys import math import time from rpython.rlib import rrandom PRINT_IT = True random = rrandom.Random(1) # calculate a random number where: a <= rand < b def rand(a, b): return (b - a) * random.random() + a # Make a matrix (we could use NumPy to speed this up) def makeMatrix(I, J, fill=0.0): m = [] for i in range(I): m.append([fill] * J) return m