再帰ってのは？

カスタム関数の再帰の計算処理がどんなふうに行われるのか分からなかったので
今回分かったことをメモ

再帰

Loopみたいに繰り返しの処理を行うのだけど少し違うところは、
自分自身を繰り返すというところです。

ちなみにLoopはスクリプトステップですね。
以前は、計算式で繰り返しをするような関数が無かったのでカスタム関数で再帰のものを作って使っていたようです。
現在は、While関数が登場したためカスタム関数の再帰を使う機会は減ったようです。

カスタム関数の再帰

実際どんなものか？

Let(
    ~integer = Abs (_integer)
    ;
    If (
        ~integer <= 1;
        ~integer;
        ~integer* _Factorial ( ~integer - 1 )
    )
)

順を追って考えてみます。

// ~integerに4を代入します。
Let(
    4 = Abs (4)  //Absは数値の絶対値を返す関数
    ;
    If (
        4 <= 1;
        4;
        4* _Factorial ( 4 - 1 )
    )
)c

結果は 4 <= 1; は偽なので
4* _Factorial ( 3 )
このままでは_Factorial ( 3 )の結果がわからないので、正しい結果がまだでていない状態。。。。。。

では _Factorial ( 3 )の結果は？

// ~integerに3を代入します。
Let(
    3 = Abs (3)  //Absは数値の絶対値を返す関数
    ;
    If (
       3 <= 1;
       3;
       3* _Factorial ( 3 - 1 )
    )
)c

結果は 3 <= 1 は偽なので
3* _Factorial ( 2 )
このままでは_Factorial ( 2 )の結果がわからないので、正しい結果がまだでていない状態。。。。。。

では _Factorial ( 2 )の結果は？

// ~integerに2を代入します。
Let(
    2 = Abs (2)  //Absは数値の絶対値を返す関数
    ;
    If (
       2 <= 1;
       2;
       2* _Factorial ( 2 - 1 )
    )
)c

結果は 2 <= 1 は偽なので
2* _Factorial ( 1 )
このままでは_Factorial ( 1 )の結果がわからないので、正しい結果がまだでていない状態。。。。。。

では _Factorial ( 1 )の結果は？

// ~integerに1を代入します。
Let(
    1 = Abs (1)  //Absは数値の絶対値を返す関数
    ;
    If (
       1 <= 1;
       1;
       1* _Factorial ( 1 - 1 )
    )
)c

結果は 1 <= 1 は新なので
1
ここでようやく_Factorial ( 1 )の結果が1と分かりました。

次はこの結果を元にさっきまで正しいものが分からなかった結果に、値を代入していきます。
_Factorial ( 1 ) → 1
_Factorial ( 2 ) →→→ 2* _Factorial ( 1 ) →→ 2*1
_Factorial ( 3 ) →→→ 3* _Factorial ( 2 ) →→ 3*2
_Factorial ( 4 ) →→→ 4* _Factorial ( 3 ) →→ 4*6

_Factorial ( 4 )の結果は 24 になります！

Case (Lenghth (str) ) > 1 ;
    Explode ( Left ( str ; Length ( str ) - 1 ) )
    & "¶" & 
     Left ( str ; Length ( str ) - 1 ) ;

// (str) にBobを代入                      Explode (Bob)の結果
Case (
    Lenghth (Bob) ) > 1 ;
        Explode ( Left ( Bob ; Length ( Bob ) - 1 ) )
    & "¶" & 
     Left ( Bob ; Length ( Bob ) - 1 ) ;
     str )

3 > 1  だから結果は。。。
Explode ( Bo )
Bo
---------------------------------------------------------------------------------
// (str) にBoを代入                         Explode ( Bo )の結果
Case (Lenghth (Bo) ) > 1 ;
    Explode ( Left ( Bo ; Length ( Bo ) - 1 ) )
    & "¶" & 
     Left ( Bo ; Length ( Bo ) - 1 ) ;
     str )

2 > 1  だから結果は。。。
Explode ( B )
B
---------------------------------------------------------------------------------
// (str) にBを代入                            Explode ( B )の結果
Case (Lenghth (B) ) > 1 ;
    Explode ( Left ( B ; Length ( B ) - 1 ) )
    & "¶" & 
     Left ( B ; Length ( B ) - 1 ) ;
     str )

1 > 1  だから結果は。。。。。str
B
---------------------------------------------------------------------------------

 Explode ( B )の答えが B と確定したので
結果に代入していきます。

Explode ( B )    →
B
Explode ( Bo )  →
B
B
Explode ( Bob )  →
B
B
Bo

Explode ( Bob )の結果は
B
B
Bob
になります！

こんな感じで結果を求めるために自分自身を繰り返す処理を行います🙌