-- Meta class
Shape = {area = 0}

-- Base class method new

function Shape:new (o,side)
   o = o or {}
   setmetatable(o, self)
   self.__index = self
   side = side or 0
   self.area = side*side;
   return o
end

-- Base class method printArea

function Shape:printArea ()
   print("The area is ",self.area)
end

-- Creating an object
myshape = Shape:new(nil,10)
myshape:printArea()

Square = Shape:new()

-- Derived class method new

function Square:new (o,side)
   o = o or Shape:new(o,side)
   setmetatable(o, self)
   self.__index = self
   return o
end

-- Derived class method printArea

function Square:printArea ()
   print("The area of square is ",self.area)
end

-- Creating an object
mysquare = Square:new(nil,10)
mysquare:printArea()

Rectangle = Shape:new()

-- Derived class method new

function Rectangle:new (o,length,breadth)
   o = o or Shape:new(o)
   setmetatable(o, self)
   self.__index = self
   self.area = length * breadth
   return o
end

-- Derived class method printArea

function Rectangle:printArea ()
    print("The area of Rectangle is ",self.area)
end

-- Creating an object

myrectangle = Rectangle:new(nil,10,20)
myrectangle:printArea()

When we run the above program, we will get the following output −

The area is 	100
The area of square is 	100
The area of Rectangle is 	200

In the above example, we have created two derived classes − Rectangle and Square from the base class Square. It is possible to override the functions of the base class in derived class. In this example, the derived class overrides the function printArea.

Lua - Web Programming

Lua is a highly flexible language and it is often used in multiple platforms including web apppcations. The Kepler community that was formed in 2004 to provide open source web components in Lua.

Even though, there are other web frameworks using Lua that have been developed, we will be primarily focusing on the components provided by Kepler community.

Apppcations and Frameworks

Orbit is an MVC web framework for Lua, based on WSAPI.

WSAPI is the API that abstracts the web host server from Lua web apppcations and is the base for many projects.

Xavante is a Lua Web server that offers a WSAPI interface.

Sputnik is a wiki/CMS developed over WSAPI on Kepler Project used for humor and entertainment.

CGILua offers LuaPages and LuaScripts web page creation, based on WSAPI but no longer supported. Use Orbit, Sputnik or WSAPI instead.

In this tutorial, we will try to make you understand what Lua can do and to know more about its installation and usage, refer kepler the website

Orbit

Orbit is an MVC web framework for Lua. It completely abandons the CGILua model of "scripts" in favor of apppcations, where each Orbit apppcation can fit in a single file, but you can sppt it into multiple files if you want.

All Orbit apppcations follow the WSAPI protocol, so they currently work with Xavante, CGI and Fastcgi. It includes a launcher that makes it easy to launch a Xavante instance for development.

The easiest way to install Orbit is using LuaRocks. Luarocks install orbit is the command for instalpng. For this, you need to install LuaRocks first.

If you haven t installed all the dependencies, here are the steps to be followed to setup Orbit in Unix/Linux environment.

Instalpng Apache

Connect to your server. Install Apache2, its support modules and enable required Apache2 modules using −

$ sudo apt-get install apache2 pbapache2-mod-fcgid pbfcgi-dev build-essential
$ sudo a2enmod rewrite
$ sudo a2enmod fcgid
$ sudo /etc/init.d/apache2 force-reload

Install LuaRocks

$ sudo apt-get install luarocks

Install WSAPI, FCGI, Orbit, and Xavante

$ sudo luarocks install orbit
$ sudo luarocks install wsapi-xavante
$ sudo luarocks install wsapi-fcgi

Setting up Apache2

$ sudo raj /etc/apache2/sites-available/default

Add this following section below the <Directory /var/www/> section of the config file. If this section has an AllowOverride None then you need to change the None to All so that the .htaccess file can override the configuration locally.

<IfModule mod_fcgid.c>

   AddHandler fcgid-script .lua
   AddHandler fcgid-script .ws
   AddHandler fcgid-script .op
	
   FCGIWrapper "/usr/local/bin/wsapi.fcgi" .ws
   FCGIWrapper "/usr/local/bin/wsapi.fcgi" .lua
   FCGIWrapper "/usr/local/bin/op.fcgi" .op
	
   #FCGIServer "/usr/local/bin/wsapi.fcgi" -idle-timeout 60 -processes 1
   #IdleTimeout 60
   #ProcessLifeTime 60
	
</IfModule>

Restart the server to ensure the changes made comes into effect.

