Script Programming(스크립트 프로그래밍)

# example-start buttons buttons.py

import pygtk
pygtk.require('2.0')
import gtk

# Create a new hbox with an image and a label packed into it
# and return the box.

def xpm_label_box(parent, xpm_filename, label_text):
    # Create box for xpm and label
    box1 = gtk.HBox(False, 0)
    box1.set_border_width(2)

    # Now on to the image stuff
    image = gtk.Image()
    image.set_from_file(xpm_filename)

    # Create a label for the button
    label = gtk.Label(label_text)

    # Pack the pixmap and label into the box
    box1.pack_start(image, False, False, 3)
    box1.pack_start(label, False, False, 3)

    image.show()
    label.show()
    return box1

class Buttons:
    # Our usual callback method
    def callback(self, widget, data=None):
        print "Hello again - %s was pressed" % data

    def __init__(self):
        # Create a new window
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)

        self.window.set_title("Image'd Buttons!")

        # It's a good idea to do this for all windows.
        self.window.connect("destroy", lambda wid: gtk.main_quit())
        self.window.connect("delete_event", lambda a1,a2:gtk.main_quit())

        # Sets the border width of the window.
        self.window.set_border_width(10)

        # Create a new button
        button = gtk.Button()

        # Connect the "clicked" signal of the button to our callback
        button.connect("clicked", self.callback, "cool button")

        # This calls our box creating function
        box1 = xpm_label_box(self.window, "info.xpm", "cool button")

        # Pack and show all our widgets
        button.add(box1)

        box1.show()
        button.show()

        self.window.add(button)
        self.window.show()

def main():
    gtk.main()
    return 0    

if __name__ == "__main__":
    Buttons()
    main()

import java.io._

object testHexView_03 {

    def printUsage() {
        println("Usage: scala testHexView_03 [filename]")
    }

    def toHex(n: Int) : String = {
        var s = ""
        var x1 = (n & 0xF0) >> 4
        var x2 = n & 0xF
        if (x1 < 10) {
            s = s + "%c".format(('0' + x1) toChar)
        }
        else {
            s = s + "%c".format('A' + (x1 - 10))
        }
        if (x2 < 10) {
            s = "%s%c".format(s, ('0' + x2) toChar)
        }
        else {
            s = s + "%c".format('A' + (x2 - 10))
        }
        return s
    }

    def toHex8(n: Int) : String = {
        var s = ""
        var x1 = (n & 0xF0000000) >> 28
        var x2 = (n & 0xF000000) >> 24
        var x3 = (n & 0xF00000) >> 20
        var x4 = (n & 0xF0000) >> 16
        var x5 = (n & 0xF000) >> 12
        var x6 = (n & 0xF00) >> 8
        var x7 = (n & 0xF0) >> 4
        var x8 = n & 0xF
        if (x1 < 10) {
            s = s + "%c".format(('0' + x1) toChar)
        }
        else {
            s = s + "%c".format('A' + (x1 - 10))
        }
        if (x2 < 10) {
            s = "%s%c".format(s, ('0' + x2) toChar)
        }
        else {
            s = s + "%c".format('A' + (x2 - 10))
        }
        if (x3 < 10) {
            s = "%s%c".format(s, ('0' + x3) toChar)
        }
        else {
            s = s + "%c".format('A' + (x3 - 10))
        }
        if (x4 < 10) {
            s = "%s%c".format(s, ('0' + x4) toChar)
        }
        else {
            s = s + "%c".format('A' + (x4 - 10))
        }
        s = s + " "
        if (x5 < 10) {
            s = "%s%c".format(s, ('0' + x5) toChar)
        }
        else {
            s = s + "%c".format('A' + (x5 - 10))
        }
        if (x6 < 10) {
            s = "%s%c".format(s, ('0' + x6) toChar)
        }
        else {
            s = s + "%c".format('A' + (x6 - 10))
        }
        if (x7 < 10) {
            s = "%s%c".format(s, ('0' + x7) toChar)
        }
        else {
            s = s + "%c".format('A' + (x7 - 10))
        }
        if (x8 < 10) {
            s = "%s%c".format(s, ('0' + x8) toChar)
        }
        else {
            s = s + "%c".format('A' + (x8 - 10))
        }
        return s
    }

