def test_recursive(self):
inp = list('abc')
out = [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3'], ['c1', 'c2', 'c3']]
self.assertEqual(
out,
accumulate(inp,
lambda x: accumulate(list('123'), lambda y: x + y)))
def test_recursive(self):
inp = ['a', 'b', 'c']
out = [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3'], ['c1', 'c2', 'c3']]
self.assertEqual(
accumulate(inp,
lambda x: accumulate(list('123'), lambda y: x + y)),
out)
def RealApply(self, x, y):
with tm.TimeMonitor("Destriping Local Operations"):
sig = np.repeat(x.array[0], self.BaselineLengths)
self.tmap_local[:]=0
with tm.TimeMonitor("Destriping Comm Operations"):
bin_map(self.pix, sig, self.tmap_local, self.tmap_glob, self.hits_glob, self.comm, broadcast_locally=True)
with tm.TimeMonitor("Destriping Local Operations"):
signalremoveti(sig, self.tmap_local.array, self.pix)
accumulate(sig, self.BaselineLengths, y.array[0])
return 0
def RealApply(self, x, y):
# baseline to tod
sig = {}
with tm.TimeMonitor("Destriping Local Operations"):
sig['Q'] = np.repeat(x.array[0][:self.NumBaselines], self.BaselineLengths)
sig['U'] = np.repeat(x.array[0][self.NumBaselines:], self.BaselineLengths)
self.SignalRemove(sig)
# tod to baseline
with tm.TimeMonitor("Destriping Local Operations"):
accumulate(sig['Q'], self.BaselineLengths, y.array[0][:self.NumBaselines])
accumulate(sig['U'], self.BaselineLengths, y.array[0][self.NumBaselines:])
return 0
def __call__(self, seq, init=None, func=None):
if init: self.init = init
def bi_op(a, b):
if func:
return self.bi_op(a, b, f=func)
else:
return self.bi_op(a, b)
if self.save_state:
self.init = accumulate(bi_op, self.init, seq)
return self.init
else:
return accumulate(bi_op, self.init, seq)
def test_composition(self):
inp = [10, 17, 23]
self.assertEqual(
inp,
accumulate(accumulate(inp, lambda x: divmod(x, 7)),
lambda x: 7 * x[0] + x[1]))
def test_pow(self):
self.assertEqual([1, 4, 9, 16, 25], accumulate([1, 2, 3, 4, 5],
lambda x: x * x))
def test_recursive(self):
inp = list('abc')
out = [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3'], ['c1', 'c2', 'c3']]
self.assertEqual(out, accumulate(inp, lambda x: accumulate(list('123'),
lambda y: x + y)))
def test_composition(self):
inp = [10, 17, 23]
self.assertEqual(inp, accumulate(accumulate(inp, lambda x: divmod(x, 7)),
lambda x: 7 * x[0] + x[1]))
def test_divmod(self):
self.assertEqual(accumulate([10, 17, 23], lambda x: divmod(x, 7)),
[(1, 3), (2, 3), (3, 2)])
def test_divmod(self):
self.assertEqual(
accumulate([10, 17, 23], lambda x: divmod(x, 7)),
[(1, 3), (2, 3), (3, 2)])
import numpy
import accumulate
if __name__ == "__main__":
numpy_array = numpy.array([-1, -2])
a = [1, 2, 4, 6]
result = accumulate.accumulate(a)
print(result)
def test_composition(self):
inp = [10, 17, 23]
fn1 = lambda x: divmod(x, 7)
fn2 = lambda x: 7 * x[0] + x[1]
self.assertEqual(inp, accumulate(accumulate(inp, fn1), fn2))
def count_leaves(tree):
return accu.accumulate(lambda x, y: 1 + y, 0,
list(map(lambda x: 1, enumerate_tree(tree))))
def test_empty_sequence(self):
self.assertEqual(accumulate([], lambda x: x / 2), [])
def test_capitalize(self):
self.assertEqual(
accumulate(['hello', 'world'], str.upper), ['HELLO', 'WORLD'])
class Test:
x = accumulate([1, 2])
def test_recursive(self):
inp = ['a', 'b', 'c']
out = [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3'], ['c1', 'c2', 'c3']]
self.assertEqual(
accumulate(
inp, lambda x: accumulate(list('123'), lambda y: x + y)), out)
def test_capitalize(self):
self.assertEqual(accumulate(['hello', 'world'], str.upper),
['HELLO', 'WORLD'])
data['q_channel_w']['U'],
data['u_channel_w']['Q'],
data['u_channel_w']['U'], pix)
except exceptions.ValueError: # byteswap in case input h5 has wrong endianness
signalremove(
signal_removed['Q'], signal_removed['U'],
data['Q'].byteswap().newbyteorder().astype(np.float32),
data['U'].byteswap().newbyteorder().astype(np.float32),
tmap_local.array, umap_local.array,
data['q_channel_w']['Q'], data['q_channel_w']['U'],
data['u_channel_w']['Q'], data['u_channel_w']['U'],
pix)
assert len(baseline_lengths) == len(
RHS.array[0][:num_baselines])
accumulate(signal_removed['Q'], baseline_lengths,
RHS.array[0][:num_baselines])
assert len(baseline_lengths) == len(
RHS.array[0][num_baselines:])
accumulate(signal_removed['U'], baseline_lengths,
RHS.array[0][num_baselines:])
else:
l.info("Bin maps")
bin_map(pix,
data['T'],
tmap_local,
tmap_glob,
hits_glob,
comm,
broadcast_locally=True)
tmap_glob[hits_glob == 0] = hp.UNSEEN
l.info("Write maps")
def test_divmod(self):
inp = [10, 17, 23]
out = [(1, 3), (2, 3), (3, 2)]
self.assertEqual(out, accumulate(inp, lambda x: divmod(x, 7)))
def horner_eval(x, coefficient_sequence):
return accu.accumulate(
lambda this_coeff, higher_terms: this_coeff + op.mul(x, higher_terms),
0, coefficient_sequence)
def test_capitalize(self):
inp = ['hello', 'world']
out = ['HELLO', 'WORLD']
self.assertEqual(out, accumulate(inp, str.upper))
def _append(seq1, seq2):
# 这里的lambda x,y:op.add([x], y), 在lisp中只需cons
return accu.accumulate(lambda x, y: op.add([x], y), seq2, seq1)
def test_empty_sequence(self):
self.assertEqual([], accumulate([], lambda x: x / 2))
def _length(seq):
return accu.accumulate(lambda x, y: op.add(1, y), 0, seq)
def test_divmod(self):
inp = [10, 17, 23]
out = [(1, 3), (2, 3), (3, 2)]
self.assertEqual(out, accumulate(inp, lambda x: divmod(x, 7)))
def _map(proc, seq):
return accu.accumulate(lambda x, y: op.add([proc(x)], y), [], seq)
def test_capitalize(self):
inp = ['hello', 'world']
out = ['HELLO', 'WORLD']
self.assertEqual(out, accumulate(inp, str.upper))
def dot_product(v, w):
return ac.accumulate(op.add,
0,
list(map(op.mul, v, w)))
def test_pow(self):
self.assertEqual([1, 4, 9, 16, 25],
accumulate([1, 2, 3, 4, 5], lambda x: x * x))
def test_composition(self):
inp = [10, 17, 23]
fn1 = lambda x: divmod(x, 7)
fn2 = lambda x: 7*x[0]+x[1]
self.assertEqual(inp, accumulate(accumulate(inp, fn1), fn2))
def test_pow(self):
self.assertEqual(accumulate([1, 2, 3, 4], lambda x: x * x),
[1, 4, 9, 16])
def accumulate_n(op, init, seqs):
# 每个序列等长度，所以如果第一个处理完了，意味着都处理完了
if len(seqs[0]) == 0: return []
return funcs._append(
[accu.accumulate(op, init, list(map(lambda seq: seq[0], seqs)))],
accumulate_n(op, init, list(map(lambda seq: seq[1:], seqs))))
