MonomialIterator.m

Go to the documentation of this file.

/* (Autoinserted by mtoc++)
 * This source code has been filtered by the mtoc++ executable,
 * which generates code that can be processed by the doxygen documentation tool.
 *
 * On the other hand, it can neither be interpreted by MATLAB, nor can it be compiled with a C++ compiler.
 * Except for the comments, the function bodies of your M-file functions are untouched.
 * Consequently, the FILTER_SOURCE_FILES doxygen switch (default in our Doxyfile.template) will produce
 * attached source files that are highly readable by humans.
 *
 * Additionally, links in the doxygen generated documentation to the source code of functions and class members refer to
 * the correct locations in the source code browser.
 * However, the line numbers most likely do not correspond to the line numbers in the original MATLAB source files.
 */

class MonomialIterator
  :public handle {
    public:

        Dim;

        
    private:

        incidx;

        deg;

        rnd;

        expidx;

          
    public:

        MonomialIterator(integer dim) {
            if int32(dim) ~= dim || dim <= 0
                error(" Dimension d must be a positive integer. ");
            end
            this.Dim= int32(dim);
            this.deg= int32(1);
            this.rnd= RandStream(" mt19937ar "," Seed ",2);
            this.expidx= int32(1);
            this.incidx= int32(1);
        }
        function colvec<double>alpha = getNullMonomial() {
            alpha = zeros(this.Dim,1);
        }
        function [colvec<double>alpha , int32deg , exps ] = nextMonomial() {


            /*  Collect exponents via histogram count for each dimension
             *alpha = fliplr(histc(this.expidx, 1:this.Dim))'; */
            alpha = histc(this.expidx, 1:this.Dim)^t;
            deg = this.deg;
            exps = this.expidx;

            /*  Increment exponentials at current incidx */
            if this.expidx(this.incidx) == this.Dim && this.incidx > 1
                /*  Set increase counter one to the left */
                this.incidx= this.incidx - 1;

                /*  Einen hoch */
                this.expidx(this.incidx) = this.expidx(this.incidx) + 1;

                /*  See  */
                if this.expidx(this.incidx) < this.Dim
                    /*  Daneben alle auf den Wert setzen */
                    this.expidx(this.incidx+1:this.deg) = this.expidx(this.incidx);
                    this.incidx= this.deg;
                end
            else
                this.expidx(this.incidx) = this.expidx(this.incidx) + 1;
            end

            /*  Check if current degree is finished */
            if this.incidx == 0 || this.expidx(this.incidx) > this.Dim /* equiv: all(this.expidx == this.Dim) */

                this.deg= this.deg + 1;
                this.expidx= int32(ones(1,this.deg));
                /*  Increment index is last exponent */
                this.incidx= this.deg;
            end
        }
        function colvec<int32>alpha = getRandMonomial(int32 deg) {
            alpha = zeros(this.Dim,1);
            s = 0;
            while s < deg
                idx = this.rnd.randi(this.Dim);
                alpha(idx) = alpha(idx) + this.rnd.randi(deg-s);
                s = sum(alpha);
            end
        }
    public: /* ( Static ) */

        static function logicalres = test_MonomialIterator() {
            for Dim = 1:3 /* #ok<*PROP> */

                fprintf(" Dim=%d:\n ",Dim)
                mi = MonomialIterator(Dim);
                deg = 0;
                while deg < 5
                    [alpha, deg, exps] = mi.nextMonomial;
                    fprintf(" p=%d, exps=[%s], alpha=[%s]\n ",deg, Utils.implode(exps," , "," %d "),...
                        Utils.implode(alpha," , "," %d "));
                end
            end
            res = true;
            /*  test for d=1 and p=1000 */
            mi = MonomialIterator(1);
            for i=1:1000
                [alpha, deg, exps] = mi.nextMonomial; /* #ok<*PROP> */

                res = res && alpha == i && deg == i && all(exps==1);
            end

            /*  test for d=4 and p=3 */
            mi = MonomialIterator(4);
            cmpp1 = [1; 2; 3; 4];
            cmpp2 = [1 1; 1 2; 1 3; 1 4; 2 2; 2 3; 2 4; 3 3; 3 4; 4 4];
            cmpp3 = [1 1 1; 1 1 2; 1 1 3; 1 1 4; 1 2 2; 1 2 3; 1 2 4; 1 3 3; 1 3 4; 1 4 4; 2 2 2;...
                2 2 3; 2 2 4; 2 3 3; 2 3 4; 2 4 4; 3 3 3; 3 3 4; 3 4 4; 4 4 4];
            for i = 1:size(cmpp1,1)
                [~, deg, exps] = mi.nextMonomial;
                res = res && deg == 1 && all(exps==cmpp1(i,:));
            end
            for i = 1:size(cmpp2,1)
                [~, deg, exps] = mi.nextMonomial;
                res = res && deg == 2 && all(exps==cmpp2(i,:));
            end
            for i = 1:size(cmpp3,1)
                [~, deg, exps] = mi.nextMonomial;
                res = res && deg == 3 && all(exps==cmpp3(i,:));
            end
        }
};