    def main(args: Array[String]) {
            if (args.length < 1) {
                printUsage()
                System.exit(1)
            }

            var fname : String = args(0)

            var infile : File = new File(fname);
            if  (!infile.exists()) {
                 System.out.println("The file \"" + fname + "\" does not exist.");
                 System.exit(1);
            }

            if (!infile.canRead()) {
                 System.out.println("The file \"" + fname + "\" is not allowed to be read.");
                 System.exit(1);
            }   

            if  (infile.isDirectory()) {
                 System.out.println("\"" + fname + "\" is a directory.");
                 System.exit(1);
            }

            val is = new FileInputStream(fname)
            val cnt = is.available

            var lines = new Array[String](19)
            var b = new Array[Byte](1)

            printf("The size of the file \"%s\" is %d.\n", fname, cnt)
            printf("\n")

            var n = 0
            var dum = ""
            while (n < cnt) {
                if (n % 16 == 0) {
                    printf("%s: ", toHex8(n))
                }
                is.read(b)
                if (n % 16 == 8) {
                    printf("-%s", toHex(b(0) toInt))
                }
                else {
                    printf(" %s", toHex(b(0) toInt))
                }
                if ((b(0) toInt) < (' ' toInt) || (b(0) toInt) > 0x7F) {
                    dum = dum + "."
                }
                else {
                    dum = dum + "%c".format(b(0) toChar)
                }
                if (n % 16 == 15) {
                    printf("  |%s|\n", dum)
                    dum = ""
                }
                n += 1
            }
            if (n % 16 > 0) {
                for (j <- 1 to 16 - (n % 16)) {
                    printf("   ")
                }
                printf("  |%s", dum)
                for (j <- 1 to 16 - (n % 16)) {
                    printf(" ")
                }
                printf("|\n", dum)
                dum = ""
            }
            printf("\nRead %d bytes.\n", n)

            is.close()
    }
}

# Filename: testHexView_02.rb
#
# Execute: ruby testHexView_02.rb [filename]

def toHex(b)
    s = ""
    x1 = (b & 0xF0) >> 4
    x2 = b & 0x0F
    if x1 < 10 then
        s += (x1 + '0'[0].ord).chr
    else
        s += ((x1 - 10) + 'A'.ord).chr
    end
    if (x2 < 10)
        s += (x2 + '0'.ord).chr
    else
        s += ((x2 - 10) + 'A'.ord).chr
    end
    return s
end

def toHex8(n)
    s = ""
    x1 = (n & 0xF0000000) >> 28
    x2 = (n & 0xF000000) >> 24
    x3 = (n & 0xF00000) >> 20
    x4 = (n & 0xF0000) >> 16
    x5 = (n & 0xF000) >> 12
    x6 = (n & 0xF0) >> 8
    x7 = (n & 0xF0) >> 4
    x8 = n & 0x0F
    if x1 < 10 then
        s += (x1 + '0'.ord).chr
    else
        s += ((x1 - 10) + 'A'.ord).chr
    end
    if x2 < 10 then
        s += (x2 + '0'.ord).chr
    else
        s += ((x2 - 10) + 'A'.ord).chr
    end
    if x3 < 10 then
        s += (x3 + '0'.ord).chr
    else
        s += ((x3 - 10) + 'A'.ord).chr
    end
    if x4 < 10 then
        s += (x4 + '0'.ord).chr
    else
        s += ((x4 - 10) + 'A'.ord).chr
    end
    s += " "
    if x5 < 10 then
        s += (x5 + '0'.ord).chr
    else
        s += ((x5 - 10) + 'A'.ord).chr
    end
    if x6 < 10 then
        s += (x6 + '0'.ord).chr
    else
        s += ((x6 - 10) + 'A'.ord).chr
    end
    if x7 < 10 then
        s += (x7 + '0'.ord).chr
    else
        s += ((x7 - 10) + 'A'.ord).chr
    end
    if x8 < 10 then
        s += (x8 + '0'.ord).chr
    else
        s += ((x8 - 10) + 'A'.ord).chr
    end
  
    return s
