def spread(count, start, end=None, step=None, mode=1):
if end is step is None:
raise TypeError('one of end or step must be given')
if not isinstance(mode, int):
raise TypeError('mode must be an int')
if count != int(count):
raise ValueError('count must be an integer')
elif count <= 0:
raise ValueError('count must be positive')
if mode & 1:
yield start
if end is None:
step = Fraction(step)
end = start + count*step
else:
step = Fraction(end-start)/count
start = Fraction(start)
for i in range(1, count):
yield float(start + i*step)
if mode & 2:
yield float(end)
python类Fraction()的实例源码
def __init__ (self, val):
assert((type(val) is int) or (isinstance(val, Fraction)) or (type(val) is float))
if (type(val) is float):
val = Fraction(val)
if (sys.version_info.major == 2):
sys.exit("Error: FPTuner is currently based on Python3 only...")
super(ConstantExpr, self).__init__(False)
elif (sys.version_info.major == 3):
super().__init__(False)
else:
sys.exit("ERROR: not supported python version: " + str(sys.version_info))
self.operands.append(val)
self.lower_bound = val
self.upper_bound = val
self.gid = -1
def concEval (self, vmap = {}):
retv = self.opd().concEval(vmap)
assert((type(retv) is int) or (type(retv) is float) or (isinstance(retv, Fraction)))
if (self.operator.label == "abs"):
return abs(retv)
elif (self.operator.label == "sqrt"):
return math.sqrt(retv)
elif (self.operator.label == "-"):
if (type(retv) is int):
return (-1 * retv)
elif ((type(retv) is float) or (isinstance(retv, Fraction))):
return (-1.0 * retv)
else:
assert(False)
else:
sys.exit("ERROR: unknwon operator found in function \"concEval\" of a UnaryExpr")
def concEval (self, vmap = {}):
retv_lhs = self.lhs().concEval(vmap)
assert((type(retv_lhs) is int) or (type(retv_lhs) is float) or (isinstance(retv_lhs, Fraction)))
retv_rhs = self.rhs().concEval(vmap)
assert((type(retv_rhs) is int) or (type(retv_rhs) is float) or (isinstance(retv_rhs, Fraction)))
if (self.operator.label == "+"):
return (retv_lhs + retv_rhs)
elif (self.operator.label == "-"):
return (retv_lhs - retv_rhs)
elif (self.operator.label == "*"):
return (retv_lhs * retv_rhs)
elif (self.operator.label == "/"):
return (retv_lhs / retv_rhs)
elif (self.operator.label == "^"):
assert(type(retv_rhs) is int)
return math.pow(retv_lhs, retv_rhs)
else:
sys.exit("ERROR: unknown operator found in function \"similar\" of a BinaryExpr")
def addVar (self, ve):
assert(isinstance(ve, tft_expr.VariableExpr))
vlabel = ve.label()
vtype = ve.type()
lb = None
if (ve.hasLB()):
lb = ve.lb().value()
ub = None
if (ve.hasUB()):
ub = ve.ub().value()
assert(vtype in [int, float, Fraction])
if (vlabel not in self.variables.keys()):
self.variables[vlabel] = [vtype, lb, ub]
else:
assert(vtype is self.variables[vlabel][0])
assert(lb is self.variables[vlabel][1])
assert(ub is self.variables[vlabel][2])
def FConst (fpn):
global CONST_ID
assert((type(fpn) is float) or (isinstance(fpn, Fraction)))
# return tft_expr.ConstantExpr(fpn)
const_value = tft_expr.ConstantExpr( fpn )
const_name = tft_expr.PRESERVED_CONST_VPREFIX + "_" + str(CONST_ID)
CONST_ID = CONST_ID + 1
return DeclareBoundedVar(const_name,
Fraction,
tft_expr.PRESERVED_CONST_GID,
const_value, const_value,
True)
# NOTE: Please don't call this function internally...
def speed_multiply(self, speed: Union[float, Fraction],
offset: Opt[int] = None):
"""
Speeds up or slows down events by grouping them together or splitting them up.
For slowdowns, event type group boundaries and isolated events are preserved.
Parameters
----------
speed
Factor to speedup or slowdown by.
Must be of the form x (speedup) or 1/x (slowdown), where x is a natural number.
Otherwise, 0 to remove all events.
offset
Offsets the grouping of events for slowdowns.
Takes a max offset of x - 1 for a slowdown of 1/x, where x is a natural number
"""
if speed == 0:
self.clear()
elif speed > 1:
self._split(speed.numerator)
elif speed < 1:
self._merge(speed.denominator, offset)
def __init__(self, file_loc,fps=30):
super().__init__()
# the approximate capture rate.
self.fps = int(fps)
self.time_base = Fraction(1000,self.fps*1000)
file_loc = str(file_loc) #force str over unicode.
try:
file_path,ext = file_loc.rsplit('.', 1)
except:
logger.error("'{}' is not a valid media file name.".format(file_loc))
raise Exception("Error")
if ext not in ('mp4'):
logger.warning("media file container should be mp4. Using a different container is risky.")
self.file_loc = file_loc
self.container = av.open(self.file_loc,'w')
logger.debug("Opened '{}' for writing.".format(self.file_loc))
self.video_stream = self.container.add_stream('mjpeg',1/self.time_base)
self.video_stream.pix_fmt = "yuvj422p"
self.configured = False
self.frame_count = 0
self.write_video_frame_compressed = self.write_video_frame
def multi_label_train_test_split(y, test_size=0.2):
"""Creates a test split with roughly the same multi-label distribution in `y`.
Args:
y: The multi-label outputs.
test_size: The test size in [0, 1]
Returns:
The train and test indices.
"""
if test_size <= 0 or test_size >= 1:
raise ValueError("`test_size` should be between 0 and 1")
# Find the smallest rational number.
frac = Fraction(test_size).limit_denominator()
test_folds, total_folds = frac.numerator, frac.denominator
logger.warn('Inferring test_size as {}/{}. Generating {} folds. The algorithm might fail if denominator is large.'
.format(test_folds, total_folds, total_folds))
folds = equal_distribution_folds(y, folds=total_folds)
test_indices = np.concatenate(folds[:test_folds])
train_indices = np.concatenate(folds[test_folds:])
return train_indices, test_indices
def lowStrainApproximation(l1,l2,ep_max=0.0001,d_start=1,d_fac=2):
"""
Find r1, r2 such that abs(0.5*(l1*r1 - l2*r2)/min(l2*r2,l1*r1)) < ep_max
"""
ep = 1.0 # strain
d = d_start
while abs(ep) > ep_max:
r1 = Fraction(l2/l1).limit_denominator(d).numerator
r2 = Fraction(l2/l1).limit_denominator(d).denominator
if r1 > d:
r2 = Fraction(l1/l2).limit_denominator(d).numerator
r1 = Fraction(l1/l2).limit_denominator(d).denominator
if r1 > d:
print (l1, l2)
raise Exception('Cannot find good approximation')
if r2 == 0 or r1 == 0:
d *= d_fac
else:
ep = 0.5*(l1*r1 - l2*r2)/min(l2*r2,l1*r1)
if abs(ep) > ep_max:
d *= d_fac
return r1, r2
def continuedFraction(numerator, denominator=None):
if denominator is None: denominator = 1
real_check(numerator, denominator); notneg_check(numerator, denominator)
x = fractions.Fraction(numerator, denominator)
a = jsfloor(x)
x -= a
cf_ = [a]
while x != 0:
x = 1 / x
a = jsfloor(x)
x -= a
cf_.append(a)
if cf_[-1] == 2: cf_[-1:] = [1, 1]
return cf_
def main():
cachePath = os.path.join(tempfile.gettempdir(), CACHEFILE)
cache = loadCache(cachePath, BASE64)
chainInfo = rpcRetrieve('getblockchaininfo')
bestHash = chainInfo['bestblockhash']
height = int(chainInfo['blocks'])
bip9forks = chainInfo['bip9_softforks']
print(formatWelcome(cache, WINDOW, bestHash, height,
F(chainInfo['difficulty']), bip9forks, THRESHOLD))
if cache.height == 0:
print('Please wait while retrieving latest block versions and caching them...\n')
if len(cache.hashes) < 1 or cache.hashes[0] != bestHash:
retrieveBlock = lambda h: rpcRetrieve('getblock', h)
cache = updateCache(cache, WINDOW, HASHES_SIZE, bestHash, height, retrieveBlock)
saveCache(cache, cachePath, BASE64)
print(formatAllData(cache, bip9forks, THRESHOLD, WINDOW))
def _json_default_exact(obj):
"""Serialization handlers for types unsupported by `simplejson`
that try to preserve the exact data types.
"""
classname = type(obj).__name__
handlers = {
'datetime': methodcaller('isoformat'),
'date': methodcaller('isoformat'),
'time': methodcaller('isoformat'),
'timedelta': partial(getattrs, attrs=['days', 'seconds', 'microseconds']),
'tuple': list,
'set': list,
'frozenset': list,
'complex': partial(getattrs, attrs=['real', 'imag']),
'Decimal': str,
'Fraction': partial(getattrs, attrs=['numerator', 'denominator']),
'UUID': partial(getattrs, attrs=['hex']),
}
if classname in handlers:
return {"__class__": classname,
"__value__": handlers[classname](obj)}
elif isinstance(obj, tuple) and classname != 'tuple':
return {"__class__": "namedtuple",
"__value__": _dump_namedtuple(classname, obj)}
raise TypeError(repr(obj) + " is not JSON serializable")
def _json_default_compat(obj):
classname = type(obj).__name__
handlers = {
'datetime': methodcaller('isoformat'),
'date': methodcaller('isoformat'),
'time': methodcaller('isoformat'),
'timedelta': _timedelta_total_seconds,
'set': list,
'frozenset': list,
'complex': partial(getattrs, attrs=['real', 'imag']),
'Fraction': partial(getattrs, attrs=['numerator', 'denominator']),
'UUID': str
}
if classname in handlers:
return handlers[classname](obj)
raise TypeError(repr(obj) + " is not JSON serializable")
def _json_object_hook(dict):
"""Deserialization handlers for types unsupported by `simplejson`.
"""
classname = dict.get('__class__')
handlers = {
'datetime': parse_datetime,
'date': lambda v: parse_datetime(v).date(),
'time': lambda v: parse_datetime(v).timetz(),
'timedelta': kwargified(timedelta),
'tuple': tuple,
'set': set,
'frozenset': frozenset,
'complex': kwargified(complex),
'Decimal': Decimal,
'Fraction': kwargified(Fraction),
'namedtuple': _load_namedtuple,
'UUID': kwargified(uuid.UUID)
}
if classname:
constructor = handlers.get(classname)
value = dict.get('__value__')
if constructor:
return constructor(value)
raise TypeError("Unknown class: '%s'" % classname)
return dict
def modified_precision(references, hypothesis, n):
# Extracts all ngrams in hypothesis
# Set an empty Counter if hypothesis is empty.
counts = Counter(ngrams(hypothesis, n)) if len(hypothesis) >= n else Counter()
# Extract a union of references' counts.
## max_counts = reduce(or_, [Counter(ngrams(ref, n)) for ref in references])
max_counts = {}
for reference in references:
reference_counts = Counter(ngrams(reference, n)) if len(reference) >= n else Counter()
for ngram in counts:
max_counts[ngram] = max(max_counts.get(ngram, 0),
reference_counts[ngram])
# Assigns the intersection between hypothesis and references' counts.
clipped_counts = {ngram: min(count, max_counts[ngram])
for ngram, count in counts.items()}
numerator = sum(clipped_counts.values())
# Ensures that denominator is minimum 1 to avoid ZeroDivisionError.
# Usually this happens when the ngram order is > len(reference).
denominator = max(1, sum(counts.values()))
return Fraction(numerator, denominator)
def testInit(self):
self.assertEqual((0, 1), _components(F()))
self.assertEqual((7, 1), _components(F(7)))
self.assertEqual((7, 3), _components(F(F(7, 3))))
self.assertEqual((-1, 1), _components(F(-1, 1)))
self.assertEqual((-1, 1), _components(F(1, -1)))
self.assertEqual((1, 1), _components(F(-2, -2)))
self.assertEqual((1, 2), _components(F(5, 10)))
self.assertEqual((7, 15), _components(F(7, 15)))
self.assertEqual((10**23, 1), _components(F(10**23)))
self.assertEqual((3, 77), _components(F(F(3, 7), 11)))
self.assertEqual((-9, 5), _components(F(2, F(-10, 9))))
self.assertEqual((2486, 2485), _components(F(F(22, 7), F(355, 113))))
self.assertRaisesMessage(ZeroDivisionError, "Fraction(12, 0)",
F, 12, 0)
self.assertRaises(TypeError, F, 1.5 + 3j)
self.assertRaises(TypeError, F, "3/2", 3)
self.assertRaises(TypeError, F, 3, 0j)
self.assertRaises(TypeError, F, 3, 1j)
def testFromDecimal(self):
self.assertRaises(TypeError, F.from_decimal, 3+4j)
self.assertEqual(F(10, 1), F.from_decimal(10))
self.assertEqual(F(0), F.from_decimal(Decimal("-0")))
self.assertEqual(F(5, 10), F.from_decimal(Decimal("0.5")))
self.assertEqual(F(5, 1000), F.from_decimal(Decimal("5e-3")))
self.assertEqual(F(5000), F.from_decimal(Decimal("5e3")))
self.assertEqual(1 - F(1, 10**30),
F.from_decimal(Decimal("0." + "9" * 30)))
self.assertRaisesMessage(
TypeError, "Cannot convert Infinity to Fraction.",
F.from_decimal, Decimal("inf"))
self.assertRaisesMessage(
TypeError, "Cannot convert -Infinity to Fraction.",
F.from_decimal, Decimal("-inf"))
self.assertRaisesMessage(
TypeError, "Cannot convert NaN to Fraction.",
F.from_decimal, Decimal("nan"))
self.assertRaisesMessage(
TypeError, "Cannot convert sNaN to Fraction.",
F.from_decimal, Decimal("snan"))
def test_accumulate(self):
self.assertEqual(list(accumulate(range(10))), # one positional arg
[0, 1, 3, 6, 10, 15, 21, 28, 36, 45])
self.assertEqual(list(accumulate(iterable=range(10))), # kw arg
[0, 1, 3, 6, 10, 15, 21, 28, 36, 45])
for typ in int, complex, Decimal, Fraction: # multiple types
self.assertEqual(
list(accumulate(map(typ, range(10)))),
list(map(typ, [0, 1, 3, 6, 10, 15, 21, 28, 36, 45])))
self.assertEqual(list(accumulate('abc')), ['a', 'ab', 'abc']) # works with non-numeric
self.assertEqual(list(accumulate([])), []) # empty iterable
self.assertEqual(list(accumulate([7])), [7]) # iterable of length one
self.assertRaises(TypeError, accumulate, range(10), 5) # too many args
self.assertRaises(TypeError, accumulate) # too few args
self.assertRaises(TypeError, accumulate, x=range(10)) # unexpected kwd arg
self.assertRaises(TypeError, list, accumulate([1, []])) # args that don't add
def testInit(self):
self.assertEqual((0, 1), _components(F()))
self.assertEqual((7, 1), _components(F(7)))
self.assertEqual((7, 3), _components(F(F(7, 3))))
self.assertEqual((-1, 1), _components(F(-1, 1)))
self.assertEqual((-1, 1), _components(F(1, -1)))
self.assertEqual((1, 1), _components(F(-2, -2)))
self.assertEqual((1, 2), _components(F(5, 10)))
self.assertEqual((7, 15), _components(F(7, 15)))
self.assertEqual((10**23, 1), _components(F(10**23)))
self.assertEqual((3, 77), _components(F(F(3, 7), 11)))
self.assertEqual((-9, 5), _components(F(2, F(-10, 9))))
self.assertEqual((2486, 2485), _components(F(F(22, 7), F(355, 113))))
self.assertRaisesMessage(ZeroDivisionError, "Fraction(12, 0)",
F, 12, 0)
self.assertRaises(TypeError, F, 1.5 + 3j)
self.assertRaises(TypeError, F, "3/2", 3)
self.assertRaises(TypeError, F, 3, 0j)
self.assertRaises(TypeError, F, 3, 1j)
def testInit(self):
self.assertEqual((0, 1), _components(F()))
self.assertEqual((7, 1), _components(F(7)))
self.assertEqual((7, 3), _components(F(F(7, 3))))
self.assertEqual((-1, 1), _components(F(-1, 1)))
self.assertEqual((-1, 1), _components(F(1, -1)))
self.assertEqual((1, 1), _components(F(-2, -2)))
self.assertEqual((1, 2), _components(F(5, 10)))
self.assertEqual((7, 15), _components(F(7, 15)))
self.assertEqual((10**23, 1), _components(F(10**23)))
self.assertEqual((3, 77), _components(F(F(3, 7), 11)))
self.assertEqual((-9, 5), _components(F(2, F(-10, 9))))
self.assertEqual((2486, 2485), _components(F(F(22, 7), F(355, 113))))
self.assertRaisesMessage(ZeroDivisionError, "Fraction(12, 0)",
F, 12, 0)
self.assertRaises(TypeError, F, 1.5 + 3j)
self.assertRaises(TypeError, F, "3/2", 3)
self.assertRaises(TypeError, F, 3, 0j)
self.assertRaises(TypeError, F, 3, 1j)
def ast_decorator_factory(ast_transformer, **kwargs):
"""
https://greentreesnakes.readthedocs.io/en/latest/examples.html
Args:
ast_transformer: a class or object that extends DecoratorAST
Returns:
a decorator that performs magic on a function
"""
@meta_wrap
def _decorator(func, *, debug=0):
return apply_ast_transform(func, ast_transformer, debug=debug, **kwargs)
return _decorator
# ---------------- Fraction interpreter -----------------
linearEquationTests.py 文件源码
项目:GeneticAlgorithmsWithPython
作者: handcraftsman
项目源码
文件源码
阅读 19
收藏 0
点赞 0
评论 0
def test_3_unknowns(self):
geneRange = [i for i in range(-5, 5) if i != 0]
geneset = [i for i in set(
Fraction(d, e)
for d in geneRange
for e in geneRange if e != 0)]
def fnGenesToInputs(genes):
return genes
def e1(genes):
x, y, z = genes
return 6 * x - 2 * y + 8 * z - 20
def e2(genes):
x, y, z = genes
return y + 8 * x * z + 1
def e3(genes):
x, y, z = genes
return 2 * z * Fraction(6, x) \
+ 3 * Fraction(y, 2) - 6
equations = [e1, e2, e3]
self.solve_unknowns(3, geneset, equations, fnGenesToInputs)
ecuacionesLineales.py 文件源码
项目:GeneticAlgorithmsWithPython
作者: handcraftsman
项目源码
文件源码
阅读 21
收藏 0
点赞 0
评论 0
def test_3_desconocidos(self):
valores = [i for i in range(-5, 5) if i != 0]
geneSet = [i for i in set(
Fraction(d, e)
for d in valores
for e in valores if e != 0)]
def fnGenesAEntradas(genes):
return genes
def e1(genes):
x, y, z = genes
return 6 * x - 2 * y + 8 * z - 20
def e2(genes):
x, y, z = genes
return y + 8 * x * z + 1
def e3(genes):
x, y, z = genes
return 2 * z * Fraction(6, x) \
+ 3 * Fraction(y, 2) - 6
ecuaciones = [e1, e2, e3]
self.resolver_desconocidos(3, geneSet, ecuaciones, fnGenesAEntradas)
def _applyActionSide1(state, act):
me, them, extra = state
if act == 'Super Potion':
me = applyHPChange(me, 50)
return {(me, them, extra): Fraction(1)}
mdata = attack_data[act]
aind = 3 if mdata.isspec else 0
dind = 3 if mdata.isspec else 1
pdiv = 64 if mdata.crit else 512
dmg_dist = getCritDist(me.fixed.lvl, Fraction(me.fixed.basespeed, pdiv),
me.stats[aind], me.fixed.stats[aind], them.stats[
dind], them.fixed.stats[dind],
mdata.power, mdata.stab, mdata.te)
dist = defaultdict(Fraction)
for dmg, p in dmg_dist.items():
them2 = applyHPChange(them, -dmg)
dist[me, them2, extra] += p
return dist
def _getSuccessorsB(self, statep):
st, state, action = statep
dist = defaultdict(Fraction)
for eact, p in [('Water Gun', Fraction(64, 130)),
('Bubblebeam', Fraction(66, 130))]:
priority1 = state[0].stats.speed + \
10000 * (action == 'Super Potion')
priority2 = state[1].stats.speed + 10000 * (action == 'X Defend')
if priority1 > priority2:
self._applyActionPair(state, 0, action, 1, eact, dist, p)
elif priority1 < priority2:
self._applyActionPair(state, 1, eact, 0, action, dist, p)
else:
self._applyActionPair(state, 0, action, 1, eact, dist, p / 2)
self._applyActionPair(state, 1, eact, 0, action, dist, p / 2)
return {k: float(p) for k, p in dist.items() if p > 0}
def testInit(self):
self.assertEqual((0, 1), _components(F()))
self.assertEqual((7, 1), _components(F(7)))
self.assertEqual((7, 3), _components(F(F(7, 3))))
self.assertEqual((-1, 1), _components(F(-1, 1)))
self.assertEqual((-1, 1), _components(F(1, -1)))
self.assertEqual((1, 1), _components(F(-2, -2)))
self.assertEqual((1, 2), _components(F(5, 10)))
self.assertEqual((7, 15), _components(F(7, 15)))
self.assertEqual((10**23, 1), _components(F(10**23)))
self.assertEqual((3, 77), _components(F(F(3, 7), 11)))
self.assertEqual((-9, 5), _components(F(2, F(-10, 9))))
self.assertEqual((2486, 2485), _components(F(F(22, 7), F(355, 113))))
self.assertRaisesMessage(ZeroDivisionError, "Fraction(12, 0)",
F, 12, 0)
self.assertRaises(TypeError, F, 1.5 + 3j)
self.assertRaises(TypeError, F, "3/2", 3)
self.assertRaises(TypeError, F, 3, 0j)
self.assertRaises(TypeError, F, 3, 1j)
def test_copyConstruct(self):
s1 = StorageGenome()
s1.inputs['uiae'] = 1
s1.inputs['eaiu'] = 2
s1.outputs['nrtd'] = 3
s1.outputs['dtrn'] = 4
s1.genes[2] = (True, float(Fraction(15, 11)))
s1.genes[5] = (True, float(Fraction(135, 9)))
s1.genes[12] = (True, float(Fraction(17, 81)))
s1.analysis_result.topologically_sorted_nodes = [1, 5, 7, 2, 3, 8]
s1.analysis_result.topologically_sorted_cycle_nodes = [3, 2, 8, 1]
s1.analysis_result.gene_closes_cycle_map[5] = True
s2 = StorageGenome(s1)
self.assertNotEqual(s1, s2)
self.assertNotEqual(s1._id, s2._id)
self.assertDictEqual(s1.inputs, s2.inputs)
self.assertDictEqual(s1.outputs, s2.outputs)
self.assertDictEqual(s1.genes, s2.genes)
self.assertEqual(s1.cluster, s2.cluster)
self.assertEqual(s1.analysis_result, s2.analysis_result)
self.assertNotEqual(s1.__repr__(), s2.__repr__())
def __init__(self, platform, clk_freq):
self.clock_domains.cd_sys = ClockDomain()
f0 = 32*1000000
clk32 = platform.request("clk32")
clk32a = Signal()
self.specials += Instance("IBUFG", i_I=clk32, o_O=clk32a)
clk32b = Signal()
self.specials += Instance("BUFIO2", p_DIVIDE=1,
p_DIVIDE_BYPASS="TRUE", p_I_INVERT="FALSE",
i_I=clk32a, o_DIVCLK=clk32b)
f = Fraction(int(clk_freq), int(f0))
n, m, p = f.denominator, f.numerator, 16
assert f0/n*m == clk_freq
pll_lckd = Signal()
pll_fb = Signal()
pll = Signal(6)
self.specials.pll = Instance("PLL_ADV", p_SIM_DEVICE="SPARTAN6",
p_BANDWIDTH="OPTIMIZED", p_COMPENSATION="INTERNAL",
p_REF_JITTER=.01, p_CLK_FEEDBACK="CLKFBOUT",
i_DADDR=0, i_DCLK=0, i_DEN=0, i_DI=0, i_DWE=0, i_RST=0, i_REL=0,
p_DIVCLK_DIVIDE=1, p_CLKFBOUT_MULT=m*p//n, p_CLKFBOUT_PHASE=0.,
i_CLKIN1=clk32b, i_CLKIN2=0, i_CLKINSEL=1,
p_CLKIN1_PERIOD=1000000000/f0, p_CLKIN2_PERIOD=0.,
i_CLKFBIN=pll_fb, o_CLKFBOUT=pll_fb, o_LOCKED=pll_lckd,
o_CLKOUT0=pll[0], p_CLKOUT0_DUTY_CYCLE=.5,
o_CLKOUT1=pll[1], p_CLKOUT1_DUTY_CYCLE=.5,
o_CLKOUT2=pll[2], p_CLKOUT2_DUTY_CYCLE=.5,
o_CLKOUT3=pll[3], p_CLKOUT3_DUTY_CYCLE=.5,
o_CLKOUT4=pll[4], p_CLKOUT4_DUTY_CYCLE=.5,
o_CLKOUT5=pll[5], p_CLKOUT5_DUTY_CYCLE=.5,
p_CLKOUT0_PHASE=0., p_CLKOUT0_DIVIDE=p//1, # sys
p_CLKOUT1_PHASE=0., p_CLKOUT1_DIVIDE=p//1,
p_CLKOUT2_PHASE=0., p_CLKOUT2_DIVIDE=p//1,
p_CLKOUT3_PHASE=0., p_CLKOUT3_DIVIDE=p//1,
p_CLKOUT4_PHASE=0., p_CLKOUT4_DIVIDE=p//1,
p_CLKOUT5_PHASE=0., p_CLKOUT5_DIVIDE=p//1,
)
self.specials += Instance("BUFG", i_I=pll[0], o_O=self.cd_sys.clk)
self.specials += AsyncResetSynchronizer(self.cd_sys, ~pll_lckd)
def test_rational(self):
def to_om_rat(obj):
return om.OMApplication(om.OMSymbol('rational', cd='nums1'),
map(to_openmath, [obj.numerator, obj.denominator]))
def to_py_rat(obj):
return Fraction(to_python(obj.arguments[0]), to_python(obj.arguments[1]))
register(Fraction, to_om_rat, 'nums1', 'rational', to_py_rat)
a = Fraction(10, 12)
self.assertEqual(a, to_python(to_openmath(a)))