Esempio n. 1
0
            public BoostedNode predictBoosted(Dictionary <string, dynamic> inputData, bool byName = true, int missing_strategy = 0)
            {
                if (byName)
                {
                    inputData = prepareInputData(inputData, byName);
                }

                // if Model was not processed before => creates root Node
                if (rootBoostedNode == null)
                {
                    rootBoostedNode = new BoostedNode((JObject)this._jsonObject["root"]);
                }

                return(predictBoostedNode(rootBoostedNode, inputData));
            }
Esempio n. 2
0
            private BoostedNode predictBoostedNode(BoostedNode currentNode, Dictionary <string, dynamic> inputData)
            {
                bool    missingField;
                string  fieldId;
                dynamic predicateValue;
                dynamic inDataValue;

                foreach (BoostedNode children in currentNode.Children)
                {
                    fieldId      = children.Predicate.Field;
                    missingField = !inputData.ContainsKey(fieldId);

                    if ((missingField) && (children.Predicate.MissingOperator))
                    {
                        predictBoostedNode(children, inputData);
                    }
                    else
                    {
                        //is a text field or items
                        bool textOrItems = children.Predicate.HasTerm;

                        if (missingField)
                        {
                            if (textOrItems)
                            {
                                inDataValue = "";
                            }
                            else
                            {
                                continue;
                            }
                        }
                        else
                        {
                            inDataValue = inputData[fieldId];
                        }
                        predicateValue = children.Predicate.Value;

                        if (textOrItems)
                        {
                            inDataValue = string.Format("{0}", inDataValue);
                            inDataValue = termMatches(inDataValue, fieldId, children.Predicate.Term);
                        }

                        switch (children.Predicate.Operator)
                        {
                        case "<":
                        case "<*":
                            if (inDataValue < predicateValue)
                            {
                                return(predictBoostedNode(children, inputData));
                            }
                            break;

                        case "<=":
                        case "<=*":
                            if (inDataValue <= predicateValue)
                            {
                                return(predictBoostedNode(children, inputData));
                            }
                            break;

                        case ">":
                        case ">*":
                            if (inDataValue > predicateValue)
                            {
                                return(predictBoostedNode(children, inputData));
                            }
                            break;

                        case ">=*":
                        case ">=":
                            if (inDataValue >= predicateValue)
                            {
                                return(predictBoostedNode(children, inputData));
                            }
                            break;

                        case "=*":
                        case "==*":
                        case "=":
                        case "==":
                            if (inDataValue == predicateValue)
                            {
                                return(predictBoostedNode(children, inputData));
                            }
                            break;

                        case "!=*":
                        case "!=":
                        case "<>*":
                        case "<>":
                            if (inDataValue != predicateValue)
                            {
                                return(predictBoostedNode(children, inputData));
                            }
                            break;

                        default:
                            throw new System.Exception(children.Predicate.Operator + " is not recognized");
                        }
                    }
                }
                return(currentNode);
            }