LogLib

5月3日

Library "LogLib"
LogLib — unified logger with BUFFERED / PER_BAR / OFF modes,
bit-packed plot encoders, perf timing (tick/tock), load timer.
Step 2 patch: enum LogMode + LogLevel, method-first API, preserved facades.

f_logger_mode_off()

f_logger_mode_buffered()

f_logger_mode_stream()

f_logger_mode_per_bar()

f_q_unsigned(x, scale, maxv)
  Quantize unsigned float to N-bit integer
  Parameters:
    x (float)
    scale (float)
    maxv (int)

f_q_signed(x, scale, bias, maxv)
  Quantize signed float to N-bit integer with bias offset
  Parameters:
    x (float)
    scale (float)
    bias (int)
    maxv (int)

f_pack3x10(a, b, c)
  Pack three 10-bit values into single float for data window
  Parameters:
    a (int)
    b (int)
    c (int)

f_pack4x8(a, b, c, d)
  Pack four 8-bit values into single float for data window
  Parameters:
    a (int)
    b (int)
    c (int)
    d (int)

f_unpack3x10_a(packed)
  Parameters:
    packed (int)

f_unpack3x10_b(packed)
  Parameters:
    packed (int)

f_unpack3x10_c(packed)
  Parameters:
    packed (int)

f_unpack4x8_a(packed)
  Parameters:
    packed (int)

f_unpack4x8_b(packed)
  Parameters:
    packed (int)

f_unpack4x8_c(packed)
  Parameters:
    packed (int)

f_unpack4x8_d(packed)
  Parameters:
    packed (int)

f_encode_flags(s0, s1, s2, s3, s4, s5, s6, s7)
  Encode 8 binary flags into 8-bit int
  Parameters:
    s0 (bool)
    s1 (bool)
    s2 (bool)
    s3 (bool)
    s4 (bool)
    s5 (bool)
    s6 (bool)
    s7 (bool)

f_encode_ternary(s0, s1, s2, s3, s4)
  Encode 5 ternary states (0,1,2) into base-3 integer
  Parameters:
    s0 (int)
    s1 (int)
    s2 (int)
    s3 (int)
    s4 (int)

f_decode_flag(encoded, bit_index)
  Parameters:
    encoded (int)
    bit_index (int)

f_decode_ternary(encoded, state_index)
  Parameters:
    encoded (int)
    state_index (int)

f_logger_new(mode, label, header, max_lines)
  Initialize Logger (legacy signature, preserved)
  Parameters:
    mode (simple int): 0=OFF/STREAM-alias, 1=BUFFERED, 2=PER_BAR
    label (simple string)
    header (simple string)
    max_lines (simple int)

f_logger_new_enum(mode, label, header, max_lines)
  Enum-aware factory (preferred for new code)
  Parameters:
    mode (simple LogMode)
    label (simple string)
    header (simple string)
    max_lines (simple int)

f_new_logger_buffered(label, header)
  Quick BUFFERED logger with default thresholds (4000 chars / 2500 lines)
  Parameters:
    label (simple string)
    header (simple string)

f_new_logger_per_bar(label, header)
  Quick PER_BAR logger
  Parameters:
    label (simple string)
    header (simple string)

f_new_logger_off()
  Quick OFF logger (no-op, for production builds)

method append(l, row)
  Append a row to the log; routes by mode.
Details OFF: discarded. BUFFERED: auto-flush when chars/lines threshold hit.
PER_BAR: caller must invoke flush() on barstate.isconfirmed.
  Namespace types: Logger
  Parameters:
    l (Logger)
    row (string)

method flush(l)
  Explicit flush — drains any non-empty buffer.
Details Does NOT depend on barstate.islast. Caller invokes at natural
boundaries (RCOM completion, manual checkpoint, barstate.isconfirmed
for PER_BAR). BUFFERED mode primary flush remains automatic via append().
  Namespace types: Logger
  Parameters:
    l (Logger)

method reset(l)
  Reset buffer without flushing (drops accumulated content)
  Namespace types: Logger
  Parameters:
    l (Logger)

method kv(l, key, val)
  Append key=value diagnostic line
  Namespace types: Logger
  Parameters:
    l (Logger)
    key (string)
    val (float)

method event(l, event_type, payload)
  Append tagged event with bar_index prefix
  Namespace types: Logger
  Parameters:
    l (Logger)
    event_type (string)
    payload (string)

method debug(l, msg)
  Severity-tagged writers (level prefix added)
  Namespace types: Logger
  Parameters:
    l (Logger)
    msg (string)

