Module: Trxl::StdLib

Included in:

Calculator

Defined in:

lib/trxl/trxl.rb

Overview

This module exists only for performance reason. Loading the stdlib directly from a ruby object, should be much faster than loading it from a file.

Constant Summary

FOREACH_IN =

<<-PROGRAM
  foreach_in = fun(enumerable, body) {
    _foreach_in_(enumerable, body, 0);
  };
  _foreach_in_ = fun(enumerable, body, index) {
    if(index < SIZE(enumerable) - 1)
      body(enumerable[index]);
      _foreach_in_(enumerable, body, index + 1)
    else
      body(enumerable[index])
    end
  };
PROGRAM

INJECT =

<<-PROGRAM
  inject = fun(memo, enumerable, body) {
    _inject_(memo, enumerable, body, 0);
  };
  _inject_ = fun(memo, enumerable, body, index) {
    if(index < SIZE(enumerable) - 1)
      _inject_(body(memo, enumerable[index]), enumerable, body, index + 1)
    else
      body(memo, enumerable[index])
    end
  };
PROGRAM

MAP =

<<-PROGRAM
  require 'stdlib/inject';
  map = fun(enumerable, body) {
    b = body; # WORK AROUND a bug in Trxl::Environment
    inject([], enumerable, fun(memo, e) { memo << b(e); });
  };
PROGRAM

SELECT =

<<-PROGRAM
  require 'stdlib/inject';
  select = fun(enumerable, body) {
    b = body; # WORK AROUND a bug in Trxl::Environment
    inject([], enumerable, fun(selected, value) { 
      if(b(value))
        selected << value
      else
        selected
      end 
    });
  };
PROGRAM

REJECT =

<<-REJECT
  require 'stdlib/inject';
  reject = fun(enumerable, filter) {
    f = filter; # WORKAROUND for a bug in Trxl::Environment
    inject([], enumerable, fun(rejected, value) {
      if(f(value)) 
        rejected
      else
        rejected << value
      end 
    })
  };
REJECT

IN_GROUPS_OF =

<<-IN_GROUPS_OF
  require 'stdlib/foreach_in';
  require 'stdlib/inject';
  in_groups_of = fun(size_of_group, enumerable, group_function) {
    count = 0; groups = []; cur_group = []; 
    foreach_in(enumerable, fun(element) {
      if(count < size_of_group)
        cur_group << element;
        count = count + 1
      end;
      if(count == size_of_group)
        groups << cur_group;
        cur_group = [];
        count = 0
      end
    });
    group_count = 0;
    inject([], groups, fun(memo, group) {
      group_count = group_count + 1;
      memo << group_function(group, group_count);
      memo
    });
  };
IN_GROUPS_OF

SUM_OF_TYPE =

<<-SUM_OF_TYPE
  sum_of_type = fun(type, all_types, all_values) {
    SUM(VALUES_OF_TYPE(type, all_types, all_values));
  };
SUM_OF_TYPE

AVG_SUM_OF_TYPE =

<<-AVG_SUM_OF_TYPE
  avg_sum_of_type = fun(type, all_types, all_values) {
    AVG_SUM(VALUES_OF_TYPE(type, all_types, all_values));
  };
AVG_SUM_OF_TYPE

AVG_RANGE_SUM_OF_TYPE =

<<-AVG_RANGE_SUM_OF_TYPE
  require 'stdlib/inject';
  require 'stdlib/avg_sum_of_type';
  avg_range_sum_of_type = fun(type, all_types, variable_range) {
    inject(0, variable_range, fun(sum, variable) { 
      sum + avg_sum_of_type(type, all_types, ENV[variable]) 
    });
  };
AVG_RANGE_SUM_OF_TYPE

TOTAL_RANGE_SUM_OF_TYPE =

<<-TOTAL_RANGE_SUM_OF_TYPE
  require 'stdlib/inject';
  require 'stdlib/sum_of_type';
  total_range_sum_of_type = fun(type, all_types, variable_range) {
    inject(0, variable_range, fun(sum, variable) { 
      sum + sum_of_type(type, all_types, ENV[variable]) 
    });
  };
TOTAL_RANGE_SUM_OF_TYPE

YEAR_FROM_DATE =

<<-YEAR_FROM_DATE
  year_from_date = fun(date) {
    date = SPLIT(date, '/');
    TO_INT(date[1]);
  };
YEAR_FROM_DATE

MONTH_FROM_DATE =

<<-MONTH_FROM_DATE
  month_from_date = fun(date) {
    date = SPLIT(date, '/');
    TO_INT(date[0]);
  };
MONTH_FROM_DATE

DATES =

<<-DATES
  require 'stdlib/month_from_date';
  require 'stdlib/year_from_date';
DATES

RATIO =

<<-RATIO
  require 'stdlib/foreach_in';
  ratio = fun(enumerable, true_condition, base_condition) {
    base = 0;
    positives = 0;
    foreach_in(enumerable, fun(val) {
      if(ENV[val] != base_condition)
        base = base + 1
      end;
      if(ENV[val] == true_condition)
        positives = positives + 1
      end;
    });
    if(base > 0)
      ROUND((ROUND(positives, 1) / base) * 100, 2)
    else
      NULL
    end
  };
RATIO