def limit_versions(language, limit, operator):
"""
Limits given languages with the given operator:
:param language:
A `Language` instance.
:param limit:
A number to limit the versions.
:param operator:
The operator to use for the limiting.
:return:
A new `Language` instance with limited versions.
:raises ValueError:
If no version is left anymore.
"""
if isinstance(limit, int):
versions = [version for version in language.versions
if operator(int(version), limit)]
else:
versions = [version for version in language.versions
if operator(version, limit)]
if not versions:
raise ValueError('No versions left')
return type(language)(*versions)
def _mul_div(self, other, operator):
if isinstance(other, self.__class__):
result = operator(self.value, other.value)
return result.plus_minus((self.rel ** 2.0 + other.rel ** 2.0) ** (1/2), relative=True)
else:
result = operator(self.value, other)
return result.plus_minus(abs(operator(self.error, other)))
def _operator_on_other(self, other, operator):
try:
return Position(operator(self.x, other[0]),
operator(self.y, other[1]))
except TypeError:
return Position(operator(self.x, other),
operator(self.y, other))
def should_record_call(self):
for operator in self.operators:
left, right = Dingus.many(2)
operator(left, right)
operator_name_without_mangling = operator.__name__.replace('_', '')
magic_method_name = '__%s__' % operator_name_without_mangling
yield assert_call_was_logged, left, magic_method_name, right
def test_device_ordering(self, context, operator):
try:
device = Device.from_path(context, "/devices/platform")
except DeviceNotFoundAtPathError:
pytest.skip("device not found")
with pytest.raises(TypeError) as exc_info:
operator(device, device)
assert str(exc_info.value) == "Device not orderable"
def edit(self, activity, options):
operator, delta = self._parse_time_delta(options.time)
for lap in activity.laps:
lap.start_time = operator(lap.start_time, delta)
for trackpoint in lap.trackpoints:
trackpoint.time = operator(trackpoint.time, delta)
def test_rate_operator_negative_rate_full(self):
from anuga.config import rho_a, rho_w, eta_w
from math import pi, cos, sin
a = [0.0, 0.0]
b = [0.0, 2.0]
c = [2.0, 0.0]
d = [0.0, 4.0]
e = [2.0, 2.0]
f = [4.0, 0.0]
points = [a, b, c, d, e, f]
# bac, bce, ecf, dbe
vertices = [[1, 0, 2], [1, 2, 4], [4, 2, 5], [3, 1, 4]]
domain = Domain(points, vertices)
# Flat surface with 1m of water
domain.set_quantity("elevation", 0)
domain.set_quantity("stage", 10.0)
domain.set_quantity("friction", 0)
Br = Reflective_boundary(domain)
domain.set_boundary({"exterior": Br})
# print domain.quantities['elevation'].centroid_values
# print domain.quantities['stage'].centroid_values
# print domain.quantities['xmomentum'].centroid_values
# print domain.quantities['ymomentum'].centroid_values
# Apply operator to these triangles
indices = [0, 1, 3]
# Catchment_Rain_Polygon = read_polygon(join('CatchmentBdy.csv'))
# rainfall = file_function(join('1y120m.tms'), quantities=['rainfall'])
rate = -1.0
factor = 10.0
default_rate = 0.0
operator = Rate_operator(domain, rate=rate, factor=factor, indices=None, default_rate=default_rate)
# Apply Operator
domain.timestep = 2.0
operator()
stage_ex = [0.0, 0.0, 0.0, 0.0]
step_integral = -80.0
# print domain.quantities['elevation'].centroid_values
# print domain.quantities['stage'].centroid_values
# print domain.quantities['xmomentum'].centroid_values
# print domain.quantities['ymomentum'].centroid_values
# print domain.fractional_step_volume_integral
assert num.allclose(domain.quantities["stage"].centroid_values, stage_ex)
assert num.allclose(domain.quantities["xmomentum"].centroid_values, 0.0)
assert num.allclose(domain.quantities["ymomentum"].centroid_values, 0.0)
assert num.allclose(domain.fractional_step_volume_integral, step_integral)
def combine(self, other, operator):
result = collections.defaultdict(fractions.Fraction)
for x, px in self._dist.iteritems():
if isinstance(other, self.__class__):
for y, py in other._dist.iteritems():
result[operator(x, y)] += px * py
else:
result[operator(x, other)] += px
return self.__class__(result)
def mod_karma(thing, operator):
thing = thing.strip()
if thing in memory:
memory[thing] = operator(memory[thing], 1)
else:
memory[thing] = operator(0, 1)
log.info("%s's new karma: %s" % (thing, memory[thing]))
with open( jsoned_memory, "wb" ) as f:
json.dump( memory, f )
def test_rate_operator_simple(self):
from anuga.config import rho_a, rho_w, eta_w
from math import pi, cos, sin
a = [0.0, 0.0]
b = [0.0, 2.0]
c = [2.0, 0.0]
d = [0.0, 4.0]
e = [2.0, 2.0]
f = [4.0, 0.0]
points = [a, b, c, d, e, f]
# bac, bce, ecf, dbe
vertices = [[1,0,2], [1,2,4], [4,2,5], [3,1,4]]
domain = Domain(points, vertices)
#Flat surface with 1m of water
domain.set_quantity('elevation', 0)
domain.set_quantity('stage', 1.0)
domain.set_quantity('friction', 0)
Br = Reflective_boundary(domain)
domain.set_boundary({'exterior': Br})
# print domain.quantities['stage'].centroid_values
# print domain.quantities['xmomentum'].centroid_values
# print domain.quantities['ymomentum'].centroid_values
# Apply operator to these triangles
indices = [0,1,3]
rate = 1.0
factor = 10.0
default_rate= 0.0
operator = Rate_operator(domain, rate=rate, factor=factor, \
indices=indices, default_rate = default_rate)
# Apply Operator
domain.timestep = 2.0
operator()
stage_ex = [ 21., 21., 1., 21.]
# print domain.quantities['stage'].centroid_values
# print domain.quantities['xmomentum'].centroid_values
# print domain.quantities['ymomentum'].centroid_values
assert num.allclose(domain.quantities['stage'].centroid_values, stage_ex)
assert num.allclose(domain.quantities['xmomentum'].centroid_values, 0.0)
assert num.allclose(domain.quantities['ymomentum'].centroid_values, 0.0)
assert num.allclose(domain.fractional_step_volume_integral, factor*domain.timestep*(rate*domain.areas[indices]).sum())
def end(operator, record, arg):
logger.debug("comparing end times %r(%r, %r)", operator, record.endTime, arg)
# We need a special-case for NULL endTime for conferences in progress
if record.endTime is None:
return operator(None, arg)
end = arrow.get(record.endTime)
if arg is None:
return operator(end, None)
return operator(end, _ReplayFilters._normalize_time_val(arg))
def _operate(self, other, operator):
K1 = self.keys()
K2 = other.keys()
keys = set(K1 + K2)
default = operator(self.default, other.default)
result = SparseVector(default=default)
for key in keys:
result[key] = operator(self.get(key, self.default), other.get(key, self.default))
return result
def reverse_binary_operator(self, other, operator):
try:
self.assert_same_keys(other)
result = self._get_empty_self()
for key in self:
result[key] = operator(other[key], self[key])
return result
except TypeError:
result = self._get_empty_self()
for key in self:
result[key] = operator(other, self[key])
return result
def do_operator(self, operator, query, value, result):
op = operator(mock_queryable, value)
assert isinstance(op, Op)
assert op.operation == query[1:]
assert op.as_query == result
if __debug__:
a = MockQueryable()
a.__disallowed_operators__ = {query}
try:
operator(a, value)
except NotImplementedError as e:
assert query in str(e)
def _build_statement(self, quals, columns, sortkeys):
statement = select([self.table])
clauses = []
for qual in quals:
operator = OPERATORS.get(qual.operator, None)
if operator:
clauses.append(operator(self.table.c[qual.field_name],
qual.value))
else:
log_to_postgres('Qual not pushed to foreign db: %s' % qual,
WARNING)
if clauses:
statement = statement.where(and_(*clauses))
if columns:
columns = [self.table.c[col] for col in columns]
else:
columns = self.table.c
statement = statement.with_only_columns(columns)
orders = []
for sortkey in sortkeys:
column = self.table.c[sortkey.attname]
if sortkey.is_reversed:
column = column.desc()
if sortkey.collate:
column = column.collate('"%s"' % sortkey.collate)
if self.engine.driver != 'pymssql' && sortkey.nulls_first:
column = column.nullsfirst()
else self.engine.driver != 'pymssql':
column = column.nullslast()
statement = statement.order_by(column)
def iscompatible(requirements, version):
"""Return whether or not `requirements` is compatible with `version`
Arguments:
requirements (str): Requirement to compare, e.g. foo==1.0.1
version (tuple): Version to compare against, e.g. (1, 0, 1)
Example:
>>> iscompatible("foo", (1, 0, 0))
True
>>> iscompatible("foo<=1", (0, 9, 0))
True
>>> iscompatible("foo>=1, <1.3", (1, 2, 0))
True
>>> iscompatible("foo>=0.9.9", (1, 0, 0))
True
>>> iscompatible("foo>=1.1, <2.1", (2, 0, 0))
True
>>> iscompatible("foo==1.0.0", (1, 0, 0))
True
>>> iscompatible("foo==1.0.0", (1, 0, 1))
False
"""
results = list()
for operator_string, requirement_string in parse_requirements(requirements):
operator = operators[operator_string]
required = string_to_tuple(requirement_string)
result = operator(version, required)
results.append(result)
return all(results)
def _apply_binary_scalar_operator(self, operator, other):
oshape = None
r = None
try:
if isinstance(other, Weights):
if other._max_weight != self._max_weight:
ValueError("Operation not possible as operands have "
"incompatible maximum conductances.")
oshape = other.shape
r = numpy.array(self._weights)
else:
if isinstance(other, list):
oshape = numpy.shape(other)
elif not hasattr(initializer, '__getitem__'):
raise TypeError("Second operand could not be interpreted "
"as an array of weights.")
if oshape != None and oshape != self.shape:
raise IndexError
if r == None:
r = numpy.zeros(oshape)
for x in xrange(self._dim1):
for y in xrange(self._dim2):
r[x][y] = operator(self._weights[x][y], other[x][y])
else:
r -= other._weights
except IndexError:
raise ValueError("Operation not possible as operands have "
"incompatible shapes.")
w = Weights([0], max_weight=self._max_weight)
w._dim1, w._dim2 = self.shape
w._weights = r
return w
def comparison(vm, frame, offset, bytecode):
b, a = frame.pop(), frame.pop()
assert isinstance(a, int) and isinstance(b, int)
if operator(a, b):
frame.pc = decode_signed_offset(bytecode, frame.pc)-1
return
frame.pc = frame.pc+2
def _build_statement(self, quals, columns, sortkeys):
statement = select([self.table])
clauses = []
for qual in quals:
operator = OPERATORS.get(qual.operator, None)
if operator:
clauses.append(operator(self.table.c[qual.field_name],
qual.value))
else:
log_to_postgres('Qual not pushed to foreign db: %s' % qual,
WARNING)
if clauses:
statement = statement.where(and_(*clauses))
if columns:
columns = [self.table.c[col] for col in columns]
else:
columns = self.table.c
statement = statement.with_only_columns(columns)
orders = []
for sortkey in sortkeys:
column = self.table.c[sortkey.attname]
if sortkey.is_reversed:
column = column.desc()
if sortkey.collate:
column = column.collate('"%s"' % sortkey.collate)
null_ordering = self._need_explicit_null_ordering(sortkey)
if null_ordering:
column = null_ordering(column)
statement = statement.order_by(column)
return statement
def majorityCnt(classList):
classCount = {}
for vote in classList:
if vote not in classCount.keys(): classCount[vote] = 0
classCount[vote] += 1
sortedClassCount = sorted(classCount.iteritems(),key=operator(1),reverse=True)
return sortedClassCount[0][0]
def execute(self, quals, columns):
"""
The quals are turned into an and'ed where clause.
"""
statement = select([self.table])
clauses = []
for qual in quals:
operator = OPERATORS.get(qual.operator, None)
if operator:
clauses.append(operator(self.table.c[qual.field_name],
qual.value))
else:
log_to_postgres('Qual not pushed to foreign db: %s' % qual,
WARNING)
if clauses:
statement = statement.where(and_(*clauses))
if columns:
columns = [self.table.c[col] for col in columns]
else:
columns = self.table.c
statement = statement.with_only_columns(columns)
log_to_postgres(str(statement), DEBUG)
rs = (self.connection
.execution_options(stream_results=True)
.execute(statement))
for item in rs:
yield dict(item)
def __init__(self, inputs, cols="1", operator=None):
self.cols = make_colspec(cols)
self.ops = map(lambda x: operator([x]), inputs)
self.name = "catcol(%s, %s)" % (",".join(map(str, self.cols)), str(self.ops[0]))
# print self.cols, self.ops
Operator.__init__(self, inputs, operators.OP_N_TO_N)
def visit_BinaryExpressionNode(self, node):
assert len(node.children) == 3
operator = self.visit(node.children[0])
operand_0 = self.visit(node.children[1])
operand_1 = self.visit(node.children[2])
return operator(operand_0, operand_1)
def process_BoolOp(self, node, children):
operator = children.pop(0)
for child in children:
if not isinstance(child, Query):
raise ValueError("Bad expression: All operands for %s must be queries." % operator.__name__)
return operator(*children)
def process_BinOp(self, node, children):
left, operator, right = children
if not isinstance(left, Query):
raise ValueError("Bad expression: left operand for %s must be a query." % operator.__name__)
if not isinstance(right, Query):
raise ValueError("Bad expression: right operand for %s must be a query." % operator.__name__)
return operator(left, right)
def execute(self, quals, columns):
"""
The quals are turned into an and'ed where clause.
"""
statement = select([self.table])
clauses = []
for qual in quals:
operator = OPERATORS.get(qual.operator, None)
if operator:
clauses.append(operator(self.table.c[qual.field_name],
qual.value))
else:
log_to_postgres('Qual not pushed to foreign db: %s' % qual,
WARNING)
if clauses:
statement = statement.where(and_(*clauses))
if columns:
columns = [self.table.c[col] for col in columns]
else:
columns = self.table.c
statement = statement.with_only_columns(columns)
log_to_postgres(str(statement), DEBUG)
rs = (self.connection
.execution_options(stream_results=True)
.execute(statement))
# Workaround pymssql "trash old results on new query"
# behaviour (See issue #100)
if self.engine.driver == 'pymssql' and self.transaction is not None:
rs = list(rs)
for item in rs:
yield dict(item)
def overload(operators, *args): for operator in operators: try: ret = operator(*args) except: pass else: return ret
def unary_op(type_, operator, operation, lhs):
if hasattr(lhs, 'operations') and lhs.operations is not None:
lhs_operations = lhs.operations
else:
lhs_operations = lhs
result = operator(type_(lhs))
return track(result, operation(lhs_operations))
def combine_multiple(subsets, operator):
if len(subsets) == 0:
return SubsetState()
else:
combined = subsets[0]
for subset in subsets[1:]:
combined = operator(combined, subset)
return combined
def _arithmetic_to_number(self, operator, operand, allow_nonzero_ints=False):
if not isinstance(operand, Capacity):
if not allow_nonzero_ints and operand != 0:
raise TypeError(
"Attempt to perform %s operation between capacity and %r" %
(operator.__name__, operand))
operand = Capacity(operand)
return operator(self.bits, operand.bits)
def prediction_func(row):
"""Look up the row's features in order of their score. Exit if the threshold is met and the tree exits on True,
or if the threshold is not met and the tree exits on False.
Args:
row: Dataframe row with features as columns
Returns:
Series with prediction for all cues used
"""
ret_ser = pd.Series()
for index, cue_row in cue_df.iterrows():
operator = operator_dict[cue_row['direction']]
outcome = operator(row[cue_row['feature']],
cue_row['threshold'])
# store prediction in series
ret_ser.set_value(index, outcome)
# exit tree if outcome is exit or last cue reached
if (cue_row['exit'] == int(outcome)) or (index + 1 == nr_rows):
cues_used = index + 1
break
# return predictions for cues used
return ret_ser
def _apply_filter(self, match_objs, filters):
"""
"""
if type(filters) is dict:
filters = [filters]
else:
if filters is None or type(filters) is not list:
raise ValueError("filters must be of type dict or list")
for filter_el in filters:
operator = LightCurve._ops[
filter_el['operator']
]
attr_name = filter_el['attribute']
match_objs = tuple(
filter(
lambda x: x.has_parameter(attr_name) and operator(x.get_value(attr_name), filter_el['value']),
match_objs
)
)
return match_objs
def handleInteraction(client, userdata, message):
data = json.loads(message.payload.decode('utf-8'))
sourceSerial = data['serial']
# Don't make an actuation change if this node is not a device
if not isDevice(parseConfig()['serial']):
logging.info('node with serial %d triggered interaction, but is not device node'
% parseConfig()['serial'])
return
for i in getOwnInteractions():
if i['trigger_serial'] == sourceSerial:
operator = OPS[i['operator']]
destVal = i['value']
srcVal = data['data']
if operator(srcVal, destVal):
global hardwareClient
# Cast to correct type
newVal = i['action']
valType = getHardwareType()
if valType == 'float':
newVal = float(newVal)
elif valType == 'boolean':
newVal = bool(newVal)
elif valType == 'integer':
newVal = int(newVal)
otherNode = getNode(i['target_serial'])
print('Interaction triggered for device \'%s\'. Changing data to \'%d\''
% (otherNode['display_name'], newVal))
hardwareClient.changeValue(getHardwareName(), newVal)
logging.info('interaction with id %d triggered' %
i['interaction_id'])
def select_bin_from_corr(r,
xip,
xip_err,
radius=1 * u.arcmin,
operator=operator.le):
"""Aggregate measurements for r less than (or greater than) radius.
Returns aggregate measurement for all entries where operator(r, radius).
E.g.,
* Passing radius=5, operator=operator.le will return averages for r<=5
* Passing radius=2, operator=operator.gt will return averages for r >2
Written with the use of correlation functions in mind, thus the naming
but generically just returns averages of the arrays xip and xip_err
where the condition is satsified
Parameters
----------
r : numpy.array
radius
xip : numpy.array
correlation
xip_err : numpy.array
correlation uncertainty
operator : Operation in the 'operator' module: le, ge, lt, gt
Returns
-------
avg_xip, avg_xip_err : (float, float)
"""
w, = np.where(operator(r, radius))
avg_xip = np.average(xip[w])
avg_xip_err = np.average(xip_err[w])
return avg_xip, avg_xip_err
def _ufunc_binary_operator(self, *, operator: tp.Callable,
other) -> np.ndarray:
'''
Binary operators applied to an index always return an NP array. This deviates from Pandas, where some operations (multipling an int index by an int) result in a new Index, while other operations result in a np.array (using == on two Index).
'''
if self._recache:
self._update_array_cache()
if issubclass(other.__class__, Index):
other = other.values # operate on labels to labels
result = operator(self._labels, other)
# see Series._ufunc_binary_operator for notes on why
if not isinstance(result, np.ndarray):
if isinstance(result, BOOL_TYPES):
result = np.full(len(self._labels), result)
else:
raise RuntimeError(
'unexpected branch from non-array result of operator application to array'
)
result.flags.writeable = False
return result
def test_operator(self, operator, emulated_operator=None):
if emulated_operator is None:
emulated_operator = operator
value = features.Value(value=2)
f = operator(value, 3)
self.assertEqual(f(), operator(2, 3))
self.assertListEqual(f().get_property("value", get_one=False), [2, 3])
f = operator(3, value)
self.assertEqual(f(), operator(3, 2))
f = operator(value, lambda: 3)
self.assertEqual(f(), operator(2, 3))
self.assertListEqual(f().get_property("value", get_one=False), [2, 3])
grid_test_features(
self,
features.Value,
features.Value,
[
{"value": 1},
{"value": 0.5},
{"value": np.nan},
{"value": np.inf},
{"value": np.random.rand(10, 10)},
],
[
{"value": 1},
{"value": 0.5},
{"value": np.nan},
{"value": np.inf},
{"value": np.random.rand(10, 10)},
],
lambda a, b: emulated_operator(a["value"], b["value"]),
operator,
)
def test_unary_operators(operator, value, result):
v = StatefulPublisher(value)
try:
value_applied = operator(v).get()
except Exception as e:
assert isinstance(e, result)
else:
assert value_applied == result
cb = mock.Mock()
try:
operator(v) | op.Sink(cb)
except Exception as e:
assert isinstance(e, result)
else:
assert cb.mock_called_once_with(result)
with pytest.raises(ValueError):
Value(1) | operator(v)
with pytest.raises(ValueError):
operator(v).emit_op(0, who=Publisher())
def _test(self, a, b, operator):
return operator(a, b)
def test_rate_operator_functions_empty_indices(self):
from anuga.config import rho_a, rho_w, eta_w
from math import pi, cos, sin
a = [0.0, 0.0]
b = [0.0, 2.0]
c = [2.0, 0.0]
d = [0.0, 4.0]
e = [2.0, 2.0]
f = [4.0, 0.0]
points = [a, b, c, d, e, f]
# bac, bce, ecf, dbe
vertices = [[1, 0, 2], [1, 2, 4], [4, 2, 5], [3, 1, 4]]
domain = Domain(points, vertices)
#Flat surface with 1m of water
domain.set_quantity('elevation', 0.0)
domain.set_quantity('stage', 1.0)
domain.set_quantity('friction', 0.0)
Br = Reflective_boundary(domain)
domain.set_boundary({'exterior': Br})
verbose = False
if verbose:
print domain.quantities['elevation'].centroid_values
print domain.quantities['stage'].centroid_values
print domain.quantities['xmomentum'].centroid_values
print domain.quantities['ymomentum'].centroid_values
# Apply operator to these triangles
indices = []
factor = 10.0
def main_spatial_rate(x, y, t):
# x and y should be an n by 1 array
return x + y
default_rate = 0.0
domain.tri_full_flag[0] = 0
operator = Rate_operator(domain, rate=main_spatial_rate, factor=factor, \
indices=indices, default_rate = default_rate)
# Apply Operator
domain.timestep = 2.0
operator()
t = operator.get_time()
Q = operator.get_Q()
x = operator.coord_c[indices, 0]
y = operator.coord_c[indices, 1]
rate = main_spatial_rate(x, y, t) * factor
Q_ex = num.sum(domain.areas[indices] * rate)
d = operator.get_timestep() * rate + 1
#print Q_ex, Q
#print indices
#print "d"
#print d
stage_ex = num.array([1.0, 1.0, 1.0, 1.0])
stage_ex[indices] = d
if verbose:
print domain.quantities['elevation'].centroid_values
print domain.quantities['stage'].centroid_values
print domain.quantities['xmomentum'].centroid_values
print domain.quantities['ymomentum'].centroid_values
assert num.allclose(domain.quantities['stage'].centroid_values,
stage_ex)
assert num.allclose(domain.quantities['xmomentum'].centroid_values,
0.0)
assert num.allclose(domain.quantities['ymomentum'].centroid_values,
0.0)
assert num.allclose(Q_ex, Q)
assert num.allclose(domain.fractional_step_volume_integral,
((d - 1.) * domain.areas[indices]).sum())
# _*_coding: UTF-8_*_
__author__ = 'bwh'
import operator
bart = operator("zhangsan", 100)
print bart.get_name()
def infer_dtype(left_dtype, right_dtype, operator):
left = build_empty_series(left_dtype)
right = build_empty_series(right_dtype)
return operator(left, right).dtype
def wrapped(*args):
d = {p.name: arg for arg, p in zip(args, parameters)}
fval = f(*[d[name] for name in names1.keys()])
gval = g(*[d[name] for name in names2.keys()])
return operator(fval, gval)
def operation(data, operator):
result = data[0]
for i in data[1:]:
result = operator(result, i)
return result
def compare(self, item, operator=operator.eq):
getter = self._getter
self._getter = lambda obj: operator(getter(obj),
self.__get_value(item, obj))
return self
def filter_by_price(queryset, value, operator):
return [
obj for obj in queryset if operator(
get_availability(obj, context.discounts).price_range.
min_price.gross, value)
]
def _combine(subsets, operator):
state = operator(*[s.subset_state for s in subsets])
result = Subset(None)
result.subset_state = state
return result
def test_rate_operator_rate_quantity(self):
from anuga.config import rho_a, rho_w, eta_w
from math import pi, cos, sin
a = [0.0, 0.0]
b = [0.0, 2.0]
c = [2.0, 0.0]
d = [0.0, 4.0]
e = [2.0, 2.0]
f = [4.0, 0.0]
points = [a, b, c, d, e, f]
# bac, bce, ecf, dbe
vertices = [[1, 0, 2], [1, 2, 4], [4, 2, 5], [3, 1, 4]]
domain = Domain(points, vertices)
#Flat surface with 1m of water
domain.set_quantity('elevation', 0.0)
domain.set_quantity('stage', 1.0)
domain.set_quantity('friction', 0.0)
Br = Reflective_boundary(domain)
domain.set_boundary({'exterior': Br})
verbose = False
if verbose:
print domain.quantities['elevation'].centroid_values
print domain.quantities['stage'].centroid_values
print domain.quantities['xmomentum'].centroid_values
print domain.quantities['ymomentum'].centroid_values
# Apply operator to these triangles
indices = [0, 1, 3]
factor = 10.0
from anuga import Quantity
rate_Q = Quantity(domain)
rate_Q.set_values(1.0)
operator = Rate_operator(domain, rate=rate_Q, factor=factor, \
indices=indices)
# Apply Operator
domain.timestep = 2.0
operator()
rate = rate_Q.centroid_values[indices]
t = operator.get_time()
Q = operator.get_Q()
rate = rate * factor
Q_ex = num.sum(domain.areas[indices] * rate)
d = operator.get_timestep() * rate + 1
#print "d"
#print d
#print Q_ex
#print Q
stage_ex = num.array([1.0, 1.0, 1.0, 1.0])
stage_ex[indices] = d
verbose = False
if verbose:
print domain.quantities['elevation'].centroid_values
print domain.quantities['stage'].centroid_values
print domain.quantities['xmomentum'].centroid_values
print domain.quantities['ymomentum'].centroid_values
assert num.allclose(domain.quantities['stage'].centroid_values,
stage_ex)
assert num.allclose(domain.quantities['xmomentum'].centroid_values,
0.0)
assert num.allclose(domain.quantities['ymomentum'].centroid_values,
0.0)
assert num.allclose(Q_ex, Q)
assert num.allclose(domain.fractional_step_volume_integral,
((d - 1.) * domain.areas[indices]).sum())
def infer_dtypes(left_dtypes, right_dtypes, operator):
left = build_empty_df(left_dtypes)
right = build_empty_df(right_dtypes)
return operator(left, right).dtypes
def evaluate(obj):
left_val = eval_left(obj)
right_val = eval_right(obj)
if left_val is None or right_val is None:
return None
return operator(eval_left(obj), eval_right(obj))
def compare_pvector(v, other, operator):
return operator(v.tolist(),
other.tolist() if isinstance(other, PVector) else other)
def make(cls, operands: Sequence[int], operator: Operator) -> 'Equation':
return Equation(tuple(operands), operator, operator(*operands))
def bad_samples(act, samples_to_drop, operator, threshold):
df = deviation[(deviation['Activity'] == act)]
temp = (deviation.Activity == act) & operator(deviation.attr_y_acc,
threshold)
return samples_to_drop.extend(list(df.Sample_Num[temp]))
def quantity_binary_operator(db_obj, other, operator):
return db.and_(
db_obj['_type'].astext == 'quantity',
db_obj['dimensionality'].astext == str(other.dimensionality),
operator(db_obj['magnitude_in_base_units'].astext.cast(db.Float),
other.magnitude_in_base_units))
def test_rate_operator_negative_rate_full(self):
from anuga.config import rho_a, rho_w, eta_w
from math import pi, cos, sin
a = [0.0, 0.0]
b = [0.0, 2.0]
c = [2.0, 0.0]
d = [0.0, 4.0]
e = [2.0, 2.0]
f = [4.0, 0.0]
points = [a, b, c, d, e, f]
# bac, bce, ecf, dbe
vertices = [[1, 0, 2], [1, 2, 4], [4, 2, 5], [3, 1, 4]]
domain = Domain(points, vertices)
#Flat surface with 1m of water
domain.set_quantity('elevation', 0)
domain.set_quantity('stage', 10.0)
domain.set_quantity('friction', 0)
Br = Reflective_boundary(domain)
domain.set_boundary({'exterior': Br})
# print domain.quantities['elevation'].centroid_values
# print domain.quantities['stage'].centroid_values
# print domain.quantities['xmomentum'].centroid_values
# print domain.quantities['ymomentum'].centroid_values
# Apply operator to these triangles
indices = [0, 1, 3]
#Catchment_Rain_Polygon = read_polygon(join('CatchmentBdy.csv'))
#rainfall = file_function(join('1y120m.tms'), quantities=['rainfall'])
rate = -1.0
factor = 10.0
default_rate = 0.0
operator = Rate_operator(domain, rate=rate, factor=factor, \
indices=None, default_rate = default_rate)
# Apply Operator
domain.timestep = 2.0
operator()
stage_ex = [0., 0., 0., 0.]
step_integral = -80.0
#print domain.quantities['elevation'].centroid_values
#print domain.quantities['stage'].centroid_values
#print domain.quantities['xmomentum'].centroid_values
#print domain.quantities['ymomentum'].centroid_values
#print domain.fractional_step_volume_integral
assert num.allclose(domain.quantities['stage'].centroid_values,
stage_ex)
assert num.allclose(domain.quantities['xmomentum'].centroid_values,
0.0)
assert num.allclose(domain.quantities['ymomentum'].centroid_values,
0.0)
assert num.allclose(domain.fractional_step_volume_integral,
step_integral)
def visit_UnaryExpressionNode(self, node):
assert len(node.children) == 2
operator = self.visit(node.children[0])
operand = self.visit(node.children[1])
return lambda x: operator(operand(x))
def _(row, ctx):
return operator(val(row, ctx))
def test_rate_operator_rate_from_file(self):
from anuga.config import rho_a, rho_w, eta_w
from math import pi, cos, sin
a = [0.0, 0.0]
b = [0.0, 2.0]
c = [2.0, 0.0]
d = [0.0, 4.0]
e = [2.0, 2.0]
f = [4.0, 0.0]
points = [a, b, c, d, e, f]
# bac, bce, ecf, dbe
vertices = [[1, 0, 2], [1, 2, 4], [4, 2, 5], [3, 1, 4]]
#---------------------------------
#Typical ASCII file
#---------------------------------
finaltime = 1200
filename = 'test_file_function'
fid = open(filename + '.txt', 'w')
start = time.mktime(time.strptime('2000', '%Y'))
dt = 60 #One minute intervals
t = 0.0
while t <= finaltime:
t_string = time.strftime(time_format, time.gmtime(t + start))
fid.write('%s, %f %f %f\n' %
(t_string, 2 * t, t**2, sin(t * pi / 600)))
t += dt
fid.close()
#Convert ASCII file to NetCDF (Which is what we really like!)
timefile2netcdf(filename + '.txt')
#Create file function from time series
F = file_function(
filename + '.tms',
quantities=['Attribute0', 'Attribute1', 'Attribute2'])
#Now try interpolation
for i in range(20):
t = i * 10
q = F(t)
#Exact linear intpolation
assert num.allclose(q[0], 2 * t)
if i % 6 == 0:
assert num.allclose(q[1], t**2)
assert num.allclose(q[2], sin(t * pi / 600))
#Check non-exact
t = 90 #Halfway between 60 and 120
q = F(t)
assert num.allclose((120**2 + 60**2) / 2, q[1])
assert num.allclose((sin(120 * pi / 600) + sin(60 * pi / 600)) / 2,
q[2])
t = 100 #Two thirds of the way between between 60 and 120
q = F(t)
assert num.allclose(2 * 120**2 / 3 + 60**2 / 3, q[1])
assert num.allclose(
2 * sin(120 * pi / 600) / 3 + sin(60 * pi / 600) / 3, q[2])
#os.remove(filename + '.txt')
#os.remove(filename + '.tms')
domain = Domain(points, vertices)
#Flat surface with 1m of water
domain.set_quantity('elevation', 0)
domain.set_quantity('stage', 1.0)
domain.set_quantity('friction', 0)
Br = Reflective_boundary(domain)
domain.set_boundary({'exterior': Br})
# print domain.quantities['elevation'].centroid_values
# print domain.quantities['stage'].centroid_values
# print domain.quantities['xmomentum'].centroid_values
# print domain.quantities['ymomentum'].centroid_values
# Apply operator to these triangles
indices = [0, 1, 3]
rate = file_function('test_file_function.tms',
quantities=['Attribute1'])
factor = 1000.0
default_rate = 17.7
operator = Rate_operator(domain, rate=rate, factor=factor, \
indices=indices, default_rate = default_rate)
# Apply Operator
domain.set_starttime(360.0)
domain.timestep = 1.0
operator()
d = domain.get_time()**2 * factor + 1.0
stage_ex0 = [d, d, 1., d]
# print d, domain.get_time(), F(360.0)
# print domain.quantities['elevation'].centroid_values
# print domain.quantities['stage'].centroid_values
# print domain.quantities['xmomentum'].centroid_values
# print domain.quantities['ymomentum'].centroid_values
assert num.allclose(domain.quantities['stage'].centroid_values,
stage_ex0)
assert num.allclose(domain.quantities['xmomentum'].centroid_values,
0.0)
assert num.allclose(domain.quantities['ymomentum'].centroid_values,
0.0)
assert num.allclose(domain.fractional_step_volume_integral,
((d - 1.) * domain.areas[indices]).sum())
domain.set_starttime(-10.0)
domain.timestep = 1.0
try:
operator()
except:
pass
else:
raise Exception('Should have raised an exception, time too early')
domain.set_starttime(1300.0)
domain.timestep = 1.0
operator()
d = default_rate * factor + d
stage_ex1 = [d, d, 1., d]
# print domain.quantities['elevation'].centroid_values
# print domain.quantities['stage'].centroid_values
# print domain.quantities['xmomentum'].centroid_values
# print domain.quantities['ymomentum'].centroid_values
assert num.allclose(domain.quantities['stage'].centroid_values,
stage_ex1)
assert num.allclose(domain.quantities['xmomentum'].centroid_values,
0.0)
assert num.allclose(domain.quantities['ymomentum'].centroid_values,
0.0)
assert num.allclose(domain.fractional_step_volume_integral,
((d - 1.) * domain.areas[indices]).sum())
def _(row, ctx):
return operator(lhs(row, ctx), rhs(row, ctx))
def operators(Alert_price,operator,Stock_price):
return operator(Alert_price,Stock_price)
def test_rate_operator_functions_rate_default_rate(self):
from anuga.config import rho_a, rho_w, eta_w
from math import pi, cos, sin
a = [0.0, 0.0]
b = [0.0, 2.0]
c = [2.0, 0.0]
d = [0.0, 4.0]
e = [2.0, 2.0]
f = [4.0, 0.0]
points = [a, b, c, d, e, f]
# bac, bce, ecf, dbe
vertices = [[1, 0, 2], [1, 2, 4], [4, 2, 5], [3, 1, 4]]
domain = Domain(points, vertices)
#Flat surface with 1m of water
domain.set_quantity('elevation', 0)
domain.set_quantity('stage', 1.0)
domain.set_quantity('friction', 0)
Br = Reflective_boundary(domain)
domain.set_boundary({'exterior': Br})
verbose = False
if verbose:
print domain.quantities['elevation'].centroid_values
print domain.quantities['stage'].centroid_values
print domain.quantities['xmomentum'].centroid_values
print domain.quantities['ymomentum'].centroid_values
# Apply operator to these triangles
indices = [0, 1, 3]
factor = 10.0
def main_rate(t):
if t > 20:
msg = 'Model time exceeded.'
raise Modeltime_too_late, msg
else:
return 3.0 * t + 7.0
default_rate = lambda t: 3 * t + 7
operator = Rate_operator(domain, rate=main_rate, factor=factor, \
indices=indices, default_rate = default_rate)
# Apply Operator
domain.timestep = 2.0
operator()
t = operator.get_time()
d = operator.get_timestep() * main_rate(t) * factor + 1
stage_ex = [d, d, 1., d]
if verbose:
print domain.quantities['elevation'].centroid_values
print domain.quantities['stage'].centroid_values
print domain.quantities['xmomentum'].centroid_values
print domain.quantities['ymomentum'].centroid_values
assert num.allclose(domain.quantities['stage'].centroid_values,
stage_ex)
assert num.allclose(domain.quantities['xmomentum'].centroid_values,
0.0)
assert num.allclose(domain.quantities['ymomentum'].centroid_values,
0.0)
assert num.allclose(domain.fractional_step_volume_integral,
((d - 1.) * domain.areas[indices]).sum())
domain.set_starttime(30.0)
domain.timestep = 1.0
operator()
t = operator.get_time()
d = operator.get_timestep() * default_rate(t) * factor + d
stage_ex = [d, d, 1., d]
if verbose:
print domain.quantities['elevation'].centroid_values
print domain.quantities['stage'].centroid_values
print domain.quantities['xmomentum'].centroid_values
print domain.quantities['ymomentum'].centroid_values
assert num.allclose(domain.quantities['stage'].centroid_values,
stage_ex)
assert num.allclose(domain.quantities['xmomentum'].centroid_values,
0.0)
assert num.allclose(domain.quantities['ymomentum'].centroid_values,
0.0)