method info(l, msg)
  Namespace types: Logger
  Parameters:
    l (Logger)
    msg (string)

method warn(l, msg)
  Namespace types: Logger
  Parameters:
    l (Logger)
    msg (string)

method error(l, msg)
  ERROR — appends + immediate flush (drains accumulated buffer too)
  Namespace types: Logger
  Parameters:
    l (Logger)
    msg (string)

method tick(l, tag)
  Namespace types: Logger
  Parameters:
    l (Logger)
    tag (string)

method tock(l, tag)
  Namespace types: Logger
  Parameters:
    l (Logger)
    tag (string)

method get_last_timing(l)
  Namespace types: Logger
  Parameters:
    l (Logger)

f_load_timer_new()

method update(lt)
  Namespace types: LoadTimer
  Parameters:
    lt (LoadTimer)

method get_time(lt)
  Namespace types: LoadTimer
  Parameters:
    lt (LoadTimer)

method get_formatted(lt)
  Namespace types: LoadTimer
  Parameters:
    lt (LoadTimer)

method get_color(lt)
  Namespace types: LoadTimer
  Parameters:
    lt (LoadTimer)

method log_time(lt, prefix)
  Namespace types: LoadTimer
  Parameters:
    lt (LoadTimer)
    prefix (string)

method log_to_logger(lt, logger)
  Namespace types: LoadTimer
  Parameters:
    lt (LoadTimer)
    logger (Logger)

method add_to_table(lt, t, col, row)
  Namespace types: LoadTimer
  Parameters:
    lt (LoadTimer)
    t (table)
    col (int)
    row (int)

Logger
  Logger state. Mode field stays int for backward compat with persisted
  Fields:
    mode (series int): 0=OFF, 1=BUFFERED, 2=PER_BAR (matches LogMode ordinal)
    buffer (series string)
    line_count (series int)
    max_lines (series int)
    max_chars (series int)
    header (series string)
    header_written (series bool)
    label (series string)
    markers (map<string, int>)
    last_delta_ms (series float)
    last_tag (series string)

LoadTimer
  Fields:
    start_ms (series int)
    load_secs_latched (series float)
    captured (series bool)

5月3日

版本注释

v2

Added:
f_json_field_str(key, val)
  Build JSON field: "key":value (string value)
  Parameters:
    key (string): Field name
    val (string): String value (will be escaped)
  Returns: JSON field string

f_json_field_num(key, val)
  Build JSON field: "key":value (numeric value)
  Parameters:
    key (string): Field name
    val (float): Numeric value (na becomes null)
  Returns: JSON field string

f_json_field_int(key, val)
  Build JSON field: "key":value (integer value)
  Parameters:
    key (string): Field name
    val (int): Integer value
  Returns: JSON field string

f_json_field_bool(key, val)
  Build JSON field: "key":value (boolean value)
  Parameters:
    key (string): Field name
    val (bool): Boolean value
  Returns: JSON field string

f_debug_json(tag, fields)
  Build complete JSON object for debug alerts
  Parameters:
    tag (string): Debug tag (DBG_* identifier)
    fields (array<string>): Array of pre-built JSON fields from f_json_field_*
  Returns: Complete JSON string with standard metadata

5月3日

版本注释

v3

Updated:
f_debug_json(source, tag, fields)
  Build complete JSON object for debug alerts
  Parameters:
    source (string): Source identifier (indicator name/version for MCP filtering)
    tag (string): Debug tag (DBG_* identifier)
    fields (array<string>): Array of pre-built JSON fields from f_json_field_*
  Returns: Complete JSON string with standard metadata

7天前

版本注释

v4

Added:
f_inspector_new(enabled, startTime, endTime, rangeMode, title)
  Parameters:
    enabled (bool)
    startTime (int)
    endTime (int)
    rangeMode (bool)
    title (string)

method scan(self, atrLen)
  Namespace types: Inspector
  Parameters:
    self (Inspector)
    atrLen (simple int)

method add(self, onTarget, name, value)
  Namespace types: Inspector
  Parameters:
    self (Inspector)
    onTarget (bool)
    name (string)
    value (string)

method commit(self, onTarget, compact)
  Namespace types: Inspector
  Parameters:
    self (Inspector)
    onTarget (bool)
    compact (bool)

method render(self, maxRows, lineColor, labelColor, txtColor)
  Namespace types: Inspector
  Parameters:
    self (Inspector)
    maxRows (int)
    lineColor (color)
    labelColor (color)
    txtColor (color)

