def apply_list(self, zmin, zmax, ns, evaluation): 'RandomComplex[{zmin_, zmax_}, ns_]' expr = Expression('RandomComplex', Expression('List', zmin, zmax), ns) min_value, max_value = self.to_complex(zmin, evaluation), self.to_complex( zmax, evaluation) if min_value is None or max_value is None: return evaluation.message('RandomComplex', 'unifr', Expression('List', zmin, zmax)) py_ns = ns.to_python() if not isinstance(py_ns, list): py_ns = [py_ns] if not all([isinstance(i, int) and i >= 0 for i in py_ns]): return evaluation.message('RandomComplex', 'array', ns, expr) with RandomEnv(evaluation) as rand: real = rand.randreal(min_value.real, max_value.real, py_ns) imag = rand.randreal(min_value.imag, max_value.imag, py_ns) return instantiate_elements( stack(real, imag), lambda c: Complex(Real(c[0]), Real(c[1])), d=2)
def apply_for_color(self, color, evaluation): "ColorNegate[color_RGBColor]" # Get components r, g, b = [leaf.to_python() for leaf in color.leaves] # Invert r, g, b = (1.0 - r, 1.0 - g, 1.0 - b) # Reconstitute return Expression("RGBColor", Real(r), Real(g), Real(b))
def apply(self, z, evaluation): "Precision[z_]" if not z.is_inexact(): return Symbol("Infinity") elif z.to_sympy().is_zero: return Real(0) else: return Real(dps(z.get_precision()))
def testReal(self): self.check('1.5', Real('1.5')) self.check('1.5`', Real('1.5')) self.check('0.0', Real(0)) self.check('-1.5`', Real('-1.5')) self.check('0.00000000000000000', '0.') self.check('0.000000000000000000`', '0.') self.check('0.000000000000000000', '0.``18')
def testReal(self): self.check("1.5", Real("1.5")) self.check("1.5`", Real("1.5")) self.check("0.0", Real(0)) self.check("-1.5`", Real("-1.5")) self.check("0.00000000000000000", "0.") self.check("0.000000000000000000`", "0.") self.check("0.000000000000000000", "0.``18")
def eval_f(x_value, y_value): value = stored.get((x_value, y_value), False) if value == False: value = quiet_evaluate(f, {x: Real(x_value), y: Real(y_value)}, evaluation) #value = dynamic_scoping(f.evaluate, {x: Real(x_value), y: Real(y_value)}, evaluation) #value = chop(value).get_real_value() if value is not None: value = float(value) stored[(x_value, y_value)] = value return value
def testReal(self): _test_group( MachineReal(1.17361), MachineReal(-1.42), MachineReal(42.846195714), MachineReal(42.846195714), MachineReal(42.846195713), Real("42.846195713", 18), Real("-1.42", 3), )
def apply(self, zmin, zmax, evaluation): 'RandomComplex[{zmin_, zmax_}]' min_value, max_value = self.to_complex(zmin, evaluation), self.to_complex(zmax, evaluation) if min_value is None or max_value is None: return evaluation.message('RandomComplex', 'unifr', Expression('List', zmin, zmax)) with RandomEnv(evaluation) as rand: real = Real(rand.randreal(min_value.real, max_value.real)) imag = Real(rand.randreal(min_value.imag, max_value.imag)) return Complex(real, imag)
def compute(a, b): return Expression( "Apply", distance_function, Expression( "List", Expression( "List", *[Real(val) for val in a.to_color_space("LAB")]), Expression( "List", *[Real(val) for val in b.to_color_space("LAB")]), ), )
def apply(self, zmin, zmax, evaluation): "RandomComplex[{zmin_, zmax_}]" min_value, max_value = ( self.to_complex(zmin, evaluation), self.to_complex(zmax, evaluation), ) if min_value is None or max_value is None: return evaluation.message("RandomComplex", "unifr", Expression("List", zmin, zmax)) with RandomEnv(evaluation) as rand: real = Real(rand.randreal(min_value.real, max_value.real)) imag = Real(rand.randreal(min_value.imag, max_value.imag)) return Complex(real, imag)
def apply(self, text1, text2, evaluation, options): 'WordSimilarity[text1_String, text2_String, OptionsPattern[%(name)s]]' doc1 = self._nlp(text1.get_string_value(), evaluation, options) if doc1: doc2 = self._nlp(text2.get_string_value(), evaluation, options) if doc2: return Real(doc1.similarity(doc2))
def apply(self, expr, evaluation): "AbsoluteTiming[expr_]" start = time.time() result = expr.evaluate(evaluation) stop = time.time() return Expression("List", Real(stop - start), result)
def apply_complex(self, x, evaluation): 'Precision[x_Complex]' if x.is_inexact(): return Real(dps(x.get_precision())) else: return Symbol('Infinity')
def apply(self, expr, evaluation): 'Timing[expr_]' start = time.clock() result = expr.evaluate(evaluation) stop = time.clock() return Expression('List', Real(stop - start), result)
def eval_f(self, f, x_name, x_value, evaluation): value = quiet_evaluate(f, {x_name: Real(x_value)}, evaluation, expect_list=True) if value is None or len(value) != 2: return None return value
def apply_N(self, prec, evaluation): 'N[E, prec_]' prec = get_precision(prec, evaluation) if prec is not None: with workprec(prec): return Real(mpmath2gmpy(mpmath.e))
def apply_any(self, args, evaluation, options): "DateObject[args_, OptionsPattern[]]" datelist = None tz = None if isinstance(args, Expression): if args.get_head_name() in ("System`Rule", "System`DelayedRule"): options[args.leaves[0].get_name()] = args.leaves[1] args = Expression("AbsoluteTime").evaluate(evaluation) elif args.get_head_name() == "System`DateObject": datelist = args._leaves[0] tz = args._leaves[3] if datelist is None: datelist = self.to_datelist(args, evaluation) tz = Real(-time.timezone / 3600.0) if datelist is None: return fmt = None if options["System`TimeZone"].sameQ(Symbol("Automatic")): timezone = Real(-time.timezone / 3600.0) else: timezone = options["System`TimeZone"].evaluate(evaluation) if not timezone.is_numeric(evaluation): evaluation.message("DateObject", "notz", timezone) # TODO: if tz != timezone, shift the datetime list. if not tz == timezone: dt = timezone.to_python() - tz.to_python() if len(datelist) > 3: newhour = datelist[3] + dt datelist = datelist[:3] + [newhour] + datelist[4:] epoch = Symbol("Eternity") if datelist[-1] == 0: for i in range(len(datelist)): if datelist[-1 - i] != 0: datelist = datelist[:-i] epoch = self.granularities[-i - 1] break else: epoch = Symbol("Instant") fmt = options["System`DateFormat"] if len(datelist) < 6: datelist = [Integer(d) for d in datelist] else: datelist = [Integer(d) for d in datelist[:5]] + [Real(datelist[5])] return Expression( "DateObject", datelist, epoch, Symbol("Gregorian"), timezone, fmt, )
def search_product(i): if i == len(result) - 1: return Expression('List', *[ Real(rand.randreal(min_value, max_value)) for j in range(result[i])]) else: return Expression('List', *[ search_product(i + 1) for j in range(result[i])])
def apply(self, word, evaluation, options): 'WordFrequencyData[word_String, OptionsPattern[%(name)s]]' doc = self._nlp(word.get_string_value(), evaluation, options) frequency = 0. if doc: if len(doc) == 1: frequency = math.exp(doc[0].prob) # convert log probability return Real(frequency)
def testAcrossTypes(self): _test_group( Integer(1), Rational(1, 1), Real(1), Complex(Integer(1), Integer(1)), String("1"), Symbol("1"), )
def apply(self, evaluation): "TimeRemaining[]" if len(evaluation.timeout_queue) > 0: t, start_time = evaluation.timeout_queue[-1] curr_time = datetime.now().timestamp() deltat = t + start_time - curr_time return Real(deltat) else: return SymbolInfinity
def apply(self, min, max, evaluation): 'RandomReal[{min_, max_}]' min_value = min.get_real_value() max_value = max.get_real_value() if min_value is None or max_value is None: return evaluation.message('RandomReal', 'unifr', Expression('List', min, max)) with RandomEnv(evaluation) as rand: return Real(rand.randreal(min_value, max_value))
def get_magnitude(leaves, targetUnit, evaluation): quanity = Q_(leaves[0], leaves[1].get_string_value()) converted_quantity = quanity.to(targetUnit) q_mag = converted_quantity.magnitude.evaluate( evaluation).get_float_value() # Displaying the magnitude in Integer form if the convert rate is an Integer if q_mag - int(q_mag) > 0: return Real(q_mag) else: return Integer(q_mag)
def apply(self, xmin, xmax, evaluation): 'RandomReal[{xmin_, xmax_}]' if not (isinstance(xmin, (Real, Integer)) and isinstance(xmax, (Real, Integer))): return evaluation.message('RandomReal', 'unifr', Expression('List', xmin, xmax)) min_value, max_value = xmin.to_python(), xmax.to_python() with RandomEnv(evaluation) as rand: return Real(rand.randreal(min_value, max_value))
def eval_color(x, y, v): v_scaled = (v - v_min) / v_range if color_function_scaling and color_function_min is not None and color_function_max is not None: v_color_scaled = color_function_min + v_scaled * color_function_range else: v_color_scaled = v v_lookup = int(v_scaled * 100 + 0.5) # calculate and store 100 different shades max. value = colors.get(v_lookup) if value is None: value = Expression(color_func, Real(v_color_scaled)) value = value.evaluate(evaluation) colors[v_lookup] = value return value
def apply(self, expr, evaluation): 'Precedence[expr_]' from mathics.builtin import builtins name = expr.get_name() precedence = 1000 if name: builtin = builtins.get(name) if builtin is not None and isinstance(builtin, Operator): precedence = builtin.precedence else: precedence = 670 return Real(precedence)
def convert_unit(leaves, target): mag = leaves[0] unit = leaves[1].get_string_value() quantity = Q_(mag, unit) converted_quantity = quantity.to(target) q_mag = converted_quantity.magnitude.evaluate( evaluation).get_float_value() # Displaying the magnitude in Integer form if the convert rate is an Integer if q_mag - int(q_mag) > 0: return Expression("Quantity", Real(q_mag), target) else: return Expression("Quantity", Integer(q_mag), target)
class SystemTimeZone(Predefined): """ <dl> <dt>'$SystemTimeZone' <dd> gives the current time zone for the computer system on which Mathics is being run. </dl> >> $SystemTimeZone = ... """ name = "$SystemTimeZone" value = Real(-time.timezone / 3600.0) def evaluate(self, evaluation): return self.value
def apply(self, image, evaluation, options): 'Threshold[image_Image, OptionsPattern[Threshold]]' pixels = image.grayscale().pixels method = self.get_option(options, 'Method', evaluation) method_name = method.get_string_value() if isinstance( method, String) else method.to_python() if method_name == 'Cluster': threshold = skimage.filters.threshold_otsu(pixels) elif method_name == 'Median': threshold = numpy.median(pixels) elif method_name == 'Mean': threshold = numpy.mean(pixels) else: return evaluation.message('Threshold', 'illegalmethod', method) return Real(threshold)
def apply_pair(self, text1, i1, text2, i2, evaluation, options): 'WordSimilarity[{text1_String, i1_}, {text2_String, i2_}, OptionsPattern[%(name)s]]' doc1 = self._nlp(text1.get_string_value(), evaluation, options) if doc1: if text2.get_string_value() == text1.get_string_value(): doc2 = doc1 else: doc2 = self._nlp(text2.get_string_value(), evaluation, options) if doc2: if i1.get_head_name() == 'System`List' and i2.get_head_name( ) == 'System`List': if len(i1.leaves) != len(i2.leaves): evaluation.message('TextSimilarity', 'idxfmt') return if any(not all(isinstance(i, Integer) for i in l.leaves) for l in (i1, i2)): evaluation.message('TextSimilarity', 'idxfmt') return indices1 = [i.get_int_value() for i in i1.leaves] indices2 = [i.get_int_value() for i in i2.leaves] multiple = True elif isinstance(i1, Integer) and isinstance(i2, Integer): indices1 = [i1.get_int_value()] indices2 = [i2.get_int_value()] multiple = False else: evaluation.message('TextSimilarity', 'idxfmt') return for index1, index2 in zip(indices1, indices2): for i, pos, doc in zip((index1, index2), (1, 2), (doc1, doc2)): if i < 1 or i > len(doc): evaluation.message('TextSimilarity', 'txtidx', i, pos, len(doc)) return result = [ Real(doc1[j1 - 1].similarity(doc2[j2 - 1])) for j1, j2 in zip(indices1, indices2) ] if multiple: return Expression('List', *result) else: return result[0]