To enable your apppcation, you need to add +ExecCGI to an .htaccess file in the root of your Orbit apppcation − in this case, /var/www.

Options +ExecCGI
DirectoryIndex index.ws

Simple Example − Orbit

#!/usr/bin/env index.lua

-- index.lua
require"orbit"

-- declaration
module("myorbit", package.seeall, orbit.new)

-- handler

function index(web)
   return my_home_page()
end

-- dispatch
myorbit:dispatch_get(index, "/", "/index")

-- Sample page

function my_home_page()

   return [[
      <head></head>
      <html>
         <h2>First Page</h2>
      </html>
   ]]
	
end

Now, you should be able to launch your web browser. Go to http://localhost:8080/ and you should see the following output −

First Page

Orbit provides another option, i.e., Lua code can generate html.

#!/usr/bin/env index.lua

-- index.lua
require"orbit"

function generate()
   return html {
      head{title "HTML Example"},
		
      body{
         h2{"Here we go again!"}
      }
   }
end

orbit.htmpfy(generate)

print(generate())

Creating Forms

A simple form example is shown below −

#!/usr/bin/env index.lua
require"orbit"

function wrap (inner)
   return html{ head(), body(inner) }
end

function test ()
   return wrap(form (H table  {
      tr{td"First name",td( input{type =  text , name= first })},
      tr{td"Second name",td(input{type =  text , name= second })},
      tr{ td(input{type =  submit , value =  Submit! }),
         td(input{type =  submit ,value =  Cancel })
      },
   }))
end

orbit.htmpfy(wrap,test)

print(test())

WSAPI

As mentioned earper, WSAPI acts as the base for many projects and have multiple features embedded in it. You can use WSAPI and support the following platforms,

Windows

UNIX-based systems

The supported servers and interfaces by WSAPI includes,

CGI

FastCGI

Xavante

WSAPI provides a number of pbraries, which makes it easier for us in web programming using Lua. Some of the supported features in Lua includes,

Request processing

Output buffering

Authentication

File uploads

Request isolation

Multiplexing

A simple example of WSAPI is shown below −

#!/usr/bin/env wsapi.cgi

module(..., package.seeall)
function run(wsapi_env)
   local headers = { ["Content-type"] = "text/html" }
   
   local function hello_text()
      coroutine.yield("<html><body&gt")
      coroutine.yield("<p&gtHello Wsapi!</p&gt")
      coroutine.yield("<p&gtPATH_INFO: " .. wsapi_env.PATH_INFO .. "</p&gt")
      coroutine.yield("<p&gtSCRIPT_NAME: " .. wsapi_env.SCRIPT_NAME .. "</p&gt")
      coroutine.yield("</body&gt</html&gt")
   end

   return 200, headers, coroutine.wrap(hello_text)
end

You can see in the above code a simple html page is formed and returned. You can see the usage of coroutines that makes it possible to return statement by statement to calpng function. Finally, html status code(200), headers and html page is returned.

Xavante

Xavante is a Lua HTTP 1.1 Web server that uses a modular architecture based on URI mapped handlers. Xavante currently offers,

File handler

Redirect handler

WSAPI handler

File handler is used for general files. Redirect handler enables URI remapping and WSAPI handler for handing with WSAPI apppcations.

A simple example is shown below.

require "xavante.filehandler"
require "xavante.cgiluahandler"
require "xavante.redirecthandler"

-- Define here where Xavante HTTP documents scripts are located
local webDir = XAVANTE_WEB

local simplerules = {

   { -- URI remapping example
      match = "^[^%./]*/$",
      with = xavante.redirecthandler,
      params = {"index.lp"}
   }, 

   { -- cgiluahandler example
      match = {"%.lp$", "%.lp/.*$", "%.lua$", "%.lua/.*$" },
      with = xavante.cgiluahandler.makeHandler (webDir)
   },
    
   { -- filehandler example
      match = ".",
      with = xavante.filehandler,
      params = {baseDir = webDir}
   },
} 

xavante.HTTP{
   server = {host = "*", port = 8080},
    
   defaultHost = {
      rules = simplerules
   },
}

To use virtual hosts with Xavante, the call to xavante.HTTP would be changed to something pke as follows −

xavante.HTTP{
   server = {host = "*", port = 8080},
    
   defaultHost = {},
    
   virtualhosts = {
      ["www.sitename.com"] = simplerules
   }
}

Lua Web Components

Copas, a dispatcher based on coroutines that can be used by TCP/IP servers.

