nv-data-tree-bp-agg v1.0.1

nv-data-tree-bp-agg

• nv-data-tree-bp-agg
• a simple expression runner

• for test "parallel" exprs excution

• ONLY support SYNC executor

• its a simplified pure-JS version of nv-task-aggregating-promise(which support async executor) in nvlang

install

• npm install nv-data-tree-bp-agg

usage

  const {load_calc_from_bp} = require("nv-data-tree-bp-agg")

load ...code... is quotes of code

    // this means   ((1,2,3)+ , (5,3)-) *     , in a suffix-style
    //     *(+(1,2,3),-(5,3))
    //     (1+2+3) * (5-3)         

    var bp =`
    {
       {[1] ,[2] ,[3]} -> [+]
       {[5], [3]}      -> [-]
    } -> [*] 
    `;




    var calc = load_calc_from_bp(bp)
    calc.reset()
    /*
    > calc.show()
    {
        {
            {
                [1 : opened]-|
                [2 : opened]-|
                [3 : opened]-|
            }-> [+ : ready]     -|
            {
                [5 : opened]-|
                [3 : opened]-|
            }-> [- : ready]     -|
        }-> [* : ready]         -|
    }-> [0 : ready]

    > calc.list_all_tags()
    [
      0,   '*', '+', '1',
      '2', '3', '-', '5',
      '3'
    ]
    >
    */

assign function IR

    calc.set_calculator_via_tag('+',(RETURN,self)=>{
        let children = self.$children_;
        let sum = 0;
        for(let nd of children) {
            sum = sum + nd.rslt_
        }
        RETURN(sum)
    });
    calc.set_calculator_via_tag('-',(RETURN,self)=>{
        let children = self.$children_;
        let sub = children[0].rslt_;
        for(let i =1;i<children.length;i++) {
            let nd = children[i];
            sub = sub-nd.rslt_
        }
        RETURN(sub)
    });
    calc.set_calculator_via_tag('*',(RETURN,self)=>{
        let children = self.$children_;
        let mul = 1;
        for(let nd of children) {
            mul = mul * nd.rslt_
        }
        RETURN(mul)
    });

    calc.set_calculator_via_tag_fltr(
        (r)=>typeof(r)==='string'  && /^[0-9]+$/.test(r),
        (RETURN,self)=>{
            RETURN(Number(self["#raw_tag"]))
       }
    );

run to complete

    var r = calc.run_to_complete()
    /*
           // 12 === (1+2+3) * (5-3)  
    12
    */

single step mode

    calc.reset();

    calc.next()

    /*
    >
    [ 1, 2, 3, 5, 3 ]
    */

    /*
    > calc.show()
    {
        {
            {
                [1 : 1 # [resolved]-|
                [2 : 2 # [resolved]-|
                [3 : 3 # [resolved]-|
            }-> [+ # opened]           -|
            {
                [5 : 5 # [resolved]-|
                [3 : 3 # [resolved]-|
            }-> [- # opened]           -|
        }-> [* # ready]                -|
    }-> [0 # ready]

    */


    calc.next()

    /*
    [6,2]
    */

    /*
    > calc.show()
    {
        {
            {
                [1 : 1 # [resolved]-|
                [2 : 2 # [resolved]-|
                [3 : 3 # [resolved]-|
            }-> [+ : 6 # [resolved]    -|
            {
                [5 : 5 # [resolved]-|
                [3 : 3 # [resolved]-|
            }-> [- : 2 # [resolved]    -|
        }-> [* # opened]               -|
    }-> [0 # ready]

    */

    /*
    > calc.next()
    [ 12 ]
    >
    > calc.show()
    {
        {
            {
                [1 : 1 # [resolved] -|
                [2 : 2 # [resolved] -|
                [3 : 3 # [resolved] -|
            }-> [+ : 6 # [resolved]     -|
            {
                [5 : 5 # [resolved] -|
                [3 : 3 # [resolved] -|
            }-> [- : 2 # [resolved]     -|
        }-> [* : 12 # [resolved]        -|
    }-> [0 # opened]

    */

    /*
    > calc.next()
    [ 12 ]
    > calc.show()
    {
        {
            {
                [1 : 1 # [resolved] -|
                [2 : 2 # [resolved] -|
                [3 : 3 # [resolved] -|
            }-> [+ : 6 # [resolved]     -|
            {
                [5 : 5 # [resolved] -|
                [3 : 3 # [resolved] -|
            }-> [- : 2 # [resolved]     -|
        }-> [* : 12 # [resolved]        -|
    }-> [0 : 12 # [resolved]

    */

    calc.reset()

METHODS

Calc

    calc.get_nds_with_tag             calc.get_nds_with_tag_fltr
    calc.get_nds_with_tag_rgx         calc.list_all_tags                calc.next
    calc.reset                        calc.run_to_complete              calc.set_calculator_via_tag
    calc.set_calculator_via_tag_fltr  calc.set_calculator_via_tag_rgx   calc.shape_bp_
    calc.show

BpAgg

    nd.dump_shape
    nd.is_can_exec                             nd.is_opened
    nd.is_ready                                nd.is_resolved
    nd.rslt_                                   nd.run
    nd.set_state_to_opened                     nd.set_state_to_ready
    nd.set_state_to_resolved                   nd.show
    nd.state_                                  nd.step
    nd.step_without_noti_parent                nd.to_str
    nd.calculator                              nd.stringify

APIS

    {
      load_calc_from_bp: [Function: load_calc_from_bp],
      Calc: [class Calc extends Array],
      BpAgg: [class BpAgg extends ‌] {
        STATES_MD: {
          '0': 'ready',
          '2': 'opened',
          '4': 'resolved',
          ready: 0,
          opened: 2,
          resolved: 4
        },
        DFLT_AGG_CALCULATOR: [Function: DFLT_AGG_CALCULATOR]
      },
      _eng: { load: [Function: load], dump: [Function: dump] },
      _paint: [Function: paint],
      _parser: {
        DFLT_TAG_PARSER: [Function: DFLT_TAG_PARSER],
        DFLT_SET_TAG: [Function: DFLT_SET_TAG],
        DFLT_GET_TAG: [Function: DFLT_GET_TAG],
        parse: [Function: parse]
      },
      _repr: { show: [Function: show] },
      _load: { load: [Function: load] }
    }

LICENSE

• ISC