method log_to_console(self)
  Namespace types: Inspector
  Parameters:
    self (Inspector)

LogRow
  Per-bar log entry captured inside the range
  Fields:
    idx (series int): bar_index of the captured bar
    hi (series float): high of the captured bar
    lo (series float): low of the captured bar
    body (series string): pre-built multiline body for this bar

Inspector
  Inspector state container
  Fields:
    active (series bool): Master on/off
    rangeMode (series bool): false = single bar, true = bar range
    tgTime (series int): Start (or single) target time (ms)
    tgTime2 (series int): End time for range mode (ms)
    atr (series float): ATR for vertical spacing
    title (series string): Label header
    names (array<string>): Current-bar logged names (transient buffer)
    vals (array<string>): Current-bar logged values (transient buffer)
    rows (array<LogRow>): Captured rows (range mode → many; single → one)

Updated:
f_json_field_str(key, val)
  Parameters:
    key (string)
    val (string)

f_json_field_num(key, val)
  Parameters:
    key (string)
    val (float)

f_json_field_int(key, val)
  Parameters:
    key (string)
    val (int)

f_json_field_bool(key, val)
  Parameters:
    key (string)
    val (bool)

f_debug_json(source, tag, fields)
  Parameters:
    source (string)
    tag (string)
    fields (array<string>)

7天前

版本注释

v5

Added:
f_label_cfg(nfeat, kind, tgtHigh, tgtLow, tgtReject, qLo, qHi, csvSafeMax, featPrec, autoResolve)
  Parameters:
    nfeat (simple int)
    kind (simple CaptureKind)
    tgtHigh (simple float)
    tgtLow (simple float)
    tgtReject (simple float)
    qLo (simple float)
    qHi (simple float)
    csvSafeMax (simple int)
    featPrec (simple int)
    autoResolve (simple bool)

f_label_store_new(cfg)
  Parameters:
    cfg (LabelCfg)

method add_target(self, tms, cls)
  Namespace types: LabelStore
  Parameters:
    self (LabelStore)
    tms (int)
    cls (series LabelClass)

method add_range(self, tStart, tEnd, cls)
  Namespace types: LabelStore
  Parameters:
    self (LabelStore)
    tStart (int)
    tEnd (int)
    cls (series LabelClass)

method feed_pivot(self, isHigh, pivotBar)
  Namespace types: LabelStore
  Parameters:
    self (LabelStore)
    isHigh (bool)
    pivotBar (int)

method capture(self, feats, hi, lo, atr)
  Namespace types: LabelStore
  Parameters:
    self (LabelStore)
    feats (array<float>)
    hi (float)
    lo (float)
    atr (float)

method finalize(self)
  Namespace types: LabelStore
  Parameters:
    self (LabelStore)

method count(self, clsFilter)
  Namespace types: LabelStore
  Parameters:
    self (LabelStore)
    clsFilter (int)

method highs(self)
  Namespace types: LabelStore
  Parameters:
    self (LabelStore)

method lows(self)
  Namespace types: LabelStore
  Parameters:
    self (LabelStore)

method row_csv(self, s)
  Namespace types: LabelStore
  Parameters:
    self (LabelStore)
    s (LabSample)

method to_csv(self)
  Namespace types: LabelStore
  Parameters:
    self (LabelStore)

method q8(self, f)
  Namespace types: LabelStore
  Parameters:
    self (LabelStore)
    f (float)

method to_q8(self)
  Namespace types: LabelStore
  Parameters:
    self (LabelStore)

method export_auto(self, source, alertOn, logOn, logger)
  Namespace types: LabelStore
  Parameters:
    self (LabelStore)
    source (string)
    alertOn (bool)
    logOn (bool)
    logger (Logger)

method export_one(self, source, slotId, alertOn, logOn, logger)
  Namespace types: LabelStore
  Parameters:
    self (LabelStore)
    source (string)
    slotId (int)
    alertOn (bool)
    logOn (bool)
    logger (Logger)

LabSample
  One labeled sample. Features copied at capture (no lookback).
  Fields:
    slotId (series int): STABLE id == target registration order; downstream diff key
    cls (series int): LabelClass ordinal resolved at finalize()
    target (series float): Numeric target: HIGH=+1, LOW=-1, REJECT/NEUTRAL=0 (configurable)
    idx (series int): bar_index at capture
    tms (series int): time (ms) at capture
    hi (series float)
    lo (series float)
    atr (series float): atr at capture (spacing/QC)
    feats (array<float>): copied feature vector (length == cfg.nfeat)
    rangeId (series int): range group id (RANGE mode), else -1