end

fname = ARGV[0]
begin
    if fname == nil then
        print "Usage: ruby testHexView_02.rb [filename]\n"
        exit(1)
    elsif not File.exist?(fname) then
        print "The file '%s' does not exist.\n" % fname
        exit(1)
    elsif File.directory?(fname) then
        print "%s is a directory\n" % fname
        exit(1)
    end

    fsize = File.size?(fname)
    if fsize != nil then
        print "The size of the file \"%s\" is %d.\n" % [fname, fsize]
        if fsize == 0 then
            exit(1)
        end
    end
    puts
    file2 = File.open(fname, "r")

    n = 0
    dum = ""
    fsize.times {
        if n % 16 == 0 then
            print "%s: " % toHex8(n & 0xFFFFFFFF)
        end
             
        if n % 16 != 8 then
            print " "
        else
            print "-"
        end

        a = file2.read(1)
        print "%s" % toHex(a.ord.to_i & 0xFF)
               
        if a.ord.to_i < ' '.ord.to_i or a.ord.to_i > 0x7F then
            dum += "."
        else
            dum += a
        end
               
        if n > 0 and n % 16 == 15 then
            print "  |%s|\n" % dum
            dum = ""
        end             

        n += 1
    }

    if n > 0 and n % 16 > 0 then
        (16 - (fsize % 16)).times {
            print "   "
        }
        print "  |%s" %dum
        (16 - (fsize % 16)).times {
            print " "
        }
        print "|\n"
        dum = ""
    end

    file2.close
    puts
    print "Read %d bytes\n" % n
rescue => err
    puts "Exception: #{err}"
    err
end

(greet "world!")

#!/usr/bin/env lua

-- Filename: testNthRoot.lua
--
--            Approximate square roots, cubic roots and n-th roots of a given number.
--
-- Execute: lua testNthRoot.lua
--
-- Date: 2013. 1. 7.
-- Copyright (c) 2013 PH Kim  (pkim __AT__ scripts.pe.kr)

local MAX_ITER = 20000
local M_EPSILON = 1.0e-15

local BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"

function itoa(num, radix) 
    local isNegative = false 
    if num < 0 then 
        isNegative = true 
        num = -num 
    end

    local arr = {} 
    local q, r = num, 0 
    while q >= radix do 
        r = math.fmod(q, radix) 
        q = math.floor(q / radix) 
        table.insert(arr, string.sub(BASE36, r+1, r+1)) 
    end

    table.insert(arr, string.sub(BASE36, q+1, q+1)) 
    if isNegative then 
        table.insert(arr, "-") 
    end 
    local ret = "" 
    for i = #arr, 1, -1 do 
        ret = ret .. arr[i] 
    end 
    return ret
end

--
-- Compute the n-th root of x to a given scale, x > 0.
--
function nPow(a, n)
    if n > 0 then
        if n == 1 then
            return a
        else
            if a == 0.0 or a == 1.0 then
                return a
            elseif a == -1.0 then
                if n % 2 == 1 then
                    return -1.0
                else
                    return 1.0
                end
            elseif a < 0.0 then
                if n % 2 == 1 then
                    return -nPow(-a, n)
                else
                    return nPow(-a, n)
                end
            else
                local y = 1.0
                for i = 1, n do
                    y = y * a
                end
                return y
            end
        end
    elseif n == 0 then
        return 1.0
    else      --  when n < 0
        if a == 0.0 then
            error('Negative powering exception of zero.')
        else
            if n == -1 then
                return 1.0/a
            else
                return 1.0/nPow(a, -n)
            end
        end
    end
end