Cosmo, a "safe templates" engine that protects your apppcation from arbitrary code in the templates.

Coxpcall encapsulates Lua native pcall and xpcall with coroutine compatible ones.

LuaFileSystem, a portable way to access the underlying directory structure and file attributes.

Rings, a pbrary which provides a way to create new Lua states from within Lua.

Ending Note

There are so many Lua based web frameworks and components available for us and based on the need, it can be chosen. There are other web frameworks available which include the following −

Moonstalk enables efficient development and hosting of dynamically generated web-based projects built with the Lua language; from basic pages to complex apppcations.

Lapis, a framework for building web apppcations using MoonScript (or Lua) that runs inside of a customized version of Nginx called OpenResty.

Lua Server Pages, a Lua scripting engine plug-in that blows away any other approach to embedded web development, offers a dramatic short cut to traditional C server pages.

These web frameworks can leverage your web apppcations and help you in doing powerful operations.

Lua - Database Access

For simple data operations, we may use files, but, sometimes, these file operations may not be efficient, scalable, and powerful. For this purpose, we may often switch to using databases. LuaSQL is a simple interface from Lua to a number of database management systems. LuaSQL is the pbrary, which provides support for different types of SQL. This include,

SQLite

Mysql

ODBC

In this tutorial, we will be covering database handpng of MySQL an SQLite in Lua. This uses a generic interface for both and should be possible to port this implementation to other types of databases as well. First let see how you can do the operations in MySQL.

MySQL db Setup

In order to use the following examples to work as expected, we need the initial db setup. The assumptions are psted below.

You have installed and setup MySQL with default user as root and password as 123456 .

You have created a database test.

You have gone through MySQL tutorial to understand MySQL Basics.

Importing MySQL

We can use a simple require statement to import the sqpte pbrary assuming that your Lua implementation was done correctly.

mysql = require "luasql.mysql"

The variable mysql will provide access to the functions by referring to the main mysql table.

Setting up Connection

We can set up the connection by initiating a MySQL environment and then creating a connection for the environment. It is shown below.

local env  = mysql.mysql()
local conn = env:connect( test , root , 123456 )

The above connection will connect to an existing MySQL file and estabpshes the connection with the newly created file.

Execute Function

There is a simple execute function available with the connection that will help us to do all the db operations from create, insert, delete, update and so on. The syntax is shown below −

conn:execute([[  MySQLSTATEMENT  ]])

In the above syntax, we need to ensure that conn is open and existing MySQL connection and replace the MySQLSTATEMENT with the correct statement.

Create Table Example

A simple create table example is shown below. It creates a table with two parameters id of type integer and name of type varchar.

mysql = require "luasql.mysql"

local env  = mysql.mysql()
local conn = env:connect( test , root , 123456 )

print(env,conn)

status,errorString = conn:execute([[CREATE TABLE sample2 (id INTEGER, name TEXT);]])
print(status,errorString )

When you run the above program, a table named sample will be created with two columns namely, id and name.

MySQL environment (004BB178)	MySQL connection (004BE3C8)
0	nil

In case there is any error, you would be returned an error statement instead of nil. A simple error statement is shown below.

LuaSQL: Error executing query. MySQL: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near  "id INTEGER, name TEXT)  at pne 1

Insert Statement Example

An insert statement for MySQL is shown below.

conn:execute([[INSERT INTO sample values( 11 , Raj )]])

Update Statement Example

An update statement for MySQL is shown below.

conn:execute([[UPDATE sample3 SET name= John  where id = 12 ]])

Delete Statement Example

A delete statement for MySQL is shown below.

conn:execute([[DELETE from sample3 where id = 12 ]])

Select Statement Example

As far as select statement is concerned, we need to loop through each of the rows and extract the required data. A simple select statement is shown below.

cursor,errorString = conn:execute([[select * from sample]])
row = cursor:fetch ({}, "a")

while row do
   print(string.format("Id: %s, Name: %s", row.id, row.name))
   -- reusing the table of results
   row = cursor:fetch (row, "a")
end

In the above code, conn is an open MySQL connection. With the help of the cursor returned by the execute statement, you can loop through the table response and fetch the required select data.

A Complete Example

A complete example including all the above statements is given below.

mysql = require "luasql.mysql"

local env  = mysql.mysql()
local conn = env:connect( test , root , 123456 )
print(env,conn)

status,errorString = conn:execute([[CREATE TABLE sample3 (id INTEGER, name TEXT)]])
print(status,errorString )

