[プログラミング] Algodooで使用できるThyme言語による追加関数

Scene.my.all := (list, predicate)=>{
    listLength := string.length(list);
    if_then_else(listLength == 0, {
        true;
    }, {
        if_then_else(predicate(list(0)), {
            Scene.my.all(list(1 .. (listLength - 1)), predicate);
        }, {
            false;
        });
    });
};

Scene.my.any := (list, predicate)=>{
   listLength := string.length(list);
   if_then_else (listLength == 0 , {
       false ;
   }, {
       if_then_else (predicate(list( 0 )), {
           true ;
       }, {
           Scene.my.any(list( 1  .. (listLength - 1 )), predicate);
       });
   });
};

Scene.my.average := (list)=>{
    sum := 0;
    listLength := string.length(list);
    for(listLength, (i)=>{
        sum = sum + list(i);
    });
    sum / listLength;
};

Scene.my.contains := (list, element)=>{
    contains := false;
    for(string.length(list), (i)=>{
        if_then_else(list(i) == element, {
            contains = true
        }, {})
    }); 
    contains
};

Scene.my.filter := (list, predicate)=>{
    newList := [];
    for(string.length(list), (i)=>{
        if_then_else(predicate(list(i)), {
            newList = newList ++ list[i];
        }, {});
    });
    newList;
};

Scene.my.fold := (initialValue, list, func)=>{
   accumulator := initialValue;
   for (string.length(list), (i)=>{
       accumulator = func(accumulator, list(i))
   });
   accumulator
};

Scene.my.indexOf := (list, element)=>{
    index := -1;
    for(string.length(list), (i)=>{
        if_then_else(index == -1 && list(i) == element, {
            index = i
        }, {})
    });
    index
};

Scene.my.insertAtIndex := (list, index, element)=>{
    list(0 .. (index - 1)) ++ [element] ++ list((index) .. (string.length(list) - 1))
};

Scene.my.map := (list, func)=>{
    newList := [];
    for(string.length(list), (i)=>{
        newList = newList ++ [func(list(i))];
    });
    newList;
};

Scene.my.max := (list)=>{
   max := -inf;
   for (string.length(list), (i)=>{
       if_then_else (list(i) > max, {
           max = list(i);
       }, {})
   });
   max;
};

Scene.my.min := (list)=>{
   min := +inf;
   for (string.length(list), (i)=>{
       if_then_else (list(i) < min, {
           min = list(i);
       })
   });
   min;
};

Scene.my.modifyAtIndex := (list, index, newElement)=>{
   list( 0  .. (index - 1 )) ++ [newElement] ++ list((index + 1 ) .. (string.length(list) - 1 ))
};

Scene.my.quickSort = (arr)=>{
    len := string.length(arr);
    len <= 1 ? arr : {
        average := 0;
        for(len, (i)=>{
            average = average + arr(i)
        });
        average = math.tofloat(average) / len;
        smaller := [];
        larger := [];
        equal := [];
        for(len, (i)=>{
            arr(i) > average ? {
                larger = larger ++ [arr(i)]
            } : {};
            arr(i) < average ? {
                smaller = smaller ++ [arr(i)]
            } : {};
            arr(i) == average ? {
                equal = equal ++ [arr(i)]
            } : {}
        });
        Scene.my.quickSort(smaller) ++ equal ++ Scene.my.quickSort(larger)
    }
};

Scene.my.removeAtIndex := (list, index)=>{
   list( 0  .. (index - 1 )) ++ list((index + 1 ) .. (string.length(list) - 1 ))
};

Scene.my.removeFirstItem := (list, item)=>{
    output = [];
    removedItem := false;
    for(string.length(list), (i)=>{
        ! removedItem && list(i) == item ? {
            removedItem = true
        } : {
            output = output ++ [list(i)]
        }
    });
    output
};

Scene.my.removeItem := (list, item)=>{
    newList := set.merge([item], list);
    newList(1 .. (string.length(newList) - 1))
};

Scene.my.removeItems := (list, items)=>{
    newList := set.merge(items, list);
    newList(string.length(items) .. (string.length(newList) - 1))
};

Scene.my.reverse := (list)=>{
    newList := [];
    listLength := string.length(list);
    for(listLength, (i)=>{
        newList = newList ++ [list(listLength - 1 - i)];
    });
    newList;
};

Scene.my.shuffle := (list)=>{
    input := list;
    output := [];
    for(string.length(list), (i)=>{
        index := math.toInt(rand.uniform01 * string.length(input));
        output = output ++ [input(index)];
        input = input(0 .. index - 1) ++ input(index + 1 .. string.length(input) - 1)
    });
    output
};