--
-- Compute the n-th root of x to a given scale, x > 0.
--
function gPow(a, n)
    if n > 0 then
        if n == 1 then
            return a
        else
            if a == 0.0 or a == 1.0 then
                return a
            elseif a == -1.0 then
                if n % 2 == 1 then
                    return -1.0
                else
                    return 1.0
                end
            elseif a < 0.0 then
                if n % 2 == 1 then
                    return -gPow(-a, n)
                else
                    return gPow(-a, n)
                end
            else
                local y = 1.0
                local r = a
                local m = 8*4 - 1           --  8*sizeof(int) - 1;
                local one = 1
                local sn = itoa(n, 2)
                for i = 0, m-1 do
                    if string.sub(sn, string.len(sn) - i, string.len(sn) - i) == '0' then          
                        y = y * 1.0
                    else
                        y = y * r
                    end
                    r = r*r
                    one = one * 2
                    if one > n then
                        break
                    end
                end
                return y
            end
        end
    elseif n == 0 then
        return 1.0
    else      --  when n < 0
        if a == 0.0 then
            error('Negative powering exception of zero.')
        else
            if n == -1 then
                return 1.0/a
            else
                return 1.0/gPow(a, -n)
            end
        end
    end
end

--
-- Compute the n-th root of x to a given scale, x > 0.
--
function mPow(a, n)
    if n > 0 then
        if n == 1 then
            return a
        else
            if a == 0.0 or a == 1.0 then
                return a
            elseif a == -1.0 then
                if n % 2 == 1 then
                    return -1.0
                else
                    return 1.0
                end
            elseif a < 0.0 then
                if n % 2 == 1 then
                    return -mPow(-a, n)
                else
                    return mPow(-a, n)
                end
            else
                y = 1.0
                r = a
                m = n
                while m > 0 do
                    if (m % 2) == 1 then
                        y = y * r
                    end
                    r = r*r
                    m = math.floor(m / 2)
                end
                return y
            end
        end
    elseif n == 0 then
        return 1.0
    else      --  when n < 0
        if a == 0.0 then
            error('Negative powering exception of zero.')
        else
            if n == -1 then
                return 1.0/a
            else
                return 1.0/mPow(a, -n)
            end
        end
    end
end

--
-- Compute the square root of x to a given scale, x > 0.
--
function heronSqrt(a)
    if a < 0.0 then
        error('Cannot find the sqrt of a negative number.')
    elseif a == 0.0 or a == 1.0 then
        return a
    else
        local x1 = a
        local x2 = (x1 + a/x1)/2.0
        local er = x1 - x2
        local counter = 0
        while x1 + er ~= x1 do
            x1 = x2
            x2 = (x1 + a/x1)/2.0
            er = x1 - x2
            if math.abs(er) < math.abs(M_EPSILON*x1) then
                break
            end
            counter = counter + 1
            if counter > MAX_ITER then
                break
            end
        end
        if counter >= MAX_ITER then
            error('Inaccurate sqrt exception by too many iterations.')
        end
        return x2
    end
end

--
-- Compute the cubic root of x to a given scale, x > 0.
--
function newtonCbrt(a)
    if a == 0.0 or a == 1.0 or a == -1.0 then
        return a
    elseif a < 0.0 then
        return -newtonCbrt(-a)
    else
        local x1 = a
        local x2 = (2.0*x1 + a/(x1*x1))/3.0
        local er = x1 - x2
        local counter = 0
        while x1 + er ~= x1 do
            x1 = x2
            x2 = (2.0*x1 + a/(x1*x1))/3.0
            er = x1 - x2
            if math.abs(er) < math.abs(M_EPSILON*x1) then
                break
            end
            counter = counter + 1
            if counter > MAX_ITER then
                break
            end
        end
        if counter >= MAX_ITER then
            error('Inaccurate cbrt exception by too many iterations.')
        end
        return x2
    end
end