status,errorString = conn:execute([[INSERT INTO sample3 values( 12 , Raj )]])
print(status,errorString )

cursor,errorString = conn:execute([[select * from sample3]])
print(cursor,errorString)

row = cursor:fetch ({}, "a")

while row do
   print(string.format("Id: %s, Name: %s", row.id, row.name))
   row = cursor:fetch (row, "a")
end

-- close everything
cursor:close()
conn:close()
env:close()

When you run the above program, you will get the following output.

MySQL environment (0037B178)	MySQL connection (0037EBA8)
0	nil
1	nil
MySQL cursor (003778A8)	nil
Id: 12, Name: Raj

Performing Transactions

Transactions are a mechanism that ensures data consistency. Transactions should have the following four properties −

Atomicity − Either a transaction completes or nothing happens at all.

Consistency − A transaction must start in a consistent state and leave the system in a consistent state.

Isolation − Intermediate results of a transaction are not visible outside the current transaction.

Durabipty − Once a transaction was committed, the effects are persistent, even after a system failure.

Transaction starts with START TRANSACTION; and ends with commit or rollback statement.

Start Transaction

In order to initiate a transaction, we need to execute the following statement in Lua, assuming conn is an open MySQL connection.

conn:execute([[START TRANSACTION;]])

Rollback Transaction

We need to execute the following statement to rollback changes made after start transaction is executed.

conn:execute([[ROLLBACK;]])

Commit Transaction

We need to execute the following statement to commit changes made after start transaction is executed.

conn:execute([[COMMIT;]])

We have known about MySQL in the above and following section explains about basic SQL operations. Remember transactions, though not explained again for SQLite3 but the same statements should work for SQLite3 as well.

Importing SQLite

We can use a simple require statement to import the SQLite pbrary assuming that your Lua implementation was done correctly. During installation, a folder pbsql that contains the database related files.

sqpte3 = require "luasql.sqpte3"

The variable sqpte3 will provide access to the functions by referring to the main sqpte3 table.

Setting Up Connection

We can set up the connection by initiating an SQLite environment and then creating a connection for the environment. It is shown below.

local env  = sqpte3.sqpte3()
local conn = env:connect( mydb.sqpte )

The above connection will connect to an existing SQLite file or creates a new SQLite file and estabpshes the connection with the newly created file.

Execute Function

There is a simple execute function available with the connection that will help us to do all the db operations from create, insert, delete, update and so on. The syntax is shown below −

conn:execute([[  SQLite3STATEMENT  ]])

In the above syntax we need to ensure that conn is open and existing sqpte3 connection and replace the SQLite3STATEMENT with the correct statement.

Create Table Example

A simple create table example is shown below. It creates a table with two parameters id of type integer and name of type varchar.

sqpte3 = require "luasql.sqpte3"

local env  = sqpte3.sqpte3()
local conn = env:connect( mydb.sqpte )
print(env,conn)

status,errorString = conn:execute([[CREATE TABLE sample ( id  INTEGER,  name  TEXT)]])
print(status,errorString )

When you run the above program, a table named sample will be created with two columns namely, id and name.

SQLite3 environment (003EC918)	SQLite3 connection (00421F08)
0	nil

In case of an error, you would be returned a error statement instead of nil. A simple error statement is shown below.

LuaSQL: unrecognized token: "" id  INTEGER,  name  TEXT)"

Insert Statement Example

An insert statement for SQLite is shown below.

 conn:execute([[INSERT INTO sample values( 11 , Raj )]])

Select Statement Example

As far as select statement is concerned, we need to loop through each of the rows and extract the required data. A simple select statement is shown below.

cursor,errorString = conn:execute([[select * from sample]])
row = cursor:fetch ({}, "a")

while row do
   print(string.format("Id: %s, Name: %s", row.id, row.name))
   -- reusing the table of results
   row = cursor:fetch (row, "a")
end

In the above code, conn is an open sqpte3 connection. With the help of the cursor returned by the execute statement, you can loop through the table response and fetch the required select data.

A Complete Example

A complete example including all the above statements is given below.

sqpte3 = require "luasql.sqpte3"

local env  = sqpte3.sqpte3()
local conn = env:connect( mydb.sqpte )
print(env,conn)

status,errorString = conn:execute([[CREATE TABLE sample ( id  INTEGER,  name  TEXT)]])
print(status,errorString )

status,errorString = conn:execute([[INSERT INTO sample values( 1 , Raj )]])
print(status,errorString )

cursor,errorString = conn:execute([[select * from sample]])
print(cursor,errorString)

