Prints the results of the equation to standard out. Useful for debugging
972160
public void print( String equation ) {
        // first assume it's just a variable
        Variable v = lookupVariable(equation);
        if( v == null ) {
            Sequence sequence = compile(equation,false,false);
            sequence.perform();
            v = sequence.output;
        }

        if( v instanceof VariableMatrix ) {
            ((VariableMatrix)v).matrix.print();
        } else if(v instanceof VariableScalar ) {
            System.out.println("Scalar = "+((VariableScalar)v).getDouble() );
        } else {
            System.out.println("Add support for "+v.getClass().getSimpleName());
        }
    }
650995
protected void printResults(PrintStream out) {
        log.debug("printResults()");
        StringBuilder line = new StringBuilder();
        out.println(line);
        out.println();
    }
107375
def _print_result(case, summary):
    
    for case, case_data in summary.items():
        for dof, data in case_data.items():
            print("    " + case + " " + dof)
            print("    -------------------")
            for header, val in data.items():
                print("    " + header + " : " + str(val))
            print("")
643971
def dbg_print(self, indent=0):
        
        lst = []
        more_data = False
        for i, addr in enumerate(self.mem.keys()):
            lst.append(addr)
            if i >= 20:
                more_data = True
                break

        for addr in sorted(lst):
            data = self.mem[addr]
            if isinstance(data, SimMemoryObject):
                memobj = data
                print("%s%xh: (%s)[%d]" % (" " * indent, addr, memobj, addr - memobj.base))
            else:
                print("%s%xh: <default data>" % (" " * indent, addr))
        if more_data:
            print("%s..." % (" " * indent))
234688
def print_values(self, parameter):
        
        if parameter in self.VALUES:
            self.print_info(u"Available values for parameter '%s':" % parameter)
            self.print_generic(u"\n".join(self.VALUES[parameter]))
            return self.HELP_EXIT_CODE
        if parameter not in [u"?", u""]:
            self.print_error(u"Invalid parameter name '%s'" % parameter)
        self.print_info(u"Parameters for which values can be listed:")
        self.print_generic(u"\n".join(sorted(self.VALUES.keys())))
        return self.HELP_EXIT_CODE
355180
def stdout_to_results(s):
    """"""
    results = s.strip().split('\n')
    return [BenchmarkResult(*r.split()) for r in results]
388551
def dump_to_console(pylint_data):
    
    for key, value in list(pylint_data.items()):
        if key not in ('errors', 'total', 'scores', 'average') and len(value) > 0:
            print("\n*********** {}".format(key))
            for line in value:
                print(line.strip('\n'))
            f_score = [score[1] for score in pylint_data['scores'] if score[0] == key][0]
            print("Score: {}".format(f_score))
1035365
def _print_divide(self):
        """"""
        for space in self.AttributesLength:
            self.StrTable += "+ " + "- " * space
        self.StrTable += "+" + "\n"
228697
public static void printResult(Number[][] m1, Number[][] m2, Number[][] m3, char op, PrintStream out)
    {
        for (int i = 0; i < m1.length; i++)
        {
            for (int j = 0; j < m1[0].length; j++)
            {
                out.print(" " + m1[i][j]);
            }

            if (i == m1.length / 2)
            {
                out.print("  " + op + "  ");
            }
            else
            {
                out.print("     ");
            }

            for (int j = 0; j < m2.length; j++)
            {
                out.print(" " + m2[i][j]);
            }

            if (i == m1.length / 2)
            {
                out.print("  =  ");
            }
            else
            {
                out.print("     ");
            }

            for (int j = 0; j < m3.length; j++)
            {
                out.print(m3[i][j] + " ");
            }

            out.println();
        }
    }
348233
def display_breakdown(scores, outfile=None):
    
    total = 0
    outfile = open(outfile, 'w') if outfile else sys.stdout

    format.print_line('-')
    print('Point breakdown', file=outfile)
    for name, (score, max_score) in scores.items():
        print('    {}: {}/{}'.format(name, score, max_score), file=outfile)
        total += score
    print(file=outfile)

    print('Score:', file=outfile)
    print('    Total: {}'.format(total), file=outfile)
    return {'Total': total}