--
-- Compute the n-th root of x to a given scale, x > 0.
--
function newtonNthRoot(n, a)
    if n == 0 then
        return 1.0
    elseif n == 1 then
        return a
    elseif n > 0 then
        if a == 0.0 or a == 1.0 then
            return a
        elseif a == -1.0 then
            if n % 2 == 1 then
                return a
            else
                error('Cannot find the even n-th root of a negative number.')
            end
        elseif a < 0.0 then
            if n % 2 == 1 then
                return -newtonNthRoot(n, -a)
            else
                error('Cannot find the even n-th root of a negative number.')
            end
        elseif a < 1.0 then
            return 1.0/newtonNthRoot(n, 1.0/a)
        else
            local x1 = a
            local xn = mPow(x1, n - 1)
            local x2 = ((n - 1)*x1 + a/xn)/n
            local er = x1 - x2
            local counter = 0
            while x1 + er ~= x1 do
                x1 = x2
                xn = mPow(x1, n - 1)
                x2 = ((n - 1)*x1 + a/xn)/n
                er = x1 - x2
                if math.abs(er) < math.abs(M_EPSILON*x1) then
                    break
                end
                counter = counter + 1
                if counter > MAX_ITER then
                    break
                end
            end
            if counter >= MAX_ITER then
                error('Inaccurate n-th root exception by too many iterations.')
            end
            return x2
        end
    else
        if a == 0.0 then
            error('Cannot find the negative n-th root of zero.')
        else
            return 1.0/newtonNthRoot(-n, a)
        end
    end
end

local x = 16.0
local u = math.sqrt(x)

print("[ Testing heronSqrt(double) ]--------------------")
print(string.format("x = %g", x))
print(string.format("u = sqrt(%g) = %g", x, u))
y = heronSqrt(x)
print(string.format("y = heronSqrt(%g) = %g", x, y))
print(string.format("y*y = %g", y*y))
print()

print("[ Testing newtonCbrt(double) ]--------------------")
x = -216.0
print(string.format("x = %g", x))
print(string.format("-exp(log(-x)/3.0) = %g", -math.exp(math.log(-x)/3.0)))
local w = newtonCbrt(x)
print(string.format("w = newtonCbrt(%g) = %g", x, w))
print(string.format("w*w*w = %g", w*w*w))
print()

x = 729000000000.0
print(string.format("x = %g", x))
print(string.format("exp(log(x)/3.0) = %g",  math.exp(math.log(x)/3.0)))
w = newtonCbrt(x)
print(string.format("w = newtonCbrt(%g) = %g", x, w))
print(string.format("w*w*w = %g", w*w*w))
print()

print("[ Testing newtonNthRoot(int, double) ]--------------------")
z = newtonNthRoot(3, x)
print(string.format("x = %g", x))
print(string.format("z = newtonNthRoot(3, %g) = %g", x, z))
print(string.format("z*z*z = %g", z*z*z))
print()

x = 12960000000000000000.0
local z = newtonNthRoot(4, x)
print(string.format("x = %g", x))
print(string.format("z = newtonNthRoot(4, x) = newtonNthRoot(4, %g) =  %g", x, z))
print(string.format("z*z*z*z = %g",  z*z*z*z))
print()

x = 1.0/12960000000000000000.0
z = newtonNthRoot(4, x)
print(string.format("x = %g", x))
print(string.format("exp(log(x)/4.0) = %g", math.exp(math.log(x)/4.0)))
print(string.format("z = newtonNthRoot(4, x) = newtonNthRoot(4, %g) =  %g", x, z))
print(string.format("z*z*z*z = %g",  z*z*z*z))
print()

x = -4.0
print("[ Test Exception heronSqrt(double) ]--------------------")
print(string.format("x = %g", x))
print(string.format("Calculating heronSqrt(%g)", x))
local y  -- = heronSqrt(x)
status, value = pcall(heronSqrt, x)
if status then
    y = value
    print(string.format("y = heronSqrt(%g) = %g", x, y))
    print(string.format("y*y = %g", y*y))
    print()
else
    print(string.format("%s\nCaught some exception in calculating heronSqrt(%g)", value, x))
    print()
end

x = -4.0
print("[ Test Exception in newtonCbrt(double) ]--------------------")
print(string.format("x = %g", x))
print(string.format("Calculating newtonCbrt(%g)", x))
status, value = pcall(newtonCbrt, x)
if status then
    y = value
    print(string.format("y = newtonCbrt(%g) = %g", x, y))
    print(string.format("y*y*y = %g", y*y*y))
    print()