LabTarget
  Pending target spec registered by the host before capture.
  Fields:
    slotId (series int): stable registration index (diff key)
    tStart (series int): start (or single) time in ms
    tEnd (series int): end time in ms (RANGE only; na for point targets)
    cls (series int): user-chosen LabelClass (AUTO triggers pivot resolution)
    matched (series bool): true once a bar matched (point targets, dedup)
    rangeId (series int): stable id for RANGE grouping

LabelCfg
  Configuration for the labeling engine. All knobs live here.
  Fields:
    nfeat (series int)
    kind (series int)
    tgtHigh (series float)
    tgtLow (series float)
    tgtReject (series float)
    qLo (series float)
    qHi (series float)
    csvSafeMax (series int)
    featPrec (series int)
    autoResolve (series bool)

LabelStore
  Engine state.
  Fields:
    cfg (LabelCfg)
    targets (array<LabTarget>)
    samples (array<LabSample>)
    pivHigh (array<int>)
    pivLow (array<int>)
    rangeSeq (series int)

Updated:
method render(self, maxRows)
  Namespace types: LabelStore
  Parameters:
    self (LabelStore)
    maxRows (int)

LogRow
  Per-bar log entry captured inside the range
  Fields:
    idx (series int)
    hi (series float)
    lo (series float)
    body (series string)

Inspector
  Inspector state container
  Fields:
    active (series bool)
    rangeMode (series bool)
    tgTime (series int)
    tgTime2 (series int)
    atr (series float)
    title (series string)
    names (array<string>)
    vals (array<string>)
    rows (array<LogRow>)

7天前

版本注释

v6

7天前

版本注释

v7

7天前

版本注释

v8

7天前

版本注释

v9

10小时前

版本注释

v10

Added:
mem_array_int(a)
  Count memory units for array<int>
  Parameters:
    a (array<int>): Array to measure
  Returns: int Number of memory units (1 per element)

mem_array_float(a)
  Count memory units for array<float>
  Parameters:
    a (array<float>): Array to measure
  Returns: int Number of memory units (1 per element)

mem_array_bool(a)
  Count memory units for array<bool>
  Parameters:
    a (array<bool>): Array to measure
  Returns: int Number of memory units (1 per element)

mem_array_string(a)
  Count memory units for array<string>
  Parameters:
    a (array<string>): Array to measure
  Returns: int Number of memory units (1 per element)

mem_udt_array(size, fields_per_object, overhead_per_object)
  Count memory units for array of UDT objects with overhead
  Parameters:
    size (int): Array size (use array.size(your_array))
    fields_per_object (int): Number of fields in UDT
    overhead_per_object (int): Object overhead (default 2 for medium UDT)
  Returns: int Total memory units = size × (fields + overhead)
Example type W3LtfBar has 6 fields (o,h,l,c,v,t) + ~2 overhead = 8 units per object
array<W3LtfBar> rqCur with 50 elements = 50 × 8 = 400 units
units = mem_udt_array(array.size(rqCur), 6, 2)

mem_ltfbar_array(size)
  Count memory units for array<W3LtfBar> (6 fields + 2 overhead = 8)
  Parameters:
    size (int): Array size
  Returns: int Memory units (size × 8)

mem_liqbar_array(size)
  Count memory units for array<W3LiqBar> (2 fields + 1 overhead = 3)
  Parameters:
    size (int): Array size
  Returns: int Memory units (size × 3)

mem_map_int_float(m)
  Count memory units for map<int, float>
  Parameters:
    m (map<int, float>): Map to measure
  Returns: int Memory units (size × 2, key + value per entry)

mem_map_int_int(m)
  Count memory units for map<int, int>
  Parameters:
    m (map<int, int>): Map to measure
  Returns: int Memory units (size × 2, key + value per entry)

mem_map_string_float(m)
  Count memory units for map<string, float>
  Parameters:
    m (map<string, float>): Map to measure
  Returns: int Memory units (size × 2, key + value per entry)

mem_map_generic(size)
  Count memory units for any map (generic)
  Parameters:
    size (int): Map size (use map.size(your_map))
  Returns: int Memory units (size × 2, key + value per entry)

mem_array_of_arrays(container_size, inner_units_total)
  Count memory units for array of arrays (e.g., array<RollSlot>)
  Parameters:
    container_size (int): Size of outer array
    inner_units_total (int): Total units from all inner arrays (pre-calculated)
  Returns: int Total units = container overhead + sum of inner units