1176214
def Print(self):
        """"""
        for val, prob in sorted(self.d.iteritems()):
            print(val, prob)
186821
def print(self):
        """"""
        cond_var = None
        if self.supported:
            cond_var = conditional_var('{}{}'.format(self.func, self.fn_num))
            print_conditional_if(cond_var)
            print('  AF',  end='')
        else:
            print('  //', end='')
        fn_num = self.fn_num
        if fn_num is None:
            fn_num = 0
        print('({:2d}, {:8s}, {:2d}, {:10s}, {:8s}), // {:s}'.format(self.idx,
              self.func, fn_num, self.pin_type, self.ptr(), self.af_str))
        print_conditional_endif(cond_var)
889301
def printStats(self):
        
        print("--- Imagestats Results ---")

        if (self.fields.find('npix') != -1 ):
            print("Number of pixels  :  ",self.npix)
        if (self.fields.find('min') != -1 ):
            print("Minimum value     :  ",self.min)
        if (self.fields.find('max') != -1 ):
            print("Maximum value     :  ",self.max)
        if (self.fields.find('stddev') != -1 ):
            print("Standard Deviation:  ",self.stddev)
        if (self.fields.find('mean') != -1 ):
            print("Mean              :  ",self.mean)
        if (self.fields.find('mode') != -1 ):
            print("Mode              :  ",self.mode)
        if (self.fields.find('median') != -1 ):
            print("Median            :  ",self.median)
        if (self.fields.find('midpt') != -1 ):
            print("Midpt            :  ",self.midpt)
1304890
def main():
    
    t, kf, t0, major, minor, prod, beta = sympy.symbols(
        't k_f t0 Y Z X beta', negative=False)
    for f in funcs:
        args = [t, kf, prod, major, minor]
        if f in (pseudo_rev, binary_rev):
            args.insert(2, kf/beta)
        expr = f(*args, backend='sympy')
        with open(f.__name__ + '.png', 'wb') as ofh:
            sympy.printing.preview(expr, output='png', filename='out.png',
                                   viewer='BytesIO', outputbuffer=ofh)
        with open(f.__name__ + '_diff.png', 'wb') as ofh:
            sympy.printing.preview(expr.diff(t).subs({t0: 0}).simplify(),
                                   output='png', filename='out.png',
                                   viewer='BytesIO', outputbuffer=ofh)
313178
public static void printResult(Number[][] m1, PrintStream out)
    {
        if (out == null)
        {
            return;
        }
        for (int i = 0; i < m1.length; i++)
        {
            for (int j = 0; j < m1[0].length; j++)
            {
                out.print(" " + m1[i][j]);
            }
            out.println("");
        }
    }
918313
def debug(value):
    
    print("%s %s: " % (type(value), value))
    print(dir(value))
    print('\n\n')
    return ''
62002
public synchronized void printStatistics() {
        // quickly memoize and update counters, get the time, record update time, etc...
        long nowSuccesses = incrementCount.get();
        long nowFailures = failureCount.get();
        long prevSuccesss = lastPeriod.getAndSet(nowSuccesses);
        long endTime = System.currentTimeMillis();
        long startTime = lastStatsReportTS;
        lastStatsReportTS = endTime;

        // do math with as much safety as possible
        long invocationsCompleted = Math.max(nowSuccesses - prevSuccesss, 0);
        long periodDurationMs = Math.max(endTime - startTime, 1);
        long cumulativeDurationMs = Math.max(endTime - benchmarkStartTS, 1);
        long periodThroughput = (long) (invocationsCompleted / (periodDurationMs / 1000.0));
        long cumulativeThroughput = (long) (nowSuccesses / (cumulativeDurationMs / 1000.0));
        long time = (long) (Math.round(endTime - benchmarkStartTS) / 1000.0);

        // print out periodic report
        System.out.printf("%02d:%02d:%02d ", time / 3600, (time / 60) % 60, time % 60);
        System.out.printf("Period Throughput %10d/s, ", periodThroughput);
        System.out.printf("Cumulative Throughput %10d/s, ", cumulativeThroughput);
        System.out.printf("Total Failures %10d", nowFailures);
        System.out.printf("\n");
    }