relationalai 0.13.0__py3-none-any.whl → 0.13.0.dev0__py3-none-any.whl

v0/relationalai/semantics/std/datetime.py

@@ -0,0 +1,363 @@
+from __future__ import annotations
+from typing import Union, Literal
+import datetime as dt
+
+from v0.relationalai.semantics.internal import internal as b
+from .std import _DateTime, _Date, _Integer, _String, _make_expr
+from .. import std
+
+class ISO:
+    DATE = "yyyy-mm-dd"
+    HOURS = "yyyy-mm-ddTHH"
+    HOURS_TZ = "yyyy-mm-ddTHHz"
+    MINUTES = "yyyy-mm-ddTHH:MM"
+    MINUTES_TZ = "yyyy-mm-ddTHH:MMz"
+    SECONDS = "yyyy-mm-ddTHH:MM:SS"
+    SECONDS_TZ = "yyyy-mm-ddTHH:MM:SSz"
+    MILLIS = "yyyy-mm-ddTHH:MM:SS.s"
+    MILLIS_TZ = "yyyy-mm-ddTHH:MM:SS.sz"
+
+#--------------------------------------------------
+# Date functions
+#--------------------------------------------------
+
+class date:
+
+    def __new__(cls, year: _Integer, month: _Integer, day: _Integer) -> b.Expression:
+        return _make_expr("construct_date", std.cast_to_int64(year), std.cast_to_int64(month), std.cast_to_int64(day), b.Date.ref("res"))
+
+    @classmethod
+    def year(cls, date: _Date) -> b.Expression:
+        return _make_expr("date_year", date, b.Int64.ref("res"))
+
+    @classmethod
+    def quarter(cls, date: _Date) -> b.Expression:
+        return _make_expr("date_quarter", date, b.Int64.ref("res"))
+
+    @classmethod
+    def month(cls, date: _Date) -> b.Expression:
+        return _make_expr("date_month", date, b.Int64.ref("res"))
+
+    @classmethod
+    def week(cls, date: _Date) -> b.Expression:
+        return _make_expr("date_week", date, b.Int64.ref("res"))
+
+    @classmethod
+    def day(cls, date: _Date) -> b.Expression:
+        return _make_expr("date_day", date, b.Int64.ref("res"))
+
+    @classmethod
+    def dayofyear(cls, date: _Date) -> b.Expression:
+        return _make_expr("date_dayofyear", date, b.Int64.ref("res"))
+
+    @classmethod
+    def isoweekday(cls, date: _Date) -> b.Expression:
+        """
+        Return the ISO weekday as an integer, where Monday is 1, and Sunday is 7.
+        """
+        return _make_expr("date_weekday", date, b.Int64.ref("res"))
+
+    @classmethod
+    def weekday(cls, date: _Date) -> b.Expression:
+        return cls.isoweekday(date) - 1 # Convert ISO weekday (1=Mon..7=Sun) to weekday (0=Mon..6=Sun)
+
+    @classmethod
+    def fromordinal(cls, ordinal: _Integer) -> b.Expression:
+        # ordinal 1 = '0001-01-01'. Minus 1 day since we can't declare date 0000-00-00
+        return cls.add(b.Date(dt.date(1, 1, 1)), days(ordinal - 1))
+
+    @classmethod
+    def to_datetime(cls, date: _Date, hour: int = 0, minute: int = 0, second: int = 0, millisecond: int = 0, tz: str = "UTC") -> b.Expression:
+        _year = cls.year(date)
+        _month = cls.month(date)
+        _day = cls.day(date)
+        return _make_expr("construct_datetime_ms_tz", _year, _month, _day, hour, minute, second, millisecond, tz, b.DateTime.ref("res"))
+
+    @classmethod
+    def format(cls, date: _Date, format: _String) -> b.Expression:
+        return _make_expr("date_format", date, format, b.String.ref("res"))
+
+    @classmethod
+    def add(cls, date: _Date, period: b.Producer) -> b.Expression:
+        return _make_expr("date_add", date, period, b.Date.ref("res"))
+
+    @classmethod
+    def subtract(cls, date: _Date, period: b.Producer) -> b.Expression:
+        return _make_expr("date_subtract", date, period, b.Date.ref("res"))
+
+    @classmethod
+    def range(cls, start: _Date | None = None, end: _Date | None = None, periods: int = 1, freq: Frequency = "D") -> b.Expression:
+        """
+        Note on date_ranges and datetime_range: The way the computation works is that it first overapproximates the
+        number of periods.
+
+        For example, date_range(2025-02-01, 2025-03-01, freq='M') and date_range(2025-02-01, 2025-03-31, freq='M') will
+        compute range_end to be ceil(28*1/(365/12))=1 and ceil(58*1/(365/12))=2.
+
+        Then, the computation fetches range_end+1 items into _date, which is the right number in the first case but
+        one too many in the second case. That's why a filter end >= _date (or variant of) is applied, to remove any
+        extra item. The result is two items in both cases.
+        """
+        if start is None and end is None:
+            raise ValueError("Invalid start/end date for date_range. Must provide at least start date or end date")
+        _days = {
+            "D": 1,
+            "W": 1/7,
+            "M": 1/(365/12),
+            "Y": 1/365,
+        }
+        if freq not in _days.keys():
+            raise ValueError(f"Frequency '{freq}' is not allowed for date_range. List of allowed frequencies: {list(_days.keys())}")
+        date_func = cls.add
+        if start is None:
+            start = end
+            end = None
+            date_func = cls.subtract
+        assert start is not None
+        if end is not None:
+            num_days = cls.period_days(start, end)
+            if freq in ["W", "M", "Y"]:
+                range_end = std.cast(b.Int64, std.math.ceil(num_days * _days[freq]))
+            else:
+                range_end = num_days
+            # date_range is inclusive. add 1 since std.range is exclusive
+            ix = std.range(0, range_end + 1, 1)
+        else:
+            ix = std.range(0, periods, 1)
+        _date = date_func(start, _periods[freq](ix))
+        if isinstance(end, dt.date) :
+            return b.Date(end) >= _date
+        elif end is not None:
+            return end >= _date
+        return _date
+
+    @classmethod
+    def period_days(cls, start: _Date, end: _Date) -> b.Expression:
+        return _make_expr("dates_period_days", start, end, b.Int64.ref("res"))
+
+    @classmethod
+    def fromisoformat(cls, date_string: _String) -> b.Expression:
+        return _make_expr("parse_date", date_string, ISO.DATE, b.Date.ref("res"))
+
+#--------------------------------------------------
+# DateTime functions
+#--------------------------------------------------
+
+class datetime:
+
+    def __new__(cls, year: _Integer, month: _Integer, day: _Integer, hour: _Integer = 0, minute: _Integer = 0,
+             second: _Integer = 0, millisecond: _Integer = 0, tz: dt.tzinfo|_String = "UTC") -> b.Expression:
+        if isinstance(tz, dt.tzinfo):
+            tz = str(tz)
+        return _make_expr("construct_datetime_ms_tz", std.cast_to_int64(year), std.cast_to_int64(month),
+                          std.cast_to_int64(day), std.cast_to_int64(hour), std.cast_to_int64(minute),
+                          std.cast_to_int64(second), std.cast_to_int64(millisecond), tz, b.DateTime.ref("res"))
+
+    @classmethod
+    def now(cls) -> b.Expression:
+        return _make_expr("datetime_now", b.DateTime.ref("res"))
+
+    @classmethod
+    def year(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("datetime_year", datetime, tz, b.Int64.ref("res"))
+
+    @classmethod
+    def quarter(cls, datetime: _DateTime,  tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("datetime_quarter", datetime, tz, b.Int64.ref("res"))
+
+    @classmethod
+    def month(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("datetime_month", datetime, tz, b.Int64.ref("res"))
+
+    @classmethod
+    def week(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("datetime_week", datetime, tz, b.Int64.ref("res"))
+
+    @classmethod
+    def day(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("datetime_day", datetime, tz, b.Int64.ref("res"))
+
+    @classmethod
+    def dayofyear(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("datetime_dayofyear", datetime, tz, b.Int64.ref("res"))
+
+    @classmethod
+    def hour(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("datetime_hour", datetime, tz, b.Int64.ref("res"))
+
+    @classmethod
+    def minute(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("datetime_minute", datetime, tz, b.Int64.ref("res"))
+
+    @classmethod
+    def second(cls, datetime: _DateTime) -> b.Expression:
+        return _make_expr("datetime_second", datetime, b.Int64.ref("res"))
+
+    @classmethod
+    def isoweekday(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        """
+        Return the ISO weekday as an integer, where Monday is 1, and Sunday is 7.
+        """
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("datetime_weekday", datetime, tz, b.Int64.ref("res"))
+
+    @classmethod
+    def weekday(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        return cls.isoweekday(datetime, tz) - 1 # Convert ISO weekday (1=Mon..7=Sun) to weekday (0=Mon..6=Sun)
+
+    @classmethod
+    def fromordinal(cls, ordinal: _Integer) -> b.Expression:
+        # Convert ordinal to milliseconds, since ordinals in Python are days
+        # Minus 1 day since we can't declare date 0000-00-00
+        ordinal_milliseconds = (ordinal - 1) * 86400000 # 24 * 60 * 60 * 1000
+        return cls.add(b.DateTime(dt.datetime(1, 1, 1, 0, 0, 0)), milliseconds(ordinal_milliseconds))
+
+    @classmethod
+    def strptime(cls, date_str: _String, format: _String) -> b.Expression:
+        return _make_expr("parse_datetime", date_str, format, b.DateTime.ref("res"))
+
+    @classmethod
+    def to_date(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(datetime, tz)
+        return _make_expr("construct_date_from_datetime", datetime, tz, b.Date.ref("res"))
+
+    @classmethod
+    def format(cls, date: _DateTime, format: _String, tz: dt.tzinfo|_String|None = None) -> b.Expression:
+        tz = _extract_tz(date, tz)
+        return _make_expr("datetime_format", date, format, tz, b.String.ref("res"))
+
+    @classmethod
+    def add(cls, date: _DateTime, period: b.Producer) -> b.Expression:
+        return _make_expr("datetime_add", date, period, b.DateTime.ref("res"))
+
+    @classmethod
+    def subtract(cls, date: _DateTime, period: b.Producer) -> b.Expression:
+        return _make_expr("datetime_subtract", date, period, b.DateTime.ref("res"))
+
+    @classmethod
+    def range(cls, start: _DateTime | None = None, end: _DateTime | None = None, periods: int = 1, freq: Frequency = "D") -> b.Expression:
+        """
+        Note on date_ranges and datetime_range: The way the computation works is that it first overapproximates the
+        number of periods.
+
+        For example, date_range(2025-02-01, 2025-03-01, freq='M') and date_range(2025-02-01, 2025-03-31, freq='M') will
+        compute range_end to be ceil(28*1/(365/12))=1 and ceil(58*1/(365/12))=2.
+
+        Then, the computation fetches range_end+1 items into _date, which is the right number in the first case but
+        one too many in the second case. That's why a filter end >= _date (or variant of) is applied, to remove any
+        extra item. The result is two items in both cases.
+        """
+        if start is None and end is None:
+            raise ValueError("Invalid start/end datetime for datetime_range. Must provide at least start datetime or end datetime")
+        _milliseconds = {
+            "ms": 1,
+            "s": 1 / 1_000,
+            "m": 1 / 60_000,
+            "H": 1 / 3_600_000,
+            "D": 1 / 86_400_000,
+            "W": 1 / (86_400_000 * 7),
+            "M": 1 / (86_400_000 * (365 / 12)),
+            "Y": 1 / (86_400_000 * 365),
+        }
+        date_func = cls.add
+        if start is None:
+            start = end
+            end = None
+            date_func = cls.subtract
+        assert start is not None
+        if end is not None:
+            num_ms = cls.period_milliseconds(start, end)
+            if freq == "ms":
+                _end = num_ms
+            else:
+                _end = std.cast(b.Int64, std.math.ceil(num_ms * _milliseconds[freq]))
+            # datetime_range is inclusive. add 1 since std.range is exclusive
+            ix = std.range(0, _end + 1, 1)
+        else:
+            ix = std.range(0, periods, 1)
+        _date = date_func(start, _periods[freq](ix))
+        if isinstance(end, dt.datetime) :
+            return b.DateTime(end) >= _date
+        elif end is not None:
+            return end >= _date
+        return _date
+
+    @classmethod
+    def period_milliseconds(cls, start: _DateTime, end: _DateTime) -> b.Expression:
+        return _make_expr("datetimes_period_milliseconds", start, end, b.Int64.ref("res"))
+
+#--------------------------------------------------
+# Periods
+#--------------------------------------------------
+
+def nanoseconds(period: _Integer) -> b.Expression:
+    return _make_expr("nanosecond", std.cast_to_int64(period), b.Int64.ref("res"))
+
+def microseconds(period: _Integer) -> b.Expression:
+    return _make_expr("microsecond", std.cast_to_int64(period), b.Int64.ref("res"))
+
+def milliseconds(period: _Integer) -> b.Expression:
+    return _make_expr("millisecond", std.cast_to_int64(period), b.Int64.ref("res"))
+
+def seconds(period: _Integer) -> b.Expression:
+    return _make_expr("second", std.cast_to_int64(period), b.Int64.ref("res"))
+
+def minutes(period: _Integer) -> b.Expression:
+    return _make_expr("minute", std.cast_to_int64(period), b.Int64.ref("res"))
+
+def hours(period: _Integer) -> b.Expression:
+    return _make_expr("hour", std.cast_to_int64(period), b.Int64.ref("res"))
+
+def days(period: _Integer) -> b.Expression:
+    return _make_expr("day", std.cast_to_int64(period), b.Int64.ref("res"))
+
+def weeks(period: _Integer) -> b.Expression:
+    return _make_expr("week", std.cast_to_int64(period), b.Int64.ref("res"))
+
+def months(period: _Integer) -> b.Expression:
+    return _make_expr("month", std.cast_to_int64(period), b.Int64.ref("res"))
+
+def years(period: _Integer) -> b.Expression:
+    return _make_expr("year", std.cast_to_int64(period), b.Int64.ref("res"))
+
+
+Frequency = Union[
+    Literal["ms"],
+    Literal["s"],
+    Literal["m"],
+    Literal["H"],
+    Literal["D"],
+    Literal["W"],
+    Literal["M"],
+    Literal["Y"],
+]
+
+_periods = {
+    "ms": milliseconds,
+    "s": seconds,
+    "m": minutes,
+    "H": hours,
+    "D": days,
+    "W": weeks,
+    "M": months,
+    "Y": years,
+}
+
+def _extract_tz(datetime: _DateTime, tz: dt.tzinfo|_String|None) -> _String:
+    default_tz = "UTC"
+    if tz is None:
+        if isinstance(datetime, dt.datetime):
+            tz = datetime.tzname() or default_tz
+        else:
+            tz = default_tz
+    elif isinstance(tz, dt.tzinfo) :
+        tz = tz.tzname(None) or default_tz
+    return tz

v0/relationalai/semantics/std/decimals.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+from typing import cast
+from decimal import Decimal as PyDecimal
+from v0.relationalai.semantics.metamodel import ir, types
+from v0.relationalai.semantics.internal import internal as b
+from .std import _make_expr
+
+#--------------------------------------------------
+# Constructors
+#--------------------------------------------------
+
+def decimal(value: b.Producer|int|float|PyDecimal, precision=38, scale=14) -> b.Expression:
+    """
+    Create an expression that represents a decimal with this value, precision and scale.
+    """
+    if isinstance(value, int):
+        value = PyDecimal(str(value))
+    if isinstance(value, float):
+        value = PyDecimal(str(value))
+    return b.ConceptMember(b.decimal_concept(precision, scale), value, {})
+
+def parse_decimal(value: b.Producer|str, precision=38, scale=14) -> b.Expression:
+    """
+    Create an expression that represents parsing this string value as a decimal with this
+    precision and scale.
+    """
+    return _make_expr("parse_decimal", value, b.decimal_concept(precision, scale).ref("res"))
+
+def parse(value: b.Producer|str, decimal: b.Concept) -> b.Expression:
+    """
+    Create an expression that represents parsing this string value as a decimal with the
+    precision and scale of the decimal argument.
+    """
+    return parse_decimal(value, precision(decimal), scale(decimal))
+
+#--------------------------------------------------
+# Decimal information.
+#--------------------------------------------------
+
+def is_decimal(decimal: b.Concept) -> bool:
+    return b.is_decimal(decimal)
+
+def precision(decimal: b.Concept) -> int:
+    """ Assuming the concept represents a decimal, return its precision. """
+    assert b.is_decimal(decimal)
+    typ = cast(ir.DecimalType, types.decimal_by_type_str(decimal._name))
+    return typ.precision
+
+def scale(decimal: b.Concept) -> int:
+    """ Assuming the concept represents a decimal, return its scale. """
+    assert b.is_decimal(decimal)
+    typ = cast(ir.DecimalType, types.decimal_by_type_str(decimal._name))
+    return typ.scale
+
+def size(decimal: b.Concept) -> int:
+    """
+    Assuming the concept represents a decimal, return its size, i.e. the number of bits
+    needed to represent the decimal.
+    """
+    assert b.is_decimal(decimal)
+    typ = cast(ir.DecimalType, types.decimal_by_type_str(decimal._name))
+    return types.digits_to_bits(typ.precision)

v0/relationalai/semantics/std/floats.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from v0.relationalai.semantics.internal import internal as b
+from .std import _make_expr
+
+def parse_float(value: b.Producer|str) -> b.Expression:
+    return _make_expr("parse_float", value, b.Float.ref("res"))

v0/relationalai/semantics/std/integers.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from v0.relationalai.semantics.internal import internal as b
+from .std import _make_expr
+
+# Coerce a number to Int64.
+def int64(value: b.Producer|int) -> b.ConceptMember:
+    return b.ConceptMember(b.Int64, value, {})
+
+# Coerce a number to Int128.
+def int128(value: b.Producer|int) -> b.ConceptMember:
+    return b.ConceptMember(b.Int128, value, {})
+
+def parse_int64(value: b.Producer|str) -> b.Expression:
+    return _make_expr("parse_int64", value, b.Int64.ref("res"))
+
+def parse_int128(value: b.Producer|str) -> b.Expression:
+    return _make_expr("parse_int128", value, b.Int128.ref("res"))
+
+# Alias parse_int128 to parse
+def parse(value: b.Producer|str) -> b.Expression:
+    return parse_int128(value)

v0/relationalai/semantics/std/math.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from v0.relationalai.semantics.internal import internal as b
+from .std import _Number, _make_expr
+from math import pi
+
+def abs(value: _Number) -> b.Expression:
+    return _make_expr("abs", value, b.Number.ref("res"))
+
+def natural_log(value: _Number) -> b.Expression:
+    return _make_expr("natural_log", value, b.Number.ref("res"))
+
+def log(value: _Number, base: _Number | None = None) -> b.Expression:
+    if base is None:
+        return _make_expr("natural_log", value, b.Number.ref("res"))
+    return _make_expr("log", base, value, b.Number.ref("res"))
+
+def log2(value: _Number) -> b.Expression:
+    return _make_expr("log", 2, value, b.Number.ref("res"))
+
+def log10(value: _Number) -> b.Expression:
+    return _make_expr("log10", value, b.Number.ref("res"))
+
+def sqrt(value: _Number) -> b.Expression:
+    return _make_expr("sqrt", value, b.Float.ref("res"))
+
+def maximum(left: _Number, right: _Number) -> b.Expression:
+    return _make_expr("maximum", left, right, b.Number.ref("res"))
+
+def minimum(left: _Number, right: _Number) -> b.Expression:
+    return _make_expr("minimum", left, right, b.Number.ref("res"))
+
+def isinf(value: _Number) -> b.Expression:
+    return _make_expr("isinf", value)
+
+def isnan(value: _Number) -> b.Expression:
+    return _make_expr("isnan", value)
+
+def ceil(value: _Number) -> b.Expression:
+    return _make_expr("ceil", value, b.Number.ref("res"))
+
+def floor(value: _Number) -> b.Expression:
+    return _make_expr("floor", value, b.Number.ref("res"))
+
+def pow(base: _Number, exponent: _Number) -> b.Expression:
+    return _make_expr("pow", base, exponent, b.Float.ref("res"))
+
+def cbrt(value: _Number) -> b.Expression:
+    return _make_expr("cbrt", value, b.Float.ref("res"))
+
+def factorial(value: _Number) -> b.Expression:
+    return _make_expr("factorial", value, b.Number.ref("res"))
+
+def cos(value: _Number) -> b.Expression:
+    return _make_expr("cos", value, b.Float.ref("res"))
+
+def cosh(value: _Number) -> b.Expression:
+    return _make_expr("cosh", value, b.Float.ref("res"))
+
+def acos(value: _Number) -> b.Expression:
+    return _make_expr("acos", value, b.Float.ref("res"))
+
+def acosh(value: _Number) -> b.Expression:
+    return _make_expr("acosh", value, b.Float.ref("res"))
+
+def sin(value: _Number) -> b.Expression:
+    return _make_expr("sin", value, b.Float.ref("res"))
+
+def sinh(value: _Number) -> b.Expression:
+    return _make_expr("sinh", value, b.Float.ref("res"))
+
+def asin(value: _Number) -> b.Expression:
+    return _make_expr("asin", value, b.Float.ref("res"))
+
+def asinh(value: _Number) -> b.Expression:
+    return _make_expr("asinh", value, b.Float.ref("res"))
+
+def tan(value: _Number) -> b.Expression:
+    return _make_expr("tan", value, b.Float.ref("res"))
+
+def tanh(value: _Number) -> b.Expression:
+    return _make_expr("tanh", value, b.Float.ref("res"))
+
+def atan(value: _Number) -> b.Expression:
+    return _make_expr("atan", value, b.Float.ref("res"))
+
+def atanh(value: _Number) -> b.Expression:
+    return _make_expr("atanh", value, b.Float.ref("res"))
+
+def cot(value: _Number) -> b.Expression:
+    return _make_expr("cot", value, b.Float.ref("res"))
+
+def acot(value: _Number) -> b.Expression:
+    return _make_expr("acot", value, b.Float.ref("res"))
+
+def degrees(value: _Number) -> b.Expression:
+    divisor = pi / 180.0
+    return _make_expr("/", value, divisor, b.Float.ref("res"))
+
+def radians(value: _Number) -> b.Expression:
+    divisor = 180.0 / pi
+    return _make_expr("/", value, divisor, b.Float.ref("res"))
+
+def exp(value: _Number) -> b.Expression:
+    return _make_expr("exp", value, b.Float.ref("res"))
+
+def erf(value: _Number) -> b.Expression:
+    return _make_expr("erf", value, b.Float.ref("res"))
+
+def erfinv(value: _Number) -> b.Expression:
+    return _make_expr("erfinv", value, b.Float.ref("res"))
+
+def haversine(x1: _Number, y1: _Number, x2: _Number, y2: _Number, r: _Number) -> b.Expression:
+    # 2 * r * asin[sqrt[sin[(x2 - x1)/2] ^ 2 + cos[x1] * cos[x2] * sin[(y2 - y1) / 2] ^ 2]]
+    # sin[(x2 - x1)/2] ^ 2
+    x_diff = _make_expr("-", x2, x1, b.Float.ref("x_diff"))
+    x_diff2 = _make_expr("/", x_diff, 2.0, b.Float.ref("x_diff2"))
+    sin_x_diff = _make_expr("sin", x_diff2, b.Float.ref("sin_x_diff"))
+    sin_x_pow = _make_expr("pow", sin_x_diff, 2.0, b.Float.ref("sin_x_pow"))
+
+    # cos[x1] * cos[x2]
+    cos_x1 = _make_expr("cos", x1, b.Float.ref("cos_x1"))
+    cos_x2 = _make_expr("cos", x2, b.Float.ref("cos_x2"))
+    cos_x1_x2 = _make_expr("*", cos_x1, cos_x2, b.Float.ref("cos_x1_x2"))
+
+    # sin[(y2 - y1) / 2] ^ 2
+    y_diff = _make_expr("-", y2, y1, b.Float.ref("y_diff"))
+    y_diff2 = _make_expr("/", y_diff, 2.0, b.Float.ref("y_diff2"))
+    sin_y_diff = _make_expr("sin", y_diff2, b.Float.ref("sin_y_diff"))
+    sin_y_pow = _make_expr("pow", sin_y_diff, 2.0, b.Float.ref("sin_y_pow"))
+
+    # cos[x1] * cos[x2] * sin[(y2 - y1) / 2] ^ 2
+    prod = _make_expr("*", cos_x1_x2, sin_y_pow, b.Float.ref("prod"))
+    # sin[(x2 - x1)/2] ^ 2 + cos[x1] * cos[x2] * sin[(y2 - y1) / 2] ^ 2
+    prod_sum = _make_expr("+", sin_x_pow, prod, b.Float.ref("prod_sum"))
+
+    sqrt_val = _make_expr("sqrt", prod_sum, b.Float.ref("sqrt_val"))
+    asin_val = _make_expr("asin", sqrt_val, b.Float.ref("asin_val"))
+    haversine_r = _make_expr("*", r, asin_val, b.Float.ref("haversine_r"))
+    haversine_final = _make_expr("*", haversine_r, 2.0, b.Float.ref("haversine_final"))
+    return haversine_final

v0/relationalai/semantics/std/pragmas.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+from typing import Any
+
+from v0.relationalai.semantics.internal import internal as b
+from .std import _make_expr
+
+def rule_reasoner_semantic_variable_order(*args: Any) -> Any:
+    return _make_expr("rule_reasoner_sem_vo", b.TupleArg(args))
+
+def rule_reasoner_physical_variable_order(*args: Any) -> Any:
+    return _make_expr("rule_reasoner_phys_vo", b.TupleArg(args))