예제 #1
0
    private static Rch fit(Rch first, Rch second) //AttGeTr: tricky: this function always returns the first reach but when one of both is fitted it returns a fitted copy of the first reach
    {
        if ((first.fitted) || (!second.fitted))
        {
            return(first);
        }
        Rch ret = first.upto(first.len);

        ret.fitted = true;
        return(ret);
    }
예제 #2
0
 protected Rch(Rch first, Rch second) //this special constructor is used to create a non-standard Reach with 1 compact Reach item <> this in Block List, used intemediately during operator+
 {
     //MethWatch mw = new MethWatch("RchFdn.Rch_first_second");
     bl = new Pile <Rch>();
     bl.Add(first.bl);
     bl.Add(second.bl);
     //bl = pieces();
     upd();
     fitted = (first.fitted || second.fitted);
     //mw._void();
 }
예제 #3
0
 private Rch badImpl(Rch r)
 {
     // AttGeTr: sometimes resulting Reaches are "fitted" - I must research why it is.
     // the concept of "fitted Reaches" and "not fitted Reaches" SURELY MAKES A LOT OF SENSE
     // I remember that a resulting reach is "fitted" in case you calculate Reach("abc").from(17) - this gives a fitted empty Reach
     // "fitted" has the meaning similar to: "a recent calculation violated bounds and the Result had to be fitted to its bounds" ...
     // IMPORTANT: the badImpl() function is NOT menat for debuggig/investiation of the "fitted" feature !!!
     // IMPORTANT: some calculations in the Rch Class call badImpl() because of invalid implemention.
     //            the implemention WAS VALID BEFORE the string parameter token has been altered to string... tokens
     //            a valid implementation MUST be found and so you should debug with a breakpoint at the next line:
     return(r); //place your debuggin breakpoint here!
 }
예제 #4
0
 internal void cloneFrom(Rch other) //only allowed if the other dies right after this call, example a.cloneFrom(b - c)
 {
     bl = other.bl;
     if (bl.Len == 1)
     {
         bl[1] = this;
     }
     mBuf   = other.mBuf;
     sLbl   = other.sLbl;
     eLbl   = other.eLbl;
     inf    = other.inf;
     fitted = other.fitted;
 }
예제 #5
0
    internal Rch(Rch source, Restrict rt)
    {
        //MethWatch mw = new MethWatch("RchFdn.Rch_Rch_Restrict");
        fitted = rt.fitted | source.fitted;
        bl     = new Pile <Rch>("", true, this);
        int sbl = 0; int ebl = 0; int sblPos = 0; int eblPos = 0; source.block4Pos(rt.sPos, rt.ePos, ref sbl, ref ebl, ref sblPos, ref eblPos);

        if (rt.ePos < rt.sPos)
        {
            ebl = sbl; eblPos = sblPos - 1;
        }
        if ((rt.sWide) && (sblPos <= 1))
        {
            for (int i = sbl - 1; i > 0; i--)
            {
                if (source.bl_Len(i) > 0)
                {
                    break;
                }
                sbl = i; sblPos = 1;
            }
        }
        if ((rt.eWide) && (eblPos >= source.bl_Len(ebl)))
        {
            for (int i = ebl + 1; i <= source.bl.Len; i++)
            {
                if (source.bl_Len(i) > 0)
                {
                    break;
                }
                ebl = i; eblPos = 0;
            }
        }
        if (sbl == ebl)
        {
            mBuf = source.bl[sbl].mBuf;
            //long sInx = mBuf.sIndex(source.bl[sbl].sLbl); // UNBELIEVABLE!!!! This variation slows doen by 10% !!!!!  long sInx = source.bl_sInx(sbl);
            long sInx = source.bl_sInx(sbl);
            sLbl = "" + mBuf.sLabel((int)(sInx - 1 + sblPos));
            eLbl = "" + mBuf.eLabel((int)(sInx - 1 + eblPos));
            mBuf.subscribe(this);
        }
        else
        {
            bl     = source.bl.slice(sbl, ebl);
            bl[1]  = source.bl[sbl].from(sblPos);
            bl[-1] = source.bl[ebl].upto(eblPos);
        }
        upd(); //inf = new long[bl.Count + 1, 3];
        //mw._void();
    }
예제 #6
0
    public static Rch operator-(Rch first, Rch second)
    {
        if (first.len * second.len == 0)
        {
            return(fit(first, second));
        }
        if ((!first.compact) || (!second.compact))
        {
            if (first.compact)
            {
                Rch ret = first;
                foreach (Rch s in second.bl)
                {
                    ret = ret - s;
                }
                return(ret);
            }
            else
            {
                Rch ret = fit(first.upto(0) + first.from(first.len + 1), second); // delFromLeftToRight strategy: Rch ret = fit(first.from(first.len + 1), second);
                foreach (Rch f in first.bl)
                {
                    Rch diff = f - second;
                    if (diff.len > 0)
                    {
                        if (ret.len == 0)
                        {
                            ret = diff;
                        }
                        else
                        {
                            ret = ret + diff;
                        }
                    }
                }
                return(ret);
            }
        }
        if (first.mBuf != second.mBuf)
        {
            return(fit(first, second));
        }
        int sInx1 = first.sbdry(first.sLbl);
        int eInx1 = first.ebdry(first.eLbl) - 1;
        int sInx2 = second.sbdry(second.sLbl);
        int eInx2 = second.ebdry(second.eLbl) - 1;

        if ((eInx2 < sInx1) || (sInx2 > eInx1))
        {
            return(fit(first, second));
        }
        if ((sInx2 <= sInx1) && (eInx2 >= eInx1))
        {
            return(fit(first.upto(0) + first.from(first.len + 1), second));                                 // delFromLeftToRight strategy: fit(first.from(first.len + 1), second);
        }
        if ((sInx2 > sInx1) && (eInx2 < eInx1))
        {
            return(fit(first.upto(sInx2 - sInx1) + first.from(first.len + 1 - (eInx1 - eInx2)), second));
        }
        if (sInx2 <= sInx1)
        {
            return(fit(first.from(first.len + 1 - (eInx1 - eInx2)), second));
        }
        return(fit(first.upto(sInx2 - sInx1), second));
    }
예제 #7
0
 internal Rch cloneDiff(Rch other, Rch skip)
 {
     cloneFrom(this - other - skip); return(other);
 }
예제 #8
0
 internal Rch cloneDiff(Rch other)
 {
     cloneFrom(this - other); return(other);
 }
예제 #9
0
 private Rch    fit(Rch r)
 {
     r.fitted = true; return(r);
 }
예제 #10
0
 public Rch          _Rch(Rch v)
 {
     stop(); return(v);
 }