Example type RollSlot has 3 arrays: rowId, buy, sell
array<RollSlot> rollSlots with 7 slots
Step 1: Calculate inner units for each slot
int inner_total = 0
for i = 0 to 6
RollSlot s = array.get(rollSlots, i)
inner_total += array.size(s.rowId) + array.size(s.buy) + array.size(s.sell)
Step 2: Add container overhead
units = mem_array_of_arrays(7, inner_total)

mem_bucket_pack(rowId_size, lo_size, hi_size, buy_size, sell_size, liqBuy_size, liqSell_size)
  Count memory units for W3BucketPack UDT
  Parameters:
    rowId_size (int): Size of rowId array
    lo_size (int): Size of lo array
    hi_size (int): Size of hi array
    buy_size (int): Size of buy array
    sell_size (int): Size of sell array
    liqBuy_size (int): Size of liqBuy array
    liqSell_size (int): Size of liqSell array
  Returns: int Total units (7 arrays + 5 scalar fields)

mem_rollslot(rowId_size, buy_size, sell_size)
  Count memory units for RollSlot UDT
  Parameters:
    rowId_size (int): Size of rowId array
    buy_size (int): Size of buy array
    sell_size (int): Size of sell array
  Returns: int Total units (3 arrays)

mem_sgd_model(n_features)
  Estimate memory units for SGD model (opaque library structure)
  Parameters:
    n_features (int): Number of features
  Returns: int Approximate units (n_features × 4 for weights + gradients + momentum + variance)

mem_scaler_model(n_features)
  Estimate memory units for Scaler model (opaque library structure)
  Parameters:
    n_features (int): Number of features
  Returns: int Approximate units (n_features × 2 for min + max per feature)

3小时前

版本注释

v11

Added:
mem_footprint_floor(gatedBars, rangePrice, ticksPerRow, liveRows)
  Footprint-context floor estimator.
Details request.footprint context is pre-paid across the GATED bar span.
rows/bar = price_range / (ticksPerRow × mintick).
Returns max(model, live_snapshot) so the cell never under-reports.
  Parameters:
    gatedBars (int): Bars where the if-gate lets footprint allocate (iwarmup + intebars).
    rangePrice (float): Price envelope used for row count estimate (scanHi - scanLo).
    ticksPerRow (int): fpTicksPerRow actually passed to request.footprint.
    liveRows (int): array.size(fp.rows()) on the current bar (0 outside gate is fine).
  Returns: int Floor units = max(gated_model, live_snapshot) × 7 fields.

mem_ledger_new()
  Create a new empty MemLedger.

method put(m, name, units, note, gated)
  Add or update a row by name (idempotent — safe to call every bar).
  Namespace types: MemLedger
  Parameters:
    m (MemLedger): The ledger.
    name (string): Row identifier.
    units (int): Current memory units.
    note (string): Optional detail string (e.g. "27r", "500b").
    gated (bool): true = floor-tier consumer.

method seal(m)
  Recompute total from all rows. Call once after all puts().
  Namespace types: MemLedger
  Parameters:
    m (MemLedger)

method thief(m)
  Return [name, units] of the largest single consumer.
  Namespace types: MemLedger
  Parameters:
    m (MemLedger)

method to_line(m, barIdx)
  Serialize ledger to a CSV line for the diag logger.
Details Replaces MEMUNITS + MEMFLOOR log blocks with a single call.
  Namespace types: MemLedger
  Parameters:
    m (MemLedger)
    barIdx (int): bar_index to prefix.

method to_table(m, t, startRow, floorCol, featCol)
  Render the ledger into a table, replacing all inlined table.cell mem rows.
  Namespace types: MemLedger
  Parameters:
    m (MemLedger): The ledger.
    t (table): Target table (must be pre-created by caller).
    startRow (int): First row index in the table to write into.
    floorCol (color): Color for floor-tier (gated=true) name labels.
    featCol (color): Color for feature-tier (gated=false) name labels.

MemRow
  One row in the memory ledger: a named consumer with units, peak, and metadata.
  Fields:
    name (series string): Short name shown in table col 0.
    units (series int): Current memory units this tick.
    peak (series int): Realtime high-water mark (survives across ticks when MemLedger is var).
    note (series string): Capacity / detail text for table col 2.
    gated (series bool): true = floor-tier (always-on); false = feature-gated.

MemLedger
  Memory ledger: holds a list of MemRows and their summed total.
  Fields:
    rows (array<MemRow>): Ordered list of MemRow entries.
    total (series int): Recomputed by seal() after all puts.

3小时前

版本注释

v12