Esempio n. 1
0
        public override FingerTree <T, M> App2(List <T> ts, FingerTree <T, M> f)
        {
            if (f is EmptyFingerTree <T, M> )
            {
                FingerTree <T, M> resultFT = this;

                foreach (var t in ts)
                {
                    resultFT = resultFT.PushRight(t);
                }

                return(resultFT);
            }
            else if (f is SingleFingerTree <T, M> )
            {
                FingerTree <T, M> resultFT = this;

                foreach (var t in ts)
                {
                    resultFT = resultFT.PushRight(t);
                }

                return(resultFT.PushRight(f.LeftView().End));
            }
            else
            {
                var dr = f as DeepFingerTree <T, M>;

                var ll = new List <T>(_rightDigits.Digits);
                ll.AddRange(ts);
                ll.AddRange(dr._leftDigits.Digits);

                return(new DeepFingerTree <T, M>(_m, _leftDigits, _fingerTree.App2(ListOfNodes(_m, ll), dr._fingerTree), dr._rightDigits));
            }
        }
Esempio n. 2
0
        public static FingerTree <T, M> Create(List <T> left, FingerTree <Node <T, M>, M> f, Digit <T, M> right)
        {
            var m = right.M;

            if (left.Count > 0)
            {
                return(new DeepFingerTree <T, M>(m, new Digit <T, M>(m, left), f, right));
            }

            if (f is EmptyFingerTree <Node <T, M>, M> )
            {
                return(FromSequence(right.Digits, m));
            }

            var il = f.LeftView();
            var n  = il.End.Nodes;

            return(new DeepFingerTree <T, M>(m, new Digit <T, M>(m, n), il.Rest, right));
        }
Esempio n. 3
0
        public override FingerTree <T, M> Reverse()
        {
            var fl = ReverseDigit(_rightDigits);
            var fr = ReverseDigit(_leftDigits);

            if (_fingerTree is EmptyFingerTree <Node <T, M>, M> )
            {
                return(new DeepFingerTree <T, M>(_m, fl, _fingerTree, fr));
            }

            if (_fingerTree is SingleFingerTree <Node <T, M>, M> )
            {
                return(new DeepFingerTree <T, M>(_m, fl, new SingleFingerTree <Node <T, M>, M>(_m, ReverseNode(_fingerTree.LeftView().End)), fr));
            }

            var rdi = (DeepFingerTree <Node <T, M>, M>)(((DeepFingerTree <Node <T, M>, M>)_fingerTree).Reverse());
            var ln  = new List <Node <T, M> >();
            var rn  = new List <Node <T, M> >();

            foreach (var n in rdi._leftDigits.Digits)
            {
                ln.Add(ReverseNode(n));
            }

            foreach (var n in rdi._rightDigits.Digits)
            {
                rn.Add(ReverseNode(n));
            }

            var ri = new DeepFingerTree <Node <T, M>, M>(_m, new DeepFingerTree <Node <T, M>, M> .Digit <Node <T, M>, M>(_m, ln), rdi._fingerTree, new DeepFingerTree <Node <T, M>, M> .Digit <Node <T, M>, M>(_m, rn));

            return(new DeepFingerTree <T, M>(_m, ReverseDigit(_rightDigits), ri, ReverseDigit(_leftDigits)));
        }