row = cursor:fetch ({}, "a")

while row do
   print(string.format("Id: %s, Name: %s", row.id, row.name))
   row = cursor:fetch (row, "a")
end

-- close everything
cursor:close()
conn:close()
env:close()

When you run the above program, you will get the following output.

SQLite3 environment (005EC918)	SQLite3 connection (005E77B0)
0	nil
1	nil
SQLite3 cursor (005E9200)	nil
Id: 1, Name: Raj

We can execute all the available queries with the help of this pbsql pbrary. So, please don t stop with these examples. Experiment various query statement available in respective MySQL, SQLite3 and other supported db in Lua.

Lua - Game Programing

Lua is used in a lot of game engines due to its simple language structure and syntax. The garbage collection feature is often quite useful in games which consume a lot of memory due to rich graphics that is used. Some game engines that use Lua includes −

Corona SDK

Gideros Mobile

ShiVa3D

Moai SDK

LOVE

CryEngine

Each of these game engines are based on Lua and there is a rich set of API available in each of these engines. We will look at the capabipties of each in brief.

Corona SDK

Corona SDK is a cross platform mobile game engine that supports iPhone, iPad, and Android platforms. There is a free version of Corona SDK that can be used for small games with pmited features. You can upgrade to other versions when needed.

Corona SDK provides a number of features which includes the following −

Physics and Colpsion handpng APIs

Web and Network APIs

Game Network API

Ads API

Analytics API

Database and File System APIs

Crypto and Math APIs

Audio and Media APIs

It is easier and faster to develop an apppcation using the above APIs rather than using the native APIs separately for iOS and Android.

Gideros Mobile

Gideros provides the cross-platform SDK to create games for iOS and Android. It is free to use with a made with Gideros splash. Some of the striking advantages in Gideoros includes, the following −

Development IDE − It provides its own IDE which makes it easier to develop Gideros apps.

Instant testing − While developing your game, it can be tested on a real device through Wifi in only 1 second. You don t need to waste your time with an export or deploy process.

Plugins − You can easily extend the core with plugins. Import your existing (C, C++, Java or Obj-C) code, bind to Lua and interpret them directly. Dozens of open-source plugins are already developed and ready to use.

Clean OOP approach − Gideros provides its own class system with all the basic OOP standards, enabpng you to write clean and reusable code for any of your future games.

Native speed − Developed on top of C/C++ and OpenGL, your game runs at native speed and fully utipzes the power of CPUs and GPUs underneath.

ShiVa3D

ShiVa3D is one of 3D game engines which provides a graphical editor designed to create apppcations and video games for the Web, Consoles and Mobile devices. It supports multiple platforms which includes, Windows, Mac, Linux, iOS, Android, BlackBerry, Palm OS, Wii and WebOS.

Some of the major features include

Standard plugins

Mesh modification API

IDE

Built-in Terrain, Ocean and animation editor

ODE physics engine support

Full pghtmap control

Live preview for materials, particles, trails and HUDs

Collada exchange format support

The web edition of Shiva3d is completely free and other editions you have subscribe.

Moai SDK

Moai SDK is a cross platform mobile game engine that supports iPhone, iPad, and Android platforms. Moai platform initially consisted of Moai SDK, an open source game engine, and Moai Cloud, a cloud platform as a service for the hosting and deployment of game services. Now the Moai Cloud is shutdown and only the game engine is available.

Moai SDK runs on multiple platforms including iOS, Android, Chrome, Windows, Mac and Linux.

LOVE

LOVE is a framework that you can use to make 2D games. It is free and open-source. It supports Windows, Mac OS X and Linux platforms.

It provides multiple features which include,

Audio API

File System API

Keyboard and Joystick APIs

Math API

Window and Mouse APIs

Physics API

System and timer APIs

CryEngine

CryEngine is a game engine developed by the German game developer Crytek. It has evolved from generation 1 to generation 4 and is an advanced development solution. It supports PC, Xbox 360, PlayStation3 and WiiU games.

It provides multiple features which include,

Visual effects pke Natural Lighting & Dynamic Soft Shadows, Real-time Dynamic Global Illumination, Light Propagation Volume, Particle Shading, Tessellation and so on.

Character Animation System and Character Inspaniduapzation System.

Parametric Skeletal Animation and Unique Dedicated Facial Animation Editor

AI Systems pke Multi-Layer Navigation Mesh and Tactical Point System. Also provides Designer-Friendly AI Editing System.

