Goak

Go module to build a decisional tree from a Json file and run a search through it.

Json structure

Domain

Option

The conditions and the outcomes inside each option of a domain will compose a domain-tree of his own. If the any of the possible outcomes isn't reached, then the default leaf will redirect to the root of the next domain-tree. The last domain will just end with default leaves.

This allows the user to configure sectors of the decisional tree that will be isolated between them, and that will only consider that domain conditions to compute the outcome.

Usage

Inside the example folder you can find a basic snippet.

Import the module

import "github.com/GangemiLorenzo/Goak/tree"

Define the condition you are using

const (
 A tree.Condition = "A"
 B tree.Condition = "B"
 C tree.Condition = "C"
 D tree.Condition = "D"
 E tree.Condition = "E"
)

Build the tree

t := tree.BuildTree("./assets/test_tree.json")

Run a search

c := tree.Conditions{ 
  B,
  C,
 }
res := t.Search(c) //res will contain the outcome that satisfy the conditions B and C

Example

The following is the json structure used in the given example.

test_tree.json

{
    "domains": [
        {
            "priority": [
                "A"
            ],
            "options": [
                {
                    "result": "OUTCOME_0",
                    "want": [
                        "A"
                    ]
                }
            ]
        },
        {
            "priority": [
                "B",
                "C",
                "D",
                "E"
            ],
            "options": [
                {
                    "result": "OUTCOME_1",
                    "want": [
                        "B"
                    ]
                },
                {
                    "result": "OUTCOME_2",
                    "want": [
                        "C"
                    ]
                },
                {
                    "result": "OUTCOME_3",
                    "want": [
                        "C",
                        "B"
                    ]
                },
                {
                    "result": "OUTCOME_4",
                    "want": [
                        "E"
                    ],
                    "or": [
                        "C",
                        "B"
                    ]
                },
                {
                    "result": "OUTCOME_5",
                    "want": [
                        "C",
                        "B",
                        "D",
                        "E"
                    ]
                }
            ]
        }
    ]
}

This structure will produce the following tree and truth table:

tree.md

graph TD
    A-->|Match|OUTCOME_0;
    A-->|Fail|B;
    B-->|Match|BC;
    BC-->|Match|BCED;
    BCED-->|Match|OUTCOME_5;
    BCED-->|Fail|OUTCOME_3;
    BC-->|Fail|BE;
    BE-->|Match|OUTCOME_4;
    BE-->|Fail|OUTCOME_1;
    B-->|Fail|C;
    C-->|Match|CE;
    CE-->|Match|OUTCOME_4;
    CE-->|Fail|OUTCOME_2;
    C-->|Fail|DEFAULT;

I'm using Mermaid to display the tree.

table.md

Domain: 0

Domain: 1

Known problems

Conditions priority (SOLVED)

Given the following branches:

graph TD
    BC --> Out1
    BE --> Out2
    CE --> Out3

Given the following satisfied conditions:

 B
 C
 E

What outcome should result from a search?

Possible solution

We could list the conditions in the json and apply to each of them a greater priority depending on which is listed first.

 "priority": [
    "B",
    "C",
    "E"
 ]

Given this priority, the result from a search with BCE would be: Out1.

• [x] Solution implemented