else
    print(string.format("%s\nCaught some exception in calculating newtonCbrtrt(%g)", value, x))
    print()
end

print("[ Test calculations by powering ]-----------------------------")
x = 200.0
z = newtonNthRoot(10, x)
print(string.format("x = %g", x))
print(string.format("exp(log(x)/10.0) = %g", math.exp(math.log(x)/10.0)))
print(string.format("z = newtonNthRoot(10, x) = newtonNthRoot(10, %g) = %g", x, z))
print(string.format("pow(z, 10) = %g", math.pow(z, 10)))
print()

x = 3001.0
z = newtonNthRoot(99, x)
print(string.format("x = %g", x))
print(string.format("exp(log(x)/99.0) = %g", math.exp(math.log(x)/99.0)))
print(string.format("z = newtonNthRoot(99, x) = newtonNthRoot(99, %g) = %g", x, z))
print(string.format("pow(z, 99) = %g", math.pow(z, 99)))
print()

x = 3001.0
z = newtonNthRoot(-99, x)
print(string.format("x = %g", x))
print(string.format("exp(log(x)/-99.0) = %g", math.exp(math.log(x)/-99.0)))
print(string.format("z = newtonNthRoot(-99, x) = newtonNthRoot(-99, %g) = %g", x, z))
print(string.format("1.0/pow(z, 99) = %g", 1.0/math.pow(z, 99)))
print()

print(string.format("pow(2.1, 2.1) = %g", math.pow(2.1, 2.1)))
print(string.format("pow(2.1, -2.1) = %g", math.pow(2.1, -2.1)))
print(string.format("pow(2.1, 2.1) * pow(2.1, -2.1) = %g", math.pow(2.1, 2.1)*math.pow(2.1,  -2.1)))
print(string.format("2.1**2.1 = exp(2.1*log(2.1)) = %g", math.exp(2.1*math.log(2.1))))
print(string.format("2.1**(-2.1) = exp(-2.1*log(2.1)) = %g", math.exp(-2.1*math.log(2.1))))
print(string.format("2.1**2.1 * 2.1**(-2.1) = exp(2.1*log(2.1)) * exp(-2.1*log(2.1)) = %g", math.exp(2.1*math.log(2.1)) * math.exp(-2.1*math.log(2.1))))
print()

k = 301
x = -1.029
t1 = nPow(x, k)
t2 = gPow(x, k)
t3 = mPow(x, k)
print(string.format("math.pow(%g, %d) = %g", x, k,  math.pow(x, k)))   -- pow(x, k)
print(string.format("t1 = nPow(%g, %d) = %g", x, k,  t1))
print(string.format("t2 = gPow(%g, %d) = %g",x, k,  t2))
print(string.format("t3 = mPow(%g, %d) = %g", x, k,  t3))
print(string.format("t1 / t2 = %g", t1 / t2))
print(string.format("t1 - t2 = %g", t1 - t2))
io.write("t1 == t2 ? ")
if t1 == t2 then
    print "yes"
else
   print "no"
end
print(string.format("t1 / t3 = %g", t1 / t3))
print(string.format("t1 - t3 = %g", t1 - t3))
io.write("t1 == t3 ? ")
if t1 == t3 then
    print "yes"
else
   print "no"
end
print(string.format("t2 / t3 = %g", t2 / t3))
print(string.format("t2 - t3 = %g", t2 - t3))
io.write("t2 == t3 ? ")
if t2 == t3 then
    print "yes"
else
   print "no"
end
print()

print "Done."

--[[
# System.out.println("sizeof(double) = " + sizeof(double) );;
# System.out.println("sizeof(int) = " + sizeof(int) );
## print "sizeof(double) = %s = %d" % ("%X" % -1.0, len("%X" % -1.0))
## print "sizeof(int) = %s = %d" % ("%X" % -1, len("%X" % -1))
# print "sizeof(double)*4 = " + String.format("%X", Double.doubleToRawLongBits(-1.0)).length()*4 );;
# print sizeof(int)*4 = " + String.format("%X", -1).length()*4 );
# print sys.getsizeof(int)   # See: http://stackoverflow.com/questions/449560/how-do-i-determine-the-size-of-an-object-in-python
# print sys.getsizeof(-1.0)   # See: http://stackoverflow.com/questions/449560/how-do-i-determine-the-size-of-an-object-in-python
# print sys.getsizeof(-1.0)*4   # See: http://stackoverflow.com/questions/449560/how-do-i-determine-the-size-of-an-object-in-python
# print sys.getsizeof(-1.0)*4   # See: http://stackoverflow.com/questions/449560/how-do-i-determine-the-size-of-an-object-in-python
## print getsizeof(-1.0)*4   # See: http://stackoverflow.com/questions/449560/how-do-i-determine-the-size-of-an-object-in-python
--]]

--[[
Output:
[ Testing heronSqrt(double) ]--------------------
x = 16
u = sqrt(16) = 4
y = heronSqrt(16) = 4
y*y = 16

[ Testing newtonCbrt(double) ]--------------------
x = -216
-exp(log(-x)/3.0) = -6
w = newtonCbrt(-216) = -6
w*w*w = -216

x = 7.29e+011
exp(log(x)/3.0) = 9000
w = newtonCbrt(7.29e+011) = 9000
w*w*w = 7.29e+011

[ Testing newtonNthRoot(int, double) ]--------------------
x = 7.29e+011
z = newtonNthRoot(3, 7.29e+011) = 9000
z*z*z = 7.29e+011

x = 1.296e+019
z = newtonNthRoot(4, x) = newtonNthRoot(4, 1.296e+019) =  60000
z*z*z*z = 1.296e+019

x = 7.71605e-020
exp(log(x)/4.0) = 1.66667e-005
z = newtonNthRoot(4, x) = newtonNthRoot(4, 7.71605e-020) =  1.66667e-005
z*z*z*z = 7.71605e-020

[ Test Exception heronSqrt(double) ]--------------------
x = -4
Calculating heronSqrt(-4)
testNthRoot.lua:228: Cannot find the sqrt of a negative number.
Caught some exception in calculating heronSqrt(-4)

[ Test Exception in newtonCbrt(double) ]--------------------
x = -4
Calculating newtonCbrt(-4)
y = newtonCbrt(-4) = -1.5874
y*y*y = -4

[ Test calculations by powering ]-----------------------------
x = 200
exp(log(x)/10.0) = 1.69865
z = newtonNthRoot(10, x) = newtonNthRoot(10, 200) = 1.69865
pow(z, 10) = 200

x = 3001
exp(log(x)/99.0) = 1.08424
z = newtonNthRoot(99, x) = newtonNthRoot(99, 3001) = 1.08424
pow(z, 99) = 3001

x = 3001
exp(log(x)/-99.0) = 0.922308
z = newtonNthRoot(-99, x) = newtonNthRoot(-99, 3001) = 0.922308
1.0/pow(z, 99) = 3001

pow(2.1, 2.1) = 4.74964
pow(2.1, -2.1) = 0.210542
pow(2.1, 2.1) * pow(2.1, -2.1) = 1
2.1**2.1 = exp(2.1*log(2.1)) = 4.74964
2.1**(-2.1) = exp(-2.1*log(2.1)) = 0.210542
2.1**2.1 * 2.1**(-2.1) = exp(2.1*log(2.1)) * exp(-2.1*log(2.1)) = 1

math.pow(-1.029, 301) = -5457.93
t1 = nPow(-1.029, 301) = -5457.93
t2 = gPow(-1.029, 301) = -5457.93
t3 = mPow(-1.029, 301) = -5457.93
t1 / t2 = 1
t1 - t2 = 6.18456e-011
t1 == t2 ? no
t1 / t3 = 1
t1 - t3 = 6.18456e-011
t1 == t3 ? no
t2 / t3 = 1
t2 - t3 = 0
t2 == t3 ? yes

Done.
--]]