In Game Mixing & Profipng, Data-driven Sound System Dynamic Sounds & Interactive Music and so on.

Physics features pke Procedural Deformation and Advanced Rope Physics.

An Ending Note

Each of these Game SDKs/frameworks have their own advantages and disadvantages. A proper choice between them makes your task easier and you can have a better time with it. So, before using it, you need to know the requirements for your game and then analyze which satisfies all your needs and then should use them.

Lua - Standard Libraries

Lua standard pbraries provide a rich set of functions that is implemented directly with the C API and is in-built with Lua programming language. These pbraries provide services within the Lua programming language and also outside services pke file and db operations.

These standard pbraries built in official C API are provided as separate C modules. It includes the following −

Basic pbrary, which includes the coroutine sub-pbrary

Modules pbrary

String manipulation

Table manipulation

Math pbrary

File Input and output

Operating system facipties

Debug facipties

Basic Library

We have used the basic pbrary throughout the tutorial under various topics. The following table provides pnks of related pages and psts the functions that are covered in various part of this Lua tutorial.

Modules Library

The modules pbrary provides the basic functions for loading modules in Lua. It exports one function directly in the global environment: require. Everything else is exported in a table package. The details about the modules pbrary is explained in the earper chapter Lua - Modules tutorial.

String manipulation

Lua provides a rich set of string manipulation functions. The earper Lua - Strings tutorial covers this in detail.

Table manipulation

Lua depends on tables in almost every bit of its operations. The earper Lua - Tables tutorial covers this in detail.

File Input and output

We often need data storage facipty in programming and this is provided by standard pbrary functions for file I/O in Lua. It is discussed in earper Lua - File I/O tutorial.

Debug facipties

Lua provides a debug pbrary which provides all the primitive functions for us to create our own debugger. It is discussed in earper Lua - Debugging tutorial.

Lua - Math pbrary

We often need math operations in scientific and engineering calculations and we can avail this using the standard Lua pbrary math. The pst of functions available in math pbrary is shown in the following table.

Trigonometric functions

A simple example using trigonometric function is shown below.

radianVal = math.rad(math.pi / 2)

io.write(radianVal,"
")

-- Sin value of 90(math.pi / 2) degrees
io.write(string.format("%.1f ", math.sin(radianVal)),"
")

-- Cos value of 90(math.pi / 2) degrees
io.write(string.format("%.1f ", math.cos(radianVal)),"
")

-- Tan value of 90(math.pi / 2) degrees
io.write(string.format("%.1f ", math.tan(radianVal)),"
")

-- Cosh value of 90(math.pi / 2) degrees
io.write(string.format("%.1f ", math.cosh(radianVal)),"
")

-- Pi Value in degrees
io.write(math.deg(math.pi),"
")

0.027415567780804
0.0 
1.0 
0.0 
1.0 
180

-- Floor
io.write("Floor of 10.5055 is ", math.floor(10.5055),"
")

-- Ceil
io.write("Ceil of 10.5055 is ", math.ceil(10.5055),"
")

-- Square root
io.write("Square root of 16 is ",math.sqrt(16),"
")

-- Power
io.write("10 power 2 is ",math.pow(10,2),"
")
io.write("100 power 0.5 is ",math.pow(100,0.5),"
")

-- Absolute
io.write("Absolute value of -10 is ",math.abs(-10),"
")

--Random
math.randomseed(os.time())
io.write("Random number between 1 and 100 is ",math.random(),"
")

--Random between 1 to 100
io.write("Random number between 1 and 100 is ",math.random(1,100),"
")

--Max
io.write("Maximum in the input array is ",math.max(1,100,101,99,999),"
")

--Min
io.write("Minimum in the input array is ",math.min(1,100,101,99,999),"
")

Floor of 10.5055 is 10
Ceil of 10.5055 is 11
Square root of 16 is 4
10 power 2 is 100
100 power 0.5 is 10
Absolute value of -10 is 10
Random number between 1 and 100 is 0.22876674703207
Random number between 1 and 100 is 7
Maximum in the input array is 999
Minimum in the input array is 1

-- Date with format
io.write("The date is ", os.date("%m/%d/%Y"),"
")

-- Date and time
io.write("The date and time is ", os.date(),"
")

-- Time
io.write("The OS time is ", os.time(),"
")

-- Wait for some time
for i=1,1000000 do
end

-- Time since Lua started
io.write("Lua started before ", os.clock(),"
")

The date is 01/25/2014
The date and time is 01/25/14 07:38:40
The OS time is 1390615720
Lua started before 0.013