PrintTable.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 PrintTable
  :public handle {
    public:

        integer TabCharLen = PrintTable.getDefaultTabCharLen;
        char ColSep = " | ";
        logical HasHeader = false;
        logical HasRowHeader = false;
        .enum Format = "txt";
        char Caption = "";
        logical TightPDF = true;
        logical StripInsertedTabChars = true;
    public: /* ( Dependent ) */

        integer NumRows;
        logical TexMathModeDetection;
    public:

        data;
        mathmode;
        contlen;
        haslatexcommand = false;
    private:

        fTexMMode = true;

        
    public:

        PrintTable(char caption,cell varargin) {
            this.clear;
            if nargin > 0
                if ~isempty(varargin)
                    this.Caption= sprintf(caption,varargin[:]);
                else
                    this.Caption= caption;
                end
            end
        }
        function  display() {
            for i = 1:length(this)
                this(i).print(1);
            end
        }
        function  print(integer outfile) {
            if nargin == 1
                outfile = 1;
            end
            for i = 1:length(this)
                t = this(i);
                if strcmp(t.Format," txt ")
                    t.printPlain(outfile);
                elseif any(strcmp(t.Format,[" tex "," pdf "]))
                    t.printTex(outfile);
                else
                    error(" Unsupported format: %s ",t.Format);
                end
            end
        }
        function charstr = toString() {
            f = fopen(" tmpout "," w+ ");
            this.print(f);
            fclose(f);
            str = fileread(" tmpout ");
            delete(" tmpout ");
        }
        function  saveToFile(char filename,logical openfile) {

            /*  Case 1: No file name given */
            if nargin < 2 || isempty(filename)
                initdir = getpref(" PrintTable "," LastDir ",pwd);
                choices = [" *.txt ", " Text files (*.txt) ";...
                           " *.tex ", " LaTeX files (*.tex) ";...
                           " *.pdf ", " PDF files (*.pdf) "];
                [fname, path, extidx] = uiputfile(choices, ...
                    sprintf(" Save table '%s' as ",this.Caption), initdir);
                /*  Abort if no file was selected */
                if fname == 0
                    return;
                end
                setpref(" PrintTable "," LastDir ",path);
                ext = choices[extidx,1](2:end);
                filename = fullfile(path, fname);
                /*  Take off the extension of the fname (automatically added
                 * by uiputfile) */
                fname = fname(1:end-4);
            /*  Case 2: File name given. Determine format by file
             * extension */
            else
                [path, fname, ext] = fileparts(filename);
                if isempty(ext)
                    ext = [" . " this.Format];
                elseif ~any(strcmp(ext,[" .txt "," .tex "," .pdf "]))
                    error(" Valid file formats are *.txt, *.tex, *.pdf ");
                end
                if isempty(path)
                    path = " . ";
                end
                /*  Try to create directory if not existing */
                if ~isempty(path) && exist(path," dir ") ~= 7
                    mkdir(path);
                end
            end
            if nargin < 3
                openfile = false;
            end

            oldfmt = this.Format; /*  store old format */

            this.Format= ext(2:end);
            /*  PDF export */
            if strcmp(ext," .pdf ")
                this.pdfExport(path, fname);
            /*  Text export in either plain or LaTeX format */
            else
                fid = fopen(filename," w ");
                this.print(fid);
                fclose(fid);
            end
            this.Format= oldfmt; /*  restore old format */

            if openfile
                open(filename);
            end
        }
        function  addMatrix(titles,data,varargin) {
            for k=1:size(data,1)
                hlp = num2cell(data(k,:));
                this.addRow(titles[k],hlp[:],varargin[:]);
            end    
        }


        function  addRow(varargin) {
            if isempty(varargin)
                error(" Not enough input arguments. ");
            end
            hasformat = iscell(varargin[end]);
            if iscell(varargin[1])
                error(" Invalid input argument. Cells cannot be added to the PrintTable, and if you wanted to specify a sprintf format you forgot the actual value to add. ");
/*              elseif hasformat && length(varargin)-1 ~= length(varargin{end})
 *                 error('Input argument mismatch. If you specify a format string cell the number of arguments (=%d) to add must equal the number of format strings (=%d).',length(varargin)-1,length(varargin{end})); */
            end
            if isempty(this.data)
                [this.data[1], this.mathmode] = this.stringify(varargin);
                this.contlen= ones(1,length(this.data[1]));
            else
                /*  Check new number of columns */
                newlen = length(varargin);
                if hasformat
                    newlen = newlen-1;
                end
                if length(this.data[1]) ~= newlen 
                    error(" Inconsistent row length. Current length: %d, passed: %d ",length(this.data[1]),newlen);
                end
                /*  Add all values */
                [this.data[end+1], this.mathmode(end+1,:)] = this.stringify(varargin);
            end
            /*  Record content length while building the table */
            this.updateContentLengthAt(length(this.data));
            /*  Check if a latex command might be contained
             * (so far no re-computation is done on row removal) */
            texcmdfun = @(s)~isempty([strfind(s," \ ") strfind(s," _ ") strfind(s," ^ ")]);
            this.haslatexcommand= this.haslatexcommand ...
                || any(cellfun(texcmdfun,this.data[end]));
        }
        function  clear() {
            this.data= [];
            this.contlen= [];
            this.Caption= ;
        }
        function  removeRow(integer idx) {
            if idx < 1 || idx > length(this.data)
                error(" Invalid row index: %d ",idx);
            end
            this.data(idx) = [];
            this.updateContentLengths;
        }
        function this = sort(integer colnr,char direction) {
            if nargin < 3
                direction = " ascend ";
                if nargin < 2
                    if this.HasHeader
                        colnr = 2;
                    else
                        colnr = 1;
                    end
                end
            end

            if isempty(this.data)
                return;
            elseif colnr < 1 || colnr > length(this.data[1])
                error(" Please specify a valid column number ");
            end

            vals = [];
            for k = 1:length(this.data)
                vals[k] = this.data[k][colnr];/* #ok */

            end
            [~, sidx] = sort(vals);
            /*  "Manually" choose direction */
            if strcmpi(direction," descend ")
                sidx = fliplr(sidx);
            end
            copy = this.data;
            copym = this.mathmode;
            for k = 1:length(this.data)
                copy[k] = this.data[sidx(k)];
                copym(k,:) = this.mathmode(sidx(k),:);
            end
            this.data= copy;
            this.mathmode= copym;
        }
        function transposed = ctranspose() {
            transposed = this.clone;
            hlp = reshape([this.data[:]],length(this.data[1]),[]);
            transposed.data= [];
            for k=1:size(hlp,1)
                transposed.data[k] = hlp(k,:);
            end
            transposed.contlen= cellfun(@(row)max(cellfun(@(el)length(el),row)),...
                this.data);
            /*  Trigger correct content length guessing if need be */
            transposed.TexMathModeDetection= this.fTexMMode;
            transposed.mathmode= this.mathmode^t;
        }


        function copy = clone() {
            copy = PrintTable(this.Caption);
            copy.ColSep= this.ColSep;
            copy.HasHeader= this.HasHeader;
            copy.HasRowHeader= this.HasRowHeader;
            copy.Format= this.Format;
            copy.TightPDF= this.TightPDF;
            copy.data= this.data;
            copy.contlen= this.contlen;
            copy.mathmode= this.mathmode;
            copy.fTexMMode= this.fTexMMode;
            copy.haslatexcommand= this.haslatexcommand;
            copy.StripInsertedTabChars= this.StripInsertedTabChars;
        }
        function joined = append(PrintTable table,rowvec<integer> columns) {
            if isempty(this.data)
                error(" No table rows exists to append to. Why would you want to do that? ");
            end

            joined = this.clone;
            /*  Check data compatibility */
            if ~isa(table," PrintTable ")
                error(" Argument must be a PrintTable instance ");
            end
            if table.NumRows == 0
                return;
            end
            if nargin < 3
                columns = 1:length(table.data[1]);
            end
            if length(this.data[1]) ~= length(columns)
                error(" Invalid column number: Have %d but want to append %d ",length(this.data[1]),length(columns));
            end
            /*  Augment data */
            start = 1;
            if table.HasHeader
                start = 2;
            end
            for k=start:length(table.data)
                joined.data[end+1] = table.data[k](columns);
            end
            joined.contlen= max(this.contlen,table.contlen(columns));
            joined.mathmode= [this.mathmode; table.mathmode(:,columns)];
            joined.haslatexcommand= this.haslatexcommand || table.haslatexcommand;
            /*  Transfer Caption if not set locally */
            if ~isempty(joined.Caption)
                joined.Caption= table.Caption;
            end
        }
#if 0 //mtoc++: 'set.ColSep'
function  ColSep(value) {
            if ~isempty(value) && ~isa(value," char ")
                error(" ColSep must be a char array. ");
            end
            this.ColSep= value;
        }

#endif

    
        /* % Getter & Setter */
    public:

        
#if 0 //mtoc++: 'set.HasHeader'
function  HasHeader(value) {
            if ~islogical(value) || ~isscalar(value)
                error(" HasHeader must be a logical scalar. ");
            end
            this.HasHeader= value;
        }

#endif


        
#if 0 //mtoc++: 'set.HasRowHeader'
function  HasRowHeader(value) {
            if ~islogical(value) || ~isscalar(value)
                error(" HasRowHeader must be a logical scalar. ");
            end
            this.HasRowHeader= value;
        }

#endif


        
#if 0 //mtoc++: 'set.Caption'
function  Caption(value) {
            if ~isempty(value) && ~ischar(value)
                error(" Caption must be a character array. ");
            end
            this.Caption= value;
        }

#endif


        
#if 0 //mtoc++: 'set.Format'
function  Format(value) {
            if ~any(strcmp([" txt "," tex "," pdf "],value))
                error(" Format must be either  "" txt ""  or  "" tex "" . ");
            end
            this.Format= value;
       end

       function set.TabCharLen(this, value)
          if isscalar(value) && value > 0 && round(value) == value
             this.TabCharLen= value;
          else
             error(" Invalid argument for TabCharLen. Must be a positive integer scalar. ");
          end
       end

        function value = get.NumRows(this)
            value = length(this.data);
            if this.HasHeader
                value = max(0,value-1);
            end
        }

#endif

#if 0 //mtoc++: 'set.TexMathModeDetection'
function  TexMathModeDetection(value) {
            if this.fTexMMode ~= value
                if ~islogical(value) || ~isscalar(value)
                    error(" TexMathModeDetection must be true or false. ");
                end
                this.fTexMMode= value;
                this.updateContentLengths;
            end
        }

#endif


        
#if 0 //mtoc++: 'get.TexMathModeDetection'
function value = TexMathModeDetection() {
            value = this.fTexMMode;
        }

#endif

    
        /* % Internal helpers */
    private:


        function  updateContentLengthAt(idx) {
            fun = @(str,num)length(str) + 2*num; /* 2 characters for local $ tex environment */

            ismm = num2cell(this.mathmode(idx,:));
            this.contlen= max([this.contlen; cellfun(fun,this.data[idx],ismm)]);
        }


        function  updateContentLengths() {
            if ~isempty(this.data)
                this.contlen= ones(1,length(this.data[1]));
                for idx = 1:length(this.data)
                    this.updateContentLengthAt(idx);
                end
            end
        }


        function  printPlain(outfile) {
            if ~isempty(this.Caption)
                fprintf(outfile," Table  "" %s "" :\n ",this.Caption);
            end
            for ridx = 1:length(this.data)
                this.printRow(ridx,outfile,this.ColSep);
                fprintf(outfile," \n ");
                if ridx == 1 && this.HasHeader
                    /*  Compute number of tabs */
                    ttabs = 0;
                    for i = 1:length(this.data[ridx])
                        ttabs = ttabs +  ceil((length(this.ColSep)*(i~=1)+this.contlen(i))/this.TabCharLen);
                    end
                    fprintf(outfile," %s\n ",repmat(" _ ",1,(ttabs+1)*this.TabCharLen));
                end
            end
        }
        function  printTex(outfile) {

            if ~this.TexMathModeDetection && this.haslatexcommand
                warning(" PrintTable:TexExport ",...
                    " No TexMathModeDetection enabled but LaTeX commands have been detected. Export might produce invalid LaTeX code. ");
            end

            /*  Add verbose comment */
            if ~isempty(this.Caption)
                fprintf(outfile," %% PrintTable '%s' generated on %s\n ",this.Caption,datestr(clock));
            else
                fprintf(outfile," %% PrintTable generated on %s\n ",datestr(clock));
            end
            d = dbstack;
            d = d(find(~strcmp([d(:).file]," PrintTable.m "),1));
            if ~isempty(d)                
                fprintf(outfile," %% Created in %s:%d at %s\n ",d.name,d.line,which(d.file));
            end
            /*  Add an informative comment to make the user aware of it's options :-) */
            fprintf(outfile," %% Export settings: TexMathModeDetection %d, HasHeader %d, HasRowHeader %d, StripInsertedTabChars %d, IsPDF %d, TightPDF %d\n ",...
                    this.TexMathModeDetection,this.HasHeader,this.HasRowHeader,this.StripInsertedTabChars,...
                    strcmp(this.Format," pdf "),this.TightPDF);
            cols = 0;
            if ~isempty(this.data)
                cols = length(this.data[1]);
            end
            /*  Only add surroundings for pure tex output or full-sized PDF
             * generation */
            if strcmp(this.Format," tex ") || ~this.TightPDF
                fprintf(outfile," \\begin{table}[!hb]\n\t\\centering\n\t\\def\\arraystretch{1.3}\n\t ");
            elseif ~isempty(this.Caption)
                /*  Enable this if you want, but i found no straight way of putting the caption
                 * above the table (for the given time&resources :-))
                 *fprintf(outfile,'Table: %s\n',this.Caption); */
            end
            if this.HasRowHeader
                aligns = [" r " repmat(" l ",1,cols-1)];
            else
                aligns = repmat(" l ",1,cols);
            end
            fprintf(outfile," \\begin{tabular}{%s}\n ",aligns);
            /*  Print all rows */
            for ridx = 1:length(this.data)
                fprintf(outfile," \t\t ");
                this.printRow(ridx,outfile," &  ");
                fprintf(outfile," \\\\\n ");
                if ridx == 1 && this.HasHeader
                    fprintf(outfile," \t\t\\hline\\\\\n ");
                end
            end
            fprintf(outfile, " \t\\end{tabular}\n ");
            /*  Only add surroundings for pure tex output or full-sized PDF
             * generation */
            if strcmp(this.Format," tex ") || ~this.TightPDF
                if ~isempty(this.Caption)
                    fprintf(outfile," \t\\caption{%s}\n ",this.Caption);
                end
                fprintf(outfile, " \\end{table}\n ");
            end
        }
        function  pdfExport(path,fname) {
            [status, msg] = system(" pdflatex --version ");
            if status ~= 0
                error(" pdfLaTeX not found or not working:\n%s ",msg);
            else
                cap = " table ";
                if ~isempty(this.Caption)
                    cap = [ this.Caption ];
                end
                fprintf(" Exporting %s to PDF using '%s'...\n ",cap,msg(1:strfind(msg,sprintf(" \n "))-1));
            end

            texfile = fullfile(path, [fname " .tex "]);
            fid = fopen(texfile," w ");
            fprintf(fid," \\documentclass{article}\n\\begin{document}\n ");
            if this.TightPDF
                fprintf(fid," \\newsavebox{\\tablebox}\n\\begin{lrbox}{\\tablebox}\n ");
            else
                fprintf(fid, " \\thispagestyle{empty}\n ");
            end
            /*  Print actual tex table */
            this.print(fid);
            if this.TightPDF
                fprintf(fid, [" \\end{lrbox}\n\\pdfhorigin=0pt\\pdfvorigin=0pt\n "...
                    " \\pdfpagewidth=\\wd\\tablebox\\pdfpageheight=\\ht\\tablebox\n "...
                    " \\advance\\pdfpageheight by \\dp\\tablebox\n "...
                    " \\shipout\\box\\tablebox\n "]);
            end
            fprintf(fid," \\end{document} ");
            fclose(fid);
            [status, msg] = system(sprintf(" pdflatex -interaction=nonstopmode -output-directory='%s' %s ",path,texfile));/* #ok */

            if 0 ~= status
                delete(fullfile(path, [fname " .pdf "]));
                fprintf(2," PDF export failed, pdflatex finished with errors. See the <a href='matlab:edit( "" %s "" )'>LaTeX logfile</a> for details.\n ",fullfile(path, [fname " .log "]));
            else
                delete(fullfile(path, [fname " .log "]));
                fprintf(" done!\n ");
            end
            delete(texfile,fullfile(path, [fname " .aux "]));
        }


        function  printRow(rowidx,outfile,sep) {
            row = this.data[rowidx];
            /*  Check if mathmode has been determined */
            if ~isempty(this.mathmode)
                ismm = this.mathmode(rowidx,:);
            else
                ismm = false(size(row));
            end
            /*  Check if we are producing tex-based output */
            istex = any(strcmp(this.Format,[" tex ", " pdf "]));
            sl = length(sep);
            for i = 1:length(row)-1
                str = row[i];
                if istex && this.fTexMMode && ismm(i)
                    str = [" $ " str " $ "];/* #ok */

                end
                fillstabs = floor((sl*(i~=1)+length(str))/this.TabCharLen);
                tottabs = ceil((sl*(i~=1)+this.contlen(i))/this.TabCharLen);
                fprintf(outfile," %s%s ",[str repmat(char(9),1,tottabs-fillstabs)],sep);
            end
            str = row[end];
            if istex && this.fTexMMode && ismm(end)
                str = [" $ " str " $ "];
            end
            fprintf(outfile," %s ",str);
        }
        function [str , ismm ] = stringify(data) {

            /*  Format cell array given */
            if iscell(data[end])
                /*  if format cell is only one item but have more values,
                 * apply same format string */
                if length(data[end]) == 1 && length(data)-1 > 1
                    data[end] = repmat(data[end],1,length(data)-1);
                elseif this.HasRowHeader && length(data[end]) == length(data)-2
                    data[end] = [" %s " data[end]];
                elseif length(data[end]) ~= length(data)-1
                    error(" Either provide a single format string or one for each column. ");
                end
                str = cell(1,length(data)-1);
                /*  Apply sprintf pattern to each element */
                start = 1;
                if this.HasRowHeader
                    str(1) = this.stringify(data(1));
                    start = 2;
                end
                for i=start:length(data)-1
                    if isa(data[end][i]," function_handle ")
                        if nargin(data[end][i]) > 1
                            tmpstr = data[end][i](data[i],i);
                        else
                            tmpstr = data[end][i](data[i]);
                        end
                    else
                        tmpstr = sprintf(data[end][i],data[i]);
                    end
                    tmpstr = strrep(tmpstr,char(10),);
                    /*  Strip tab chars if set */
                    if this.StripInsertedTabChars
                        str[i] = strrep(tmpstr,char(9),);
                    else
                        str[i] = tmpstr;
                    end
                end
            else /*  convert to strings if no specific format is given */

                str = cell(1,length(data));
                for i=1:length(data)
                    el = data[i];
                    if isa(el," char ")
                        el = strrep(el,char(10),);
                        /*  Use char array directly and strip tab characters if desired */
                        if this.StripInsertedTabChars
                            str[i] = strrep(el,char(9),);
                        else
                            str[i] = el;
                        end
                    elseif isinteger(el)
                        if numel(el) > 1
                            str[i] = [" [ " this.implode(el(:)," ,  "," %d ") " ] "];
                        else
                            str[i] = sprintf(" %d ",el);
                        end
                    elseif isnumeric(el)
                        if numel(el) > 1
                            if isvector(el) && length(el) < 100
                                str[i] = [" [ " this.implode(el(:)," ,  "," %g ") " ] "];
                            else
                                str[i] = [" [ " this.implode(size(el)," x "," %d ") "   " class(el) " ] "];
                            end
                        else
                            if isempty(el)
                                str[i] = " [] ";
                            else
                                str[i] = sprintf(" %g ",el);
                            end
                        end
                    elseif isa(el," function_handle ")
                        str[i] = func2str(el);
                    elseif isa(el," handle ")
                        mc = metaclass(el);
                        str[i] = mc.Name;
                    elseif islogical(el)
                        if numel(el) > 1
                            str[i] = this.implode(el(:)," ,  "," %d ");
                        else
                            str[i] = sprintf(" %d ",el);
                        end
                    else
                        error(" Cannot automatically convert an argument of type %s for PrintTable display. ",class(el));
                    end
                end
            end
            /*  Detect if any of the cell contents are numerical values */
            fun = @(arg)~isempty(arg) && arg(1) ~= " $ " && arg(end) ~= " $ " ...
                        && (~isnan(str2double(arg)) || ~isempty(strfind(arg," \ ")) || ~isempty(strfind(arg," _ ")) || ~isempty(strfind(arg," ^ ")));
            ismm = cellfun(fun,str);
        }
        function str = implode(data,glue,format) {
            str = ;
            if ~isempty(data)
                if nargin < 3
                    format = " %2.3e ";
                    if nargin < 2
                        glue = " ,  ";
                    end
                end
                if isa(data," cell ")
                    str = data[1];
                    for idx = 2:length(data)
                        str = [str glue data[idx]];/* #ok */

                    end
                elseif isnumeric(data)
                    /*  first n-1 entries */
                    if numel(data) > 1
                        str = sprintf([format glue],data(1:end-1));
                    end
                    /*  append last, no glue afterwards needed */
                    str = [str sprintf(format,data(end))];
                else
                    error(" Can only pass cell arrays of strings or a vector with sprintf format pattern ");
                end
            end
        }

    
        /* % Tests */
    public: /* ( Static ) */

        static function [res , doublet ] = test_PrintTable() {
            t = PrintTable;
            t.Caption= " This is my PrintTable test. ";
            t.addRow(" A "," B "," C ");
            t.addRow(" 123 ",456E10," 789 ");
            t.addRow(1234567," 12345 "," 789 ");
            t.addRow(" 1234567 ",123456," 789 ");
            t.addRow(" 34 "," \sin(x)+4 "," somestring ");
            t.addRow(" foo "," bar ",datestr(clock));
            t.addRow(123.45678,pi,789,[" %2.3f "," $%4.4g$ "," decimal: %d "]);

            /*  If HasHeader is set, the format args can be omitted for the first column. */
            t.HasRowHeader= true;
            t.addRow(123.45678,pi,789,[" $%4.4g$ "," decimal: %d "]);
            t.HasRowHeader= false;

            t.addRow(" 12345678 "," \latexcommand{foo}+5 "," 789 ");
            t.addRow(" yet  "," 123 "," 789 ");
            t.addRow(123.45678,pi,789,[" %2.3f ",@(v)sprintf(" functioned pi=%g! ",v-3)," decimal: %d "]);
            t.addRow(2,2,2,[@(v,colidx)sprintf(" callback using column index: %d! ",v^colidx)]);
            t.addRow(" single ",pi," fun with colidx ",[" %s ",@(v,colidx)sprintf(" value at column %d: %g! ",colidx,v)," %s "]);
            t.addRow(" next col with tabs ",char(9)," StripInsertedTabChars on ",[" %s "," >\t>%s>\t> "," %s "]);

            fprintf(2," test_PrintTable: Plain text display:\n ");
            t.display;

            fprintf(2," test_PrintTable: Plain text display with no tab stripping:\n ");
            t.StripInsertedTabChars= false;
            t.addRow(" next col with tabs ",char(9)," StripInsertedTabChars off (destroys layout) ",[" %s "," >\t>%s>\t> "," %s "]);
            t.display;
            t.removeRow(t.NumRows);

            fprintf(2," test_PrintTable: Plain text display with header:\n ");
            t.HasHeader= true;
            t.display;

            fprintf(2," test_PrintTable: LaTeX display:\n ");
            t.HasHeader= false;
            t.Format= " tex ";
            t.print;

            fprintf(2," test_PrintTable: LaTeX display with header:\n ");
            t.HasHeader= true;
            t.print;
            t.HasHeader= false;

            fprintf(2," test_PrintTable: LaTeX display and no TexMathModeDetection:\n ");
            t.TexMathModeDetection= false;
            t.print;
            t.TexMathModeDetection= true;

            fprintf(2," test_PrintTable: LaTeX display of transposed:\n ");
            tt = t^t;
            tt.print;

            fprintf(2," test_PrintTable: Plain text display of transposed:\n ");
            tt.Format= " txt ";
            tt.print;
            res = true;
        }
        static function [res , doublet ] = test_PrintTable_Misc() {
            t = PrintTable(" This is PrintTable Misc Features test, created on %s ",datestr(now));
            t.HasRowHeader= true;
            t.HasHeader= true;
            t.addRow(" A "," B "," C ");
            t.addRow(" header-autofmt ",456,789,[" %d "]);
            t.addRow(1234.345,456,789,[" %2.2E "," %d "," %d "]);
            t.addRow(" header-expl-fmt ",456,pi,[" %s "," %d "," %2.2f "]);
            t.addRow(" nofmt-header ",456,pi,[" %d "," %f "]);
            t.addRow(" 1234567 "," 12345 "," 789 ");
            t.addRow(" foo "," bar ",datestr(clock));
            t.addRow(123.45678,pi,789,[" %2.3f "," %4.4g "," decimal: %d "]);
            t.addRow(12345678," 123 "," 789 ");
            t.addRow(12345.6789," 123 "," 789 ");
            t.display;

            fprintf(2," test_PrintTable_Misc: Tex-Format:\n ");
            t.Format= " tex ";
            t.print;

            fprintf(2," test_PrintTable_Misc: Tex-Format with Row Header:\n ");
            t.HasHeader= true;
            t.print;

            fprintf(2," test_PrintTable_Misc: Self-Appended:\n ");
            t.Format= " txt ";
            ta = t.append(t);
            ta.display;

            t2 = PrintTable(" dummy ");
            t2.addRow(" A "," B "," C "," D "," E ");
            t2.addRow(" header1 ",456,789,1,34,[" %d "]);
            t2.addRow(12345.6789," 123 "," 789 "," foo "," bar ");
            t2.addRow(" header2 ",4656,35789,351,4);

            fprintf(2," test_PrintTable_Misc: Test table to append:\n ");
            t2.display;

            fprintf(2," test_PrintTable_Misc: Appending some test table columns (with header):\n ");
            ta = t.append(t2,[1 3 5]);
            ta.display;

            fprintf(2," test_PrintTable_Misc: Appending some test table columns (without header):\n ");
            t2.HasHeader= true;
            ta = t.append(t2,[4 2 1]);
            ta.display;

            /*  Empty table append test */
            t2.clear;
            t.append(t2);

            res = true;
        }
        static function [res , doublet ] = test_PrintTable_LaTeX_Export() {
            t = PrintTable(" LaTeX/PDF export demo, %s ",datestr(now));
            t.HasRowHeader= true;
            t.HasHeader= true;
            t.addRow(" A "," B "," C ");
            t.addRow(" Data 1 ",456,789,[" %d "]);
            t.addRow(1234.345,456,789,[" $%2.2E$ "," $%d$ "," $%d$ "]);
            t.addRow(" header-expl-fmt ",456,pi,[" %s "," %d "," %2.2f "]);
            t.addRow(" 1234567 "," 12345 "," 789 ");
            x = 4;
            t.addRow(" x=4 "," \sin(x) ",sin(x),[" %s "," %f "]);
            /*  Explicit wrapping directly or with $$ per format string */
            t.addRow(" x=4 "," 25 (5*5)= ",5*5,[" $%s$ "," %d "]);
            /*  (have HasRowHeader, thus the first format string is not necessary (but yet
             * possible to define)) */
            t.addRow(" $x=4,\alpha=.2$ "," \alpha\exp(x)\cos(x) ",.2*exp(x)*cos(x),[" $%s$ "," %f "]);
            t.display;

            /*  LaTeX */
            t.saveToFile(" myLaTeXexportedPrintTable.tex ",true);

            /*  Tight PDF */
            t.saveToFile(" mytable_tightpdf.pdf ",true);

            /*  Whole page PDF */
            t.TightPDF= false;
            t.TexMathModeDetection= true;
            t.saveToFile(" mytable_fullpage.pdf ",true);
            res = true;
        }
        static function [res , doublet ] = test_PrintTable_Failed_LaTeX_Export() {
            t = PrintTable(" LaTeX/PDF export demo (THIS MUST FAIL!), %s ",datestr(now));
            t.HasRowHeader= true;
            t.HasHeader= true;
            t.TexMathModeDetection= false;
            t.addRow(" A "," B "," C ");
            t.addRow(" Data 1 ",456,789,[" %d "]);
            t.addRow(1234.345,456,789,[" $%2.2E$ "," $%d$ "," $%d$ "]);
            t.addRow(" header-expl-fmt ",456,pi,[" %s "," %d "," %2.2f "]);
            t.addRow(1234567," 12345 ",45.3463E-4);
            x = 4;
            /*  This is the offending latex line */
            t.addRow(" x=4 "," \sin(x) ",sin(x),[" %s "," %f "]);
            /*  Explicit wrapping directly or with $$ per format string */
            t.addRow(" x=4 "," 25 (5*5)= ",5*5,[" $%s$ "," %d "]);
            t.addRow(" $x=4,\alpha=.2$ "," \alpha\exp(x)\cos(x) ",.2*exp(x)*cos(x),[" $%s$ "," %f "]);
            t.display;
            try
                t.saveToFile(" mytable_tightpdf_nodetection.pdf ",true);
            catch ME
                fprintf(2," TEST FAILED AS EXPECTED, WARNING HAS BEEN ISSUED. ALL GOOD.\n ");
                res = true;
                return;
            end
            res = false;
        }

    
    private: /* ( Static ) */

        static function l = getDefaultTabCharLen() {

            /*  Use default value 8 */
            defaultLen = 8;

            jDesktop = com.mathworks.mde.desk.MLDesktop.getInstance;
            /*  Display of output in command window */
            if ~isempty(jDesktop.getClient(" Command Window "))
                /*  Display of output in console etc */
                l = com.mathworks.services.Prefs.getIntegerPref(" CommandWindowSpacesPerTab ",-1);
                if l < 0
                    l = com.mathworks.services.Prefs.getIntegerPref(" EditorSpacesPerTab ",defaultLen);
                end
            elseif isunix
                [c, l] = system(" echo -n $ "" \t ""  | wc -L ");
                if c == 0
                    l = str2double(l);
                else
                    l = defaultLen;
                end
            else
                /*  Not checked yet for windows command line, but i guess this will be a rare
                 * occasion. Please share if you encounter this situation. */
                l = defaultLen;
            end
        }
};