Lua Esta Si Es para Hacer Los Zom

w
Optimizacin de Uso de i
variables locales k
i
Buscar
Visin de conjunto
Las variables locales son muy rpidos, ya que se accede a ellos por el ndice.
"Las variables locales son muy rpidos ya que residen en los registros de la
mquina virtual, y se puede acceder directamente por el ndice. Las variables
globales, por otra parte, residen en una tabla lua y como tal se accede por una
bsqueda de hash". -- Thomas Jefferson
Haciendo variables globales locales
Las variables locales son muy rpidos, ya que se accede a ellos por el ndice. Si
es posible, hacer que las variables globales local (raro, eh?). En serio, funciona
muy bien y el acceso indexado siempre va a ser ms rpido que una bsqueda de
hash. Si una variable, por ejemplo GameState, las necesidades de alcance mundial
para acceso de C, hacer una variable secundaria que se parece a ' local GSLocal
= GameState' y use GSLocaldentro del mdulo. Esta tcnica tambin se puede
utilizar para funciones que son llamadas de forma repetitiva, tambin. p.ej.
x = {a = 1, b = 2}
la funcin foo ()
locales y = x
impresin (xa)
impresin (YB) - ms rpido que la letra anterior puesto que y es
una tabla local
fin
Tenga en cuenta, esto tambin trabajar con funciones globales (incluyendo
funciones de la librera estndar), por ejemplo.
(Steve DeKorte) Yo slo llegu a jugar con esto y funciona muy bien. Por
ejemplo, este cdigo:
i locales, v = siguiente (t, nil)
mientras que lo que hago lo, v = siguiente (t, i) final
Es 10% ms rpido si haces nextun local de:
= local al lado prximo
i locales, v = siguiente (t, nil)
mientras que lo que hago lo, v = siguiente (t, i) final
Tambin hice algunas otras pruebas y se encontr que foreach () es ~ 20% ms
rpido que el equivalente bucle while, mientras foreachi () fue ~ 20% ms lento
que un bucle while.
para i, v en t do final - aproximadamente 5 veces ms rpido que un
tiempo
Tenga en cuenta que lo que Steve est midiendo en sus pruebas de una
sobrecarga de bucle (el cuerpo del bucle est vaca). En realidad hay algunas
declaraciones provistas en el cuerpo as que la prdida no es tan significativa. -
Juan Belmonte
Ver tambin: OptimisationTips
RecentChanges preferencias
de edicin historia
ltima edicin 28 de de octubre de, el ao 2015 21:24 GMT (dif)
w
Optimising Using Local i
Variables k
i
Search
Overview
Local variables are very quick, since they are accessed by index.
"Local variables are very fast as they reside in virtual machine registers, and are
accessed directly by index. Global variables on the other hand, reside in a lua
table and as such are accessed by a hash lookup." -- Thomas Jefferson
Making global variables local
Local variables are very quick, since they are accessed by index. If possible,
make global variables local (weird, eh?). Seriously, it works great and indexed
access is always going to be faster than a hash lookup. If a variable,
say GameState, needs global scope for access from C, make a secondary variable
that looks like 'local GSLocal = GameState' and use GSLocal within the module.
This technique can also be used for functions that are called repetitively, too. eg.
x = { a=1,b=2 }
function foo()
local y=x
print( x.a )
print( y.b ) -- faster than the print above since y is a local
table
end
Note, this will also work with global functions (including standard library
functions), eg.
(Steve Dekorte) I just got around to playing with this and it works great. For
example this code:
local i, v = next(t, nil)
while i do i, v = next(t, i) end
Is 10% faster if you make next a local:
local next = next
local i, v = next(t, nil)
while i do i, v = next(t, i) end
I also did some other tests and found that foreach() is ~20% faster than the
equivalent while loop, while foreachi() was ~20% slower than a while loop.
for i, v in t do end -- about 5x as fast as a while
Keep in mind that what Steve is measuring in his tests is loop overhead (the loop
body is empty). In reality there are some statments in the body so the overhead is
not so significant. -- John Belmonte
See also: OptimisationTips
RecentChanges preferences
edit history
Last edited October 28, 2015 9:24 pm GMT (diff)
Introduction
Garbage collection of your system can cause performance problems if a large
number of objects have been generated. This page discusses the issues involved
and ideas for avoiding the problem.
Minimising objects created

Question: Basically I want to minimise the amount of temporary memory being
allocated, so that I can reduce the frequency GC is called (and maybe reduce the
hit of each GC?). Can anyone give some hints on this topic? For instance, if I
have local variables declared inside function A, will the local variables allocate
memory each time A is called?
(ET) No. Local variables are kept on a stack and will not affect the GC. These
constructs will create a new garbage collected object:
a..b (example only; any string generating construct i.e. strsub() [*1]
or lua_pushstring().)
Each new string creates a new object. Lua has unique strings, that means
that each possible string exists only once within Lua. If a new string
occurs Lua first checks if it already exists within the string pool. If it does,
a reference to that older string is used. If it does not exist, a new string
object is created and put into the string pool. The GC checks the string
pool for unused strings and frees them. So creating a lot of unique strings
will trash the GC. I.e. this is bad GC-wise:
for i=1,100 do x="foo"..tostring(i) end -- 100 new strings
Note: Code segments hold references to strings constants (a la "foo"
above). So the string will exist in the string pool as long as the function
exists; it does not have to be created each time the function is executed.
{ ... }
Each time a table constructor is executed a new table is created. Try to
reuse tables if possible. You could even go as far as creating and using
newtable/freetable functions that manage a pool of unused tables. That
way you get old style memory management for tables but you'll also get
the old problems too ;-)
function() ... end
Executing a function statement creates a closure (note: not calling the

function but executing the function statement!). Normally no big impact
on the GC but if you have function statements within a loop you may
create a lot of garbage. I.e.:
for i=1,100 do foo(function() end) end -- bad for GC
creates 100 function closures.
function(foo, ...) end
Vararg functions create a table for the ellipsis (stored in ' arg') each time the
function is called. (Note: No longer true as of Lua 5.2, or if using LuaJIT.)
userdata objects
In Lua 4.0 (and 3.x) userdata objects are handled similar to strings. They
are equal if the pointer value and the tag are equal. What about Lua5?
dofile/dostring
Well, these load/compile new code and will create strings and (GCed)
code segments.
Freeing local variables

Question (continuation of above): So any local string or table will be freed when
you exit a function?
Variables are a place to store objects (In fact, except for numbers it only holds
pointers to the objects). Whether the stored object is a number or a table or
anything else doesn't bother the variable. And local variables are not garbage
collected objects themselves. So you may use them without creating intermediate
objects. I think, that was what the original poster meant.
"So you may use them without creating intermediate objects." Does this
need clarification? The variable itself doesnt create a GC object but its
value could. You can use local variables which reference other existing
objects without creating objects that need to be collected. But, you can't
create new objects which are locals without creating an object that needs
to be collected later.
About the objects stored within local variables: at the moment the local variable
is no longer active the GC may collect the object that was stored there. The actual
freeing of the object has nothing to do with function scopes or variable live
times. The GC runs at certain times and frees all objects that are no longer
accessible by any L
[*1] strsub exists in Lua 4, not Lua 5.
RecentChanges preferences
edit history
Last edited April 18, 2014 6:12 pm GMT (diff)
Introduccin
La recoleccin de basura de su sistema puede causar problemas de rendimiento si
se han generado un gran nmero de objetos. Esta pgina discute las cuestiones
planteadas y las ideas para evitar el problema.
Minimizar los objetos creados

Pregunta: Quiero bsicamente para reducir al mnimo la cantidad de memoria
temporal que se asigna, de modo que pueda reducir la frecuencia de GC se llama
(y tal vez reducir el impacto de cada GC?). Puede alguien dar algunos consejos
sobre este tema? Por ejemplo, si he variables locales declaradas dentro de la
funcin A, sern las variables locales asignar memoria cada vez que una se
llama?
(ET) Las variables locales No. se mantienen en una pila y no afectarn a la

GC. Estas construcciones se cree un objeto nuevo recolector de basura:
a..b(slo ejemplo, cualquier cadena de generacin de la construccin, es

decir strsub()[* 1] o lua_pushstring().)
Cada nueva cadena crea un nuevo objeto. Lua tiene cadenas nicas, lo que
significa que existe cada cadena posible slo una vez dentro de Lua. Si se
produce una nueva cadena Lua primero comprueba si ya existe dentro del
grupo de cadena. Si lo hace, se utiliza una referencia a esa cadena
mayor. Si no existe, se crea un nuevo objeto de cadena y poner en el grupo
de cadena. El GC comprueba el grupo de cadena para cadenas no
utilizados y los libera. Por lo tanto la creacin de una gran cantidad de
cadenas nicas se trash la GC. Es decir, esto es malo GC-sabia:
para i = 1,100 hacer x = "foo" .. toString (i) end - 100 nuevas
cadenas
Nota: Los segmentos de cdigo mantienen constantes referencias a
cadenas (al estilo de "foo" ms arriba). Lo que la cadena va a existir en el
grupo de cadena mientras exista la funcin; s no tiene que ser creado cada
vez que se ejecute la funcin.
{ ... }
Cada vez que un constructor se ejecuta mesa se crea una nueva

tabla. Intente volver a utilizar tablas si es posible. Incluso se puede ir tan
lejos como la creacin y el uso de funciones newtable / freetable que
gestionan un conjunto de tablas no utilizadas. De esta manera se obtiene la
gestin de memoria del viejo estilo para las tablas, pero tambin obtendr
los viejos problemas tambin ;-)
function() ... end
La ejecucin de una sentencia de funcin crea un cierre (nota: no llamar a

la funcin, pero la ejecucin de la sentencia de funcin). Normalmente no
es gran impacto en la GC, pero si usted tiene las sentencias de funcin
dentro de un bucle puede crear un montn de basura. Es decir:
para i = 1,100 hacer foo (function () final) final - malo para GC
crea 100 cierres de funcin.
function(foo, ...) end
Funciones vararg crear una mesa para los puntos suspensivos (almacenado
en ' arg') cada vez que la funcin se llama . (Nota: Ya no son ciertas en
Lua 5.2, o si est usando LuaJIT.)
objetos userdata
En Lua 4.0 (3.x) objetos userdata se manejan similares a cuerdas. Ellos
son iguales si el valor del puntero y la etiqueta son iguales. Qu hay de
Lua5?
dofile/dostring
Bueno, estos carga / compilar cdigo nuevo y crear cadenas y segmentos

de cdigo (GCed).
La liberacin de las variables locales

Pregunta (continuacin de la anterior): As que cualquier cadena local o mesa
sern liberados al salir de una funcin?
Las variables son un lugar para guardar objetos (De hecho, a excepcin de los
nmeros que slo se mantiene punteros a los objetos). Si el objeto almacenado es
un nmero o una mesa o cualquier otra cosa no molesta a la variable. Y las
variables locales no son basura y posteriormente objetos mismos. Por lo que
puede utilizarlos sin crear objetos intermedios. Creo, eso era lo que quera decir
el cartel original.
"Por lo que puede usarlos sin crear objetos intermedios." Esto necesita
una aclaracin? La variable si misma no crear un objeto de GC pero su
valor poda. Puede utilizar variables locales que hacen referencia a otros
objetos existentes sin crear objetos que necesitan ser recogidos. Sin
embargo, no se puede crear nuevos objetos que son locales sin crear un
objeto que necesita ser recogido ms tarde.
Acerca de los objetos que contiene las variables locales: en el momento en que la
variable local ya no est activa la GC puede recoger el objeto que se almacena
all. La liberacin real del objeto no tiene nada que ver con los mbitos de
funcin o tiempos en vivo variables. El GC se ejecuta en ciertos momentos y
libera todos los objetos que ya no estn a disposicin de cualquier L
[* 1] strsubexiste en Lua 4, 5 no Lua.
RecentChanges preferencias
de edicin historia
ltima edicin 18 de de abril de, 2014 18:12 GMT (dif)
w
Vararg The Second Class i
Citizen k
i
Search
Lua varargs "..." [1] are not [first class] objects in Lua 5.1, and this leads to
some limitations in expression. Some of these issues and their workarounds are
given here.
Issue #1: Vararg Saving
Issue #2: Combining Lists
Issue #3: Selecting the First N Elements in List
Issue #4: Appending One Element to a List
Issue #5: Reversing a List
Issue #6: The map Function
Issue #7: The filter Function
Issue #8: Iterating over Varargs
Issue #1: Vararg Saving

Lua 5.1 vararg (...) handling is a bit limited. For example, it doesn't permit
things like this:
function tuple(...) return function() return ... end end
--Gives error "cannot use '...' outside a vararg function near '...'"
(Some comments on that are in LuaList:2007-03/msg00249.html .)
You might want to use such a function to temporarily store away the return
values of a function call, do some other work, and then retrieve those stored
return values again. The following function would use this
hypothetical tuple function to add trace statements around a given function:
--Wraps a function with trace statements.
function trace(f)
return function(...)
print("begin", f)
local result = tuple(f(...))
print("end", f)
return result()
end
end
test = trace(function(x,y,z) print("calc", x,y,z); return x+y, z end)

print("returns:", test(2,3,nil))
-- Desired Output:
-- begin function: 0x687350
-- calc 2 3 nil
-- end function: 0x687350
-- returns: 5 nil
Still, there are ways to achieve this in Lua.
Solution: {...} and unpack
You could instead implement trace with the table construct {...} and unpack:
function trace(f)
print("begin", f)
local result = {f(...)}
print("end", f)
return unpack(result)
end
end

-- Output:
-- begin function: 0x6869d0
-- calc 2 3 nil
-- end function: 0x6869d0
-- returns: 5
Unfortunately, it misses a nil return value since nil are not explicitly storable in
tables , and particularly {...} does not preserve information about trailing nils
(this is further discussed in StoringNilsInTables).
Solution: {...} and unpack with n
The following improvement on the previous solution properly handles nils:

function pack2(...) return {n=select('#', ...), ...} end
function unpack2(t) return unpack(t, 1, t.n) end

function trace(f)
print("begin", f)
local result = pack2(f(...))
print("end", f)
return unpack2(result);
end
end

-- Output:
-- begin function: 0x6869d0
-- calc 2 3 nil
-- end function: 0x6869d0
-- returns: 5 nil
A variant noted by Shirik is

local function tuple(...)
local n = select('#', ...)
local t = {...}
return function() return unpack(t, 1, n) end
end
Solution: nil Placeholders
The following approach swaps the nil's with placeholders that can be stored in
tables. It's probably less optimal here, but the approach might be usable
elsewhere.
local NIL = {} -- placeholder value for nil, storable in table.
function pack2(...)
local t = {}
for i = 1,n do
local v = select(i, ...)
t[i] = (v == nil) and NIL or v
end
return t
end
function unpack2(t) --caution: modifies t

if #t == 0 then
return
else
local v = table.remove(t, 1)
if v == NIL then v = nil end
return v, unpack2(t)
end
end

function trace(f)
print("begin", f)
local result = pack2(f(...))
print("end", f)
return unpack2(result)
end
end

-- Output:
-- begin function: 0x687350
-- calc 2 3 nil
-- end function: 0x687350
-- returns: 5 nil
Here are more optimal implementations of pack2 and unpack2:

local NIL = {} -- placeholder value for nil, storable in table.
function pack2(...)
local t = {...}
for i = 1,n do
if t[i] == nil then
t[i] = NIL
end
end
return t
end
function unpack2(t, k, n)
k = k or 1
n = n or #t
if k > n then return end
local v = t[k]
if v == NIL then v = nil end
return v, unpack2(t, k + 1, n)
end
As a good side effect, now unpack2 can operate on range of indexes [k, n] instead
of whole table. If you don't specify the range, whole table is unpacked.--Sergey
Rozhenko, 2009, Lua 5.1
See also StoringNilsInTables.
Solution: Continuation Passing Style (CPS)
Tables can be avoided if we use the Continuation passing style (CPS)

([Wikipedia]) as below. We could expect this to be a bit more efficient.
function trace(f)
local helper = function(...)
print("end", f)
return ...
end
print("begin", f)
return helper(f(...))
end
end

-- Output:
-- begin function: 0x686b10
-- calc 2 3 nil
-- end function: 0x686b10
-- returns: 5 nil
The CPS approach was also used in the RiciLake's string split function
(LuaList:2006-12/msg00414.html).
Solution: Code Generation
Another approach is code generation, which compiles a separate constructor for

each tuple size. There is some initial overhead building the constructors, but the
constructors themselves can be optimally implemented. The tuple function used
previously can be implemented as such:
local function build_constructor(n)
local t = {}; for i = 1,n do t[i] = "a" .. i end
local arglist = table.concat(t, ',')
local src = "return function(" .. arglist ..
") return function() return " .. arglist .. " end end"
return assert(loadstring(src))()
end
function tuple(...)
local construct = build_constructor(select('#', ...))
return construct(...)
end
To avoid the overhead of code generation on each store, we can memoize

the make_storeimpl function (for background
see [Wikipedia:Memoization] and FuncTables).
function Memoize(fn)
return setmetatable({}, {
__index = function(t, k) local val = fn(k); t[k] = val; return
val end,
__call = function(t, k) return t[k] end
})
end
build_constructor = Memoize(build_constructor)
A more complete example of tuples implemented via code generation is

in FunctionalTuples.
The code building/memoization technique and the above Memoize function are
based on some previous related examples by RiciLake such as [Re: The Curry
Challenge].
Note also that if your wrapped function raises exceptions, you would want
to pcall as well (LuaList:2007-02/msg00165.html).
Solution: Functional, Recursive
The following approach is purely functional (no tables) and avoids code
generation. It's not necessarily the most efficient as it creates a function per tuple
element.
function helper(n, first, ...)
if n == 1 then
return function() return first end
else
local rest = helper(n-1, ...)
return function() return first, rest() end
end
end
function tuple(...)
return (n == 0) and function() end or helper(n, ...)
end
-- TEST
local function join(...)
local t = {n=select('#', ...), ...}
for i=1,t.n do t[i] = tostring(t[i]) end
return table.concat(t, ",")
end
local t = tuple()
assert(join(t()) == "")
t = tuple(2,3,nil,4,nil)
assert(join(t()) == "2,3,nil,4,nil")
print "done"
Solution: Coroutines
Another idea is with coroutines:

do
local function helper(...)
coroutine.yield()
return ...
end
function pack2(...)
local o = coroutine.create(helper)
coroutine.resume(o, ...)
return o
end
function unpack2(o)
return select(2, coroutine.resume(o))
end
end
A similar suggestion was posted in LuaList:2007-02/msg00142.html . That can

be inefficient though (RiciLake notes that a minimal coroutine occupies slightly
more than 1k plus malloc overhead, on freebsd it totals close to 2k, and the
largest part is the stack, which defaults to 45 slots @ 12 or 16 bytes each).
It is not necessary to create a new coroutine on each call. The following approach
is rather efficient, and the recursion uses a tail call:
local yield = coroutine.yield
local resume = coroutine.resume
yield(); return helper(yield(...))
end
local function make_stack() return coroutine.create(helper) end
-- Example
local stack = make_stack()
local function trace(f)
print("begin", f)
resume(stack, f(...))
print("end", f)
return select(2, resume(stack))
end
end
Solution: Upvalues in C Closure
Tuples can be implemented in C as a closure containing the tuple elements as

upvalues. This is demonstrated in Section 27.3 of Programming In Lua, 2nd
Ed [2].
Benchmarks
The speeds of the above solutions are compared in the following benchmark.
-- Avoid global table accesses in benchmark.
local time = os.time
local unpack = unpack
local select = select
-- Benchmarks function f using chunks of nbase iterations for

duration
-- seconds in ntrials trials.
local function bench(duration, nbase, ntrials, func, ...)
assert(nbase % 10 == 0)
local nloops = nbase/10
local ts = {}
for k=1,ntrials do
local t1, t2 = time()
local nloops2 = 0
repeat
for j=1,nloops do
func(...) func(...) func(...) func(...) func(...)
func(...) func(...) func(...) func(...) func(...)
end
t2 = time()
nloops2 = nloops2 + 1
until t2 - t1 >= duration
local t = (t2-t1) / (nbase * nloops2)
ts[k] = t
end
return unpack(ts)
end
local function print_bench(name, duration, nbase, ntrials, func, ...)

local fmt = (" %0.1e"):rep(ntrials)
print(string.format("%25s:" .. fmt, name,
bench(duration, nbase, ntrials, func, ...) ))
end
-- Test all methods.

local function test_suite(duration, nbase, ntrials)
print("name" .. (", t"):rep(ntrials) .. " (times in sec)")
do -- This is a base-line.
return function(...) return f(...) end
end
local f = trace(function() return 11,12,13,14,15 end)
print_bench("(control)", duration, nbase, ntrials, f, 1,2,3,4,5)
end
do
return ...
end
return helper(f(...))
end
end
print_bench("CPS", duration, nbase, ntrials, f, 1,2,3,4,5)
end
do
local yield = coroutine.yield
local resume = coroutine.resume
yield(); return helper(yield(...))
end
local function make_stack() return coroutine.create(helper) end
local stack = make_stack()
resume(stack, f(...))
return select(2, resume(stack))
end
end
print_bench("Coroutine", duration, nbase, ntrials, f, 1,2,3,4,5)
end
do
local t = {f(...)}
return unpack(t)
end
end
print_bench("{...} and unpack", duration, nbase, ntrials, f,
1,2,3,4,5)
end
do
local t = {f(...)}
return unpack(t, 1, n)
end
end
print_bench("{...} and unpack with n", duration, nbase, ntrials,
f, 1,2,3,4,5)
end
do
local NIL = {}
local function pack2(...)
local t = {...}
for i=1,n do
local v = t[i]
if t[i] == nil then t[i] = NIL end
end
return t
end
local function unpack2(t)
local n = #t
for i=1,n do
local v = t[i]
if t[i] == NIL then t[i] = nil end
end
return unpack(t, 1, n)
end
local t = pack2(f(...))
return unpack2(t)
end
end
print_bench("nil Placeholder", duration, nbase, ntrials,
f, 1,2,3,4,5)
end
do
-- This is a simplified version of Code Generation for
comparison.
local function tuple(a1,a2,a3,a4,a5)
return function() return a1,a2,a3,a4,a5 end
end
local t = tuple(f(...))
return t()
end
end
print_bench("Closure", duration, nbase, ntrials, f, 1,2,3,4,5)
end
do
local function build_constructor(n)
local t = {}; for i = 1,n do t[i] = "a" .. i end
local arglist = table.concat(t, ',')
local src = "return function(" .. arglist ..
") return function() return " .. arglist .. " end
end"
return assert(loadstring(src))()
end
local cache = {}
local construct = cache[n]
if not construct then
construct = build_constructor(n)
cache[n] = construct
end
return construct(...)
end
return t()
end
end
print_bench("Code Generation", duration, nbase, ntrials,
f, 1,2,3,4,5)
end
do
local function helper(n, first, ...)
if n == 1 then
return function() return first end
else
local rest = helper(n-1, ...)
return function() return first, rest() end
end
end
return (n == 0) and function() end or helper(n, ...)
end
return t()
end
end
print_bench("Functional, Recursive", duration, nbase, ntrials,
f, 1,2,3,4,5)
end
-- NOTE: Upvalues in C Closure not benchmarked here.
print "done"
end
test_suite(10, 1000000, 3)
test_suite(10, 1000000, 1) -- recheck
Results:
(Pentium4/3GHz)
name, t, t, t (times in sec)
(control): 3.8e-007 3.8e-007 4.0e-007
CPS: 5.6e-007 6.3e-007 5.9e-007
Coroutine: 1.7e-006 1.7e-006 1.7e-006
{...} and unpack: 2.2e-006 2.2e-006 2.4e-006
{...} and unpack with n: 2.5e-006 2.5e-006 2.5e-006
nil Placeholder: 5.0e-006 4.7e-006 4.7e-006
Closure: 5.0e-006 5.0e-006 5.0e-006
Code Generation: 5.5e-006 5.5e-006 5.5e-006
Functional, Recursive: 1.3e-005 1.3e-005 1.3e-005
done
The CPS is the fastest, followed by coroutines (both operated on the stack).
Tables take a bit more time than the coroutine approach, though coroutines could
be even faster if we didn't have the the select on the resume. Use of closures are
a few times slower still (including when generalized with code generation) to an
order of magnitude slower (if generalized with Functional, Recursive).
For a tuple size of 1, we get

(control): 2.9e-007 2.8e-007 2.7e-007
CPS: 4.3e-007 4.3e-007 4.3e-007
Coroutine: 1.4e-006 1.4e-006 1.4e-006
{...} and unpack: 2.0e-006 2.2e-006 2.2e-006
Closure: 2.0e-006 2.0e-006 2.0e-006
done
For a tuple size of 20, we get

(control): 8.3e-007 9.1e-007 9.1e-007
CPS: 1.3e-006 1.3e-006 1.1e-006
Coroutine: 2.7e-006 2.7e-006 2.7e-006
{...} and unpack: 3.0e-006 3.2e-006 3.0e-006
Closure: 1.8e-005 1.8e-005 1.8e-005
done
Notice that the times for table construction methods differ relatively little with
respect to tuple size (due to the initial overhead of constructing a table). In
contrast, use of closures entails run times that vary more significantly with tuple
size.
Issue #2: Combining Lists
Problem: given two variable length lists (e.g. the return values of two
functions, f and g, that each return multiple values), combine them into a single
list.
This can be a problem because of the behavior of Lua to discard all but the first
return value of a function unless it is the last item in a list:
local function f() return 1,2,3 end
local function g() return 4,5,6 end
print(f(), g()) -- prints 1 4 5 6
Besides the obvious solutions of converting the lists into objects such as tables
(via the methods in Issue #1 above), there are ways to do this with only function
calls.
Solution
The following combines lists recursively by prepending only one element at a

time and delaying evaluation of one of the lists.
local function helper(f, n, a, ...)
if n == 0 then return f() end
return a, helper(f, n-1, ...)
end
local function combine(f, ...)
return helper(f, n, ...)
end
-- TEST
local t = {n=select('#', ...), ...}
end
local function f0() return end
local function f1() return 1 end
local function g1() return 2 end
local function f3() return 1,2,3 end
local function g3() return 4,5,6 end
assert(join(combine(f0, f0())) == "")
assert(join(combine(f0, f1())) == "1")
assert(join(combine(f1, f0())) == "1")
assert(join(combine(g1, f1())) == "1,2")
assert(join(combine(g3, f3())) == "1,2,3,4,5,6")
print "done"
Issue #3: Selecting the First N Elements in List
Problem: Return a list consisting of the first N elements in another list.
The select function allows selecting the last N elements in a list, but there is no
built-in function for selecting the first N elements.
Solution
local function helper(n, a, ...)
if n == 0 then return end
return a, helper(n-1, ...)
end
local function first(k, ...)
return helper(k, ...)
end
-- TEST
local t = {n=select('#', ...), ...}
end
local function f0() return end
local function f1() return 1 end
local function f8() return 1,2,3,4,5,6,7,8 end
assert(join(first(0, f0())) == "")
assert(join(first(1, f1())) == "1")
assert(join(first(1, f8())) == "1")
assert(join(first(2, f8())) == "1,2")
assert(join(first(8, f8())) == "1,2,3,4,5,6,7,8")
print "done"
Note: if the number of elements is fixed, the solution is easier:

local function firstthree(a,b,c) return a,b,c end
assert(join(firstthree(f8())) == "1,2,3") -- TEST
Code generation approaches can be based on this.
Issue #4: Appending One Element to a List

Problem: Append one element to a list.
Note that prepending one element to a list is simple: {a, ...}

Solution
local function helper(a, n, b, ...)
if n == 0 then return a
else return b, helper(a, n-1, ...) end
end
local function append(a, ...)
return helper(a, select('#', ...), ...)
end

local function append3(e, a, b, c) return a, b, c, e end
Issue #5: Reversing a List

Problem: Reverse a list.
Solution
local function helper(n, a, ...)
if n > 0 then return append(a, helper(n-1, ...)) end
end
local function reverse(...)
return helper(select('#', ...), ...)
end

local function reverse3(a,b,c) return b,c,a end
Issue #6: The map Function

Problem: Implement the map [3] function over a list.
Solution
if n > 0 then return f(a), helper(f, n-1, ...) end
end
local function map(f, ...)
return helper(f, select('#', ...), ...)
end
Issue #7: The filter Function

Problem: Implement the filter [4] function over a list.
Solution
if n > 0 then
if f(a) then return a, helper(f, n-1, ...)
else return helper(f, n-1, ...) end
end
end
local function grep(f, ...)
return helper(f, select('#', ...), ...)
end
Issue #8: Iterating over Varargs

Problem: Iterate over all elements in the vararg.
Solution
for n=1,select('#',...) do
local e = select(n,...)
end
If you do not need nil elements, you can also use the following:
for _, e in ipairs({...}) do
-- something with e
end
If you wish to use an iterator function without creating a garbage table every
time, you can use the following:
do
local i, t, l = 0, {}
local function iter(...)
i = i + 1
if i > l then return end
return i, t[i]
end
function vararg(...)
i = 0
l = select("#", ...)
for n = 1, l do
t[n] = select(n, ...)
end
for n = l+1, #t do
t[n] = nil
end
return iter
end
end
for i, v in vararg(1, "a", false, nil) do print(i, v) end -- test
-- Output:
-- 1 1
-- 2 "a"
-- 3 false
-- 4 nil
Other Comments
w
Vararg El ciudadano de i
segunda clase k
i
Buscar
Lua varargs " ..." [1] no son [de primera clase] objetos en Lua 5.1, y esto lleva a
algunas limitaciones en la expresin. Algunos de estos problemas y sus
soluciones se dan aqu.
Problema # 1: Ahorro Vararg
Problema # 2: Combinacin de Listas
Problema # 3: Seleccin de los primeros elementos en la Lista N
Problema # 4: Al aadir un elemento a una lista
Problema # 5: Invertir una lista
Edicin # 6: El mapa de funciones
Edicin # 7: La funcin de filtro

Edicin # 8: interactuando sobre Varargs
Problema # 1: Ahorro Vararg

Lua 5.1 vararg ( ...) manejo es un poco limitado. Por ejemplo, no permite cosas
como esta:
funcin tupla (...) de retorno de funcin () de retorno ... extremo
final
de error --Gives "no se puede utilizar '...' fuera de una funcin
vararg cerca de '...'"
(Algunas observaciones sobre las que hay en LuaList: 2007-03 /

msg00249.html .)
Es posible que desee utilizar una funcin para almacenar temporalmente los
valores de retorno de distancia de una llamada de funcin, hacer algn otro
trabajo, y luego recuperar los valores de retorno almacenados de nuevo. La
siguiente funcin utilizara esta hipottica tuplefuncin para aadir instrucciones
de seguimiento en torno a una funcin determinada:
--Wraps Una funcin con instrucciones de seguimiento.
la funcin trace (f)
de retorno de funcin (...)
de impresin ( "iniciar" , f)
local, resultado = tupla (f (...))
de impresin ( "fin" , f)
de retorno resultado ()
final
final
de ensayo = trace ( la funcin (x, y, z) de impresin ( "calc" , x,

y, z); volver x + y, z final )
de impresin ( "devuelve:" , prueba (2,3, nil ))
- salida deseada:
- BEGIN funcin: 0x687350
- calc 2 3 nil
- end funcin: 0x687350
- vueltas: 5 nil
Sin embargo, hay maneras de lograr esto en Lua.
Solucin: {...} yunpack
En su lugar podra poner en prctica tracecon la construccin de la

tabla {...} y unpack:
--Wraps Una funcin con instrucciones de seguimiento.
la funcin trace (f)
local, resultado = {f (...)}
de retorno de desempaquetado (resultado)
extremo
final
de ensayo = trace ( la funcin (x, y, z) de impresin ( "calc" , x,

y, z); volver x + y, z final )
- salida:
- - funcin de comenzar: 0x6869d0
- Calc 2 3 nil
- end Function: 0x6869d0
- retornos: 5
Por desgracia, se echa de menos un nilvalor de retorno ya nilno son

almacenables de forma explcita en las tablas, y en particular {...} no conserva
informacin acerca de salida nils (esto se tratar ms adelante
en StoringNilsInTables ).
Solucin: {...} y unpackconn
La siguiente mejora con respecto a la solucin anterior maneja

adecuadamente nils:
funcin Pack 2 (...) de retorno {n = seleccionar ( '#' , ...), ...}
fines
funcin unpack2 (t) de retorno de desempaquetado (t, 1, tn) final
--Wraps una funcin con instrucciones de seguimiento .

la funcin trace (f)
local, resultado = Pack 2 (f (...))
volver unpack2 (resultado);
extremo
final
de ensayo = trace ( funcin (x, y, z) de impresin ( "calc" , x, y,

z); volver x + y, z final )
de impresin ( "devuelve:" , prueba (2,3, nil ) )
- salida:
- funcin de comenzar: 0x6869d0
- Calc 2 3 nil
- end Function: 0x6869d0
- retornos: 5 nula
Una variante sealado por Shirik es

local de la funcin tupla (...)
locales n = seleccionar ( '#' , ...)
locales t = {...}
retorno de la funcin () de retorno de desempaquetado (t, 1, n)
extremo
final
Solucin: nilLos marcadores de posicin
El siguiente enfoque intercambia los nil's con marcadores de posicin

que pueden ser almacenadas en tablas. Es probable que sea menos ptima aqu,
pero el enfoque podra ser til en otros lugares.
locales NIL = {} - valor de marcador de posicin para nulo,
almacenable en la tabla.
funcin Pack 2 (...)
locales t = {}
para i = 1, n hago
locales v = select (i, ...)
t [i] = (v == nil ) y nIL o v
extremo
de retorno t
finales
funcin unpack2 (t) --caution: t modifica

si #t == 0 y luego
volver
otra cosa
local de v = table.remove (t, 1)
si v == nIL entonces v = nil finales
de retorno v, unpack2 (t)
extremo
final
--Wraps una funcin con instrucciones de seguimiento.

la funcin trace (f)
local, resultado = Pack 2 (f (...))
volver unpack2 (resultado)
extremo
final
de ensayo = traza ( funcin (x, y, z) de impresin ( "calc" , x, y,

- salida:
0x687350: - funcin de comenzar
Calc 2 3 nil -
- End Function: 0x687350
- retornos: 5 nula
Aqu estn las implementaciones ms ptimas de pack2 y unpack2:
locales NIL = {} - valor de marcador de posicin para nulo,
almacenable en la tabla.
funcin Pack 2 (...)
locales t = {...}
para i = 1, n hacer
si t [i] == nil entonces
t [i] = NIL extremo final de retorno t
finales funcin unpack2 (t, k, n)
k = k o 1
n = n o #t
si k> n luego regresar finales locales v = t [k]
si v == nIL entonces v = nil finales de retorno v, unpack2 (t, k +
1, n)
final
Como un buen efecto secundario, ahora unpack2 puede operar en rango de

ndices [k, n] en lugar de toda la tabla. Si no se especifica el intervalo, toda la
tabla se descomprime .-- Sergey Rozhenko de 2009, Lua 5.1
Ver tambin StoringNilsInTables .
Solucin: Continuacin Pases Estilo (CPS)
Las tablas pueden ser evitados si utilizamos el estilo Continuacin paso (CPS)
( [Wikipedia] ) de la siguiente manera. Podramos esperar que esto sea un poco
ms eficiente.
la funcin trace (f)
locales ayudante = funcin (...)
de retorno ...
finales
de retorno auxiliar (f (... ))
final
final
de ensayo = trace ( funcin (x, y, z) de impresin ( "calc" , x, y,

- salida:
-: 0x686b10 funcin comenzar
Calc 2 3 nil -
- End Function: 0x686b10
- retornos: 5 nula
El enfoque SCP tambin se utiliz en el RiciLake funcin de cadena de divisin

's ( LuaList: 2006-12 / msg00414.html ).
Solucin: Generacin de cdigo
Otro enfoque es la generacin de cdigo, que compila un constructor separada

para cada tamao de tupla. Hay una cierta sobrecarga inicial la construccin de
los constructores, pero los constructores s se puede implementar de forma
ptima. La tuplefuncin utilizada anteriormente puede ser implementado como
tal:
local de la funcin build_constructor (n)
locales t = {}; para i = 1, n hago t = [i] "a" .. i termino
locales arglist = table.concat (t, ',' )
locales src = "funcin de retorno (" .. arglist ..
") la funcin de retorno ( ) de retorno " .. ..
arglist " extremo a extremo "
retorno asercin ( loadString (src)) ()
finales
funcin tupla (...)
local de construccin = build_constructor ( seleccione (
'#' , ...))
de retorno constructo (. ..)
final
Para evitar la sobrecarga de la generacin de cdigo en cada tienda, podemos

memoize la make_storeimplfuncin (para el fondo ver [Wikipedia:
memoization] y FuncTables ).
funcin memoize (fn)
volver setmetatable ({}, {
__index = funcin (t, k) locales val = fn (k); t [k] = val;
volver val final ,
__call = funcin (t, k) de retorno t [ k] final
}) final
build_constructor = memoize (build_constructor)
Un ejemplo ms completo de tuplas implementadas a travs de la generacin de

cdigo est en FunctionalTuples .
La tcnica de construccin de cdigo / memoization y por encima de
la Memoizefuncin se basan en algunos ejemplos relacionados anteriores
por RiciLake como [Re: El desafo Curry] .
Tenga en cuenta tambin que si su funcin ajustada plantea excepciones, usted

querra pcalltambin ( LuaList: 2007-02 / msg00165.html ).
Solucin: funcional, recursiva
El siguiente enfoque es puramente funcionales (no hay mesas) y evita la

generacin de cdigo. No es necesariamente el ms eficiente, ya que crea una
funcin por cada elemento de la tupla.
la funcin auxiliar (n, en primer lugar, ...)
si n == 1 a continuacin,
volver la funcin () volver primer extremo
dems
locales de descanso = helper (n-1, ...)
de retorno de funcin () devolver primera, descanso) ( extremo
final
finales
funcin tupla (...)
de retorno (n == 0) y la funcin () final o ayudante (n, ...)
final
- PRUEBA
local de la funcin join ( ...)
locales t = {n = seleccionar ( '#' , ...), ...}
para i = 1, tn hacer t [i] = toString (t [i]) extremo
de retorno table.concat ( t, "" )
terminar
locales t = tupla ()
afirman (join (t ()) == "" )
t = tupla (2,3, nula , 4, nil )
afirman (join (t ()) == "2,3, nil, 4, nulo" )
print "hecho"
Solucin: corrutinas
Otra idea es la co-rutinas:

hacer
local de la funcin de ayuda (...)
coroutine.yield ()
de retorno ...
finales
funcin Pack 2 (...)
locales o = coroutine.create (ayudante)
coroutine.resume (O, ...)
de retorno o
finales
funcin unpack2 (o)
volver selecto (2, coroutine.resume (o))
final
final
Una sugerencia similar fue publicada en LuaList: 2007-02 / msg00142.html . Eso

puede ser ineficaz, aunque ( RiciLake seala que una co-rutina mnima ocupa un
poco ms de 1k, ms sobrecarga malloc, en FreeBSD que asciende a cerca de 2k,
y la parte ms grande es la pila, que por defecto es de 45 ranuras @ 12 o 16 bytes
cada uno).
No es necesario para crear un nuevo co-rutina en cada llamada. El siguiente

enfoque es bastante eficiente, y la recursividad utiliza una llamada de cola:
locales rendimiento = coroutine.yield
locales resume = coroutine.resume
yield (); volver ayudante (rendimiento (...))
terminar
local de la funcin make_stack () de retorno coroutine.create
(ayudante) final
- Ejemplo
local de pila = make_stack ()
local de la funcin trace (f)
de impresin ( "begin " , f)
curriculum vitae (pila, f (...)) de impresin ( " fin " , f)
volver selecto (2, curriculum vitae (pila))
final final
Solucin: upvalues en C Cierre
Las tuplas pueden ser implementadas en C como un cierre que contiene los
elementos de tupla como upvalues. Esto se demuestra en la Seccin 27.3 de la
programacin en Lua, 2 Ed [2] .
Los puntos de referencia
Las velocidades de las soluciones anteriores se comparan en la siguiente

referencia.
- Evitar la tabla global de accesos en referencia.
local de tiempo = os.time
locales de desempaquetado = desempaquetado y
locales selectos = seleccionar
- Puntos de Referencia funcin f utilizando trozos de iteraciones
Nbase de duracin
- segundos en ensayos ntrials.
local de la funcin de banco (de duracin, Nbase, ntrials,
funcional, ...)
afirman (10% == 0 Nbase)
locales nloops = Nbase / 10
locales ts = {}
para k = 1, ntrials hacer
locales t1, t2 = tiempo ( )
locales nloops2 = 0
repita
para j = 1, nloops hacen
func (...) func (...) func (...) func (...) func (...)
func (...) func (...) func (...) func (...) func (...) final
t2 = tiempo ()
nloops2 = nloops2 + 1 hasta t2 - t1> = duracin
locales t = (t2-t1) / (* Nbase nloops2)
ts [k] = T finales de retorno de desempaquetado (ts)
termina local de la funcin print_bench (nombre, duracin, Nbase,
ntrials, funcional, ...)
locales fmt = ( "% 0.1e" ): representante (ntrials )
de impresin ( String.Format ( "% 25s:" .. FMT, nombre,
, Nbase, ntrials, funcional, ... banco
(duracin))) end - prueba de todos los mtodos. local de la funcin
test_suite (duracin, Nbase, ntrials)
print ( "nombre" .. ( "t" ): Rep (ntrials) .. "(tiempos en
segundos)" ) do - Se trata de una lnea de base. local de la funcin
trace (f)
de retorno de funcin (...) de retorno f (...) extremo final
local de f = trace ( funcin () volver 11,12,13,14,15 final )
print_bench ( "(control)" , duracin, Nbase, ntrials, f,
1,2,3,4,5)
final do local de la funcin trace (f)
de retorno ...
finales de retorno de funcin (...)
de retorno auxiliar (f (...))
final final local de f = trace ( funcin () volver
11,12,13,14,15 final )
print_bench ( "CPS" , duracin, Nbase, ntrials, f, 1,2,3,4, 5)
final hacer locales rendimiento = coroutine.yield locales resume =
coroutine.resume local de la funcin de ayuda (...)
yield (); retorno ayudante (rendimiento (...))
terminar local de la funcin make_stack () de retorno
coroutine.create (ayudante) terminar local de pila = make_stack ()
local de la funcin trace (f)
curriculum vitae (pila, f (. ..)) volver selecto (2, resume
()) pila
final termina local de f = trace ( funcin () volver
11,12,13,14,15 final )
print_bench ( "Coroutine" , duracin, Nbase, ntrials, f,
1,2,3,4,5)
final do local de la funcin trace (f)
locales t = {f (...)}
retorno de desempaquetado (t)
extremo final local de f = trace ( funcin ( ) volver
11,12,13,14,15 final )
print_bench ( "{...} y desempaquetar" , duracin, Nbase, ntrials,
f, 1,2,3,4,5)
final do local de la funcin trace (f )
locales t = {f (...)}
retorno de desempaquetado (t, 1, n)
extremo final local de f = trace ( funcin ( ) volver
11,12,13,14,15 final )
print_bench ( "{...} y descomprimir con n" , la duracin, Nbase,
ntrials,
f, 1,2,3,4,5) final do local de NIL = {}
local de la funcin Pack 2 (...)
locales t = {...}
para i = 1, n hago locales v = t [i]
si t [i] == nil entonces t [i] = nIL extremo final de
regreso t
terminar local de la funcin unpack2 (t)
locales n = # t
para i = 1, n hago locales v = t [i]
si t [i] == nIL entonces t [i] = nil extremo final de
retorno de desempaquetado (t, 1, n)
terminar local de la funcin trace (f)
locales t = Pack 2 (f (...))
volver unpack2 (t)
extremo final locales f = trace ( funcin () volver
11,12,13,14,15 final )
print_bench ( "nula marcador de posicin" , duracin, Nbase,
ntrials,
f, 1,2,3,4,5) final do - Este es una versin
simplificada de la generacin de cdigo para la comparacin. local de
la funcin tupla (a1, a2, a3, a4, a5)
de retorno de funcin () de retorno a1, a2, a3, a4, a5 extremo
final local de la funcin trace (f)
locales t = tupla (f ( ...))
de retorno t ()
11,12,13,14,15 final )
print_bench ( "Cierre" , duracin, Nbase, ntrials, f, 1,2,3 ,
4,5)
final do local de la funcin build_constructor (n)
locales t = {}; para i = 1, n hago t = [i] "a" .. i termino
locales arglist = table.concat (t, ',' )
locales src = "funcin de retorno (" .. arglist ..
") la funcin de retorno ( ) de retorno " .. ..
arglist " extremo a extremo " retorno asercin ( loadString (src)) ()
terminar local de cach = {}
local de la funcin tupla (...)
locales construir cach = [n]
si no se construye entonces
construir build_constructor = (n)
cach [n] = constructo final retorno construccin (...)
termina local de la funcin trace (f)
locales t = tupla (f (...))
de retorno t ()
11,12,13,14,15 final )
print_bench ( "Generacin de cdigo" , duracin, Nbase, ntrials,
f, 1,2 , 3,4,5) final do local de la funcin auxiliar
(n, en primer lugar, ...)
si n == 1 a continuacin, volver la funcin () volver primer
extremo dems locales de descanso = helper (n-1, ...)
de retorno de funcin () devolver en primer lugar, de reposo
() final final final local de la funcin tupla (...)
de retorno (n == 0) y la funcin () final o ayudante (n,. ..)
terminar local de la funcin trace (f)
locales t = tupla (f (...))
de retorno t ()
final final local de f = trace ( funcin () volver 11,12,13,
14,15 end )
print_bench ( "funcional, recursiva" , duracin, Nbase, ntrials,
f, 1,2,3,4,5) final - NOTA: upvalues en C cierre no
como puntos de referencia aqu. print "hecho" final
test_suite (10, 1000000, 3)
test_suite (10, 1000000, 1) - vuelva a verificar
resultados:
(Pentium 4 / 3GHz)
Nombre, T, T, T (tiempos en segundos)
(control): 3.8E-007 3.8E-007 4.0E-007
CPS: 5.6E-007 6.3e-007 5.9E-007
Coroutine: 1.7 e-006 1.7e-006 1.7e-006
{...} y descomprimir: 2.2e-006 2.2e-006 2.4e-006
{...} y descomprimir con n: 2.5e-006 2.5e-006 2.5 e-006
nil marcador de posicin: 5.0e-006 4.7E-006 4.7E-006
Cierre: 5.0e-006 5.0e-006 5.0e-006
de generacin de cdigo: 5.5e-006 5.5e-006 5.5e-006
funcional, recursiva : 1.3e-005 1.3e-005 1.3e-005
hecho
El CPS es el ms rpido, seguido de co-rutinas (ambos operados en la

pila). Tablas tomar un poco ms de tiempo que el enfoque de co-rutina, aunque
corrutinas podran ser an ms rpido si no tuviramos la del selecten
el resume. El uso de cierres son un par de veces ms lenta todava (incluyendo
cuando se generalizan con la generacin de cdigo) a un orden de magnitud ms
lento (si se generaliza con Funcional, recursiva).
Para un tamao de tupla de 1, obtenemos

nombre, T, T, T (s) en los tiempos
(de control): 2.9e-007 2.8e-007 2.7E-007
CPS: 4.3e-007 4.3e-007 4.3e-007
Coroutine: 1.4e-006 1.4e -006 1.4e-006
{...} y descomprimir: 2.0e-006 2.2e-006 2.2e-006
{...} y descomprimir con n: 2.4e-006 2.5e-006 2.4e-006
nil marcador de posicin : 3.3e-006 3.3e-006 3.3e-006
Cierre: 2.0e-006 2.0e-006 2.0e-006
de generacin de cdigo: 2.2e-006 2.5e-006 2.2e-006
funcional, recursiva: 2.5e-006 2.4e-006 2.2e-006
hecho
Para un tamao de tupla de 20, obtenemos

nombre, T, T, T (tiempos en segundos)
(control): 8.3e-007 9.1e-007 9.1e-007
CPS: 1.3e-006 1.3e-006 1.1E-006
Coroutine: 2.7e-006 2.7e -006 2.7e-006
{...} y descomprimir : 3.0e-006 3.2e-006 3.0e-006
{...} y descomprimir con n: 3.7e-006 3.3e-006 3.7e-006
nil marcador de posicin : 1,0 E-005 1.0E-005 1.0E-005
Cierre: 1.8E-005 1.8E-005 1.8E-005
de generacin de cdigo: 1.9e-005 1.8E-005 1.9e-005
funcional, recursiva: 5.7e-005 5.7e-005 5.8e-005
hecho
Tenga en cuenta que los tiempos de los mtodos de construccin de mesa difieren
relativamente poco con respecto al tamao tupla (debido a la sobrecarga inicial
de la construccin de una mesa). En contraste, el uso de cierres implica tiempos
que varan ms significativamente con el tamao tupla ejecutar.
Problema # 2: Combinacin de Listas

Problema: dadas dos listas de longitud variable (por ejemplo, los valores de
retorno de dos funciones, fy g, que cada devolver mltiples valores), se
combinan en una sola lista.
Esto puede ser un problema debido al comportamiento de Lua para descartar

todos, pero el primer valor de retorno de una funcin a menos que sea el ltimo
elemento de una lista:
local de la funcin f () volver 1,2,3 extremo
local de la funcin g () devuelven 4,5,6 final
de impresin (f (), g ()) - grabados 1 4 5 6
Adems de las soluciones obvias de la conversin de las listas en objetos tales

como tablas (a travs de los mtodos en la edicin # 1 arriba), hay maneras de
hacer esto con slo llamadas a funciones.
Solucin
A continuacin se combina listas de forma recursiva anteponiendo slo un

elemento a la vez y retrasar la evaluacin de una de las listas.
local de la funcin auxiliar (f, n, a, ...)
si n == 0 y luego volver f () final
de regreso a, ayudante (f, n-1, ...)
termina
local de la funcin se combinan (f, ... )
de retorno auxiliar (f, n, ...)
final
- PRUEBA
local de la funcin join (...)
locales t = {n = seleccionar ( '#' ,. ..), ...}
para i = 1, tn do t [i] = toString (t [i]) extremo
de retorno table.concat (t, "" )
terminar
local de la funcin f0 () de retorno termino
local de la funcin f1 () de retorno 1 extremo
local de la funcin g1 () de retorno 2 extremo
local de la funcin F3 () volver 1,2,3 extremo
local de la funcin g3 () volver 4,5,6 final
asercin (join (combinar (f0, f0 ())) == "" )
afirman (join (combinar (f0, f1 ())) == "1" )
afirman (join (combinar (f1, f0 ())) == "1" )
afirman (join (cosechadora (G1 , f1 ())) == "1,2" )
afirman (join (combinar (g3, f3 ())) == "1,2,3,4,5,6" )
print "hecho"
Problema # 3: Seleccin de los primeros

elementos en la Lista N
Problema: Devuelve una lista que consiste en los primeros N elementos en otra
lista.
La selectfuncin permite la seleccin de los ltimos N elementos de una lista,

pero no hay ninguna funcin integrada para la seleccin de los primeros N
elementos.
Solucin
local de la funcin auxiliar (n, a, ...)
si n == 0 y luego volver extremo
de regreso a, ayudante de (n-1, ...)
terminar
local de la funcin primero (k, ...)
locales n = seleccionar ( ' # ' , ...)
de retorno auxiliar (k, ...)
final
- PRUEBA
local de la funcin join (...)
locales t = {n = seleccionar ( ' # ' , ...), ...}
de i = 1, tn do t [i] = toString (t [i]) extremo
de retorno table.concat (t, "" )
terminar
local de la funcin f0 () de retorno terminar
local de la funcin f1 () de retorno 1 extremo
local de la funcin f8 ( ) volver 1,2,3,4,5,6,7,8 final
asercin (join (primero (0, f0 ())) == "" )
afirman (join (primero (0, f 1 ())) = = "" )
valer (join (primero (1, f1 ())) == "1" )
afirman (join (primero (0, f8 ())) == "" )
afirman (join (primero (1, f8 ())) == "1" )
valer (join (primero (2, f8 ())) == "1,2" )
afirman (join (primero (8, f8 ())) == "1,2 , 3,4,5,6,7,8 " )
print " hecho "
Nota: si se fija el nmero de elementos, la solucin es fcil:

local de la funcin firstthree (a, b, c) de regreso a, b, c final
asercin (unidas (firstthree (f8 ())) == "1,2,3" ) - TEST
enfoques de generacin de cdigo se pueden basar en esto.
Problema # 4: Al aadir un elemento a una lista

Problema: Anexar un elemento de una lista.
Tenga en cuenta que anteponiendo un elemento a una lista es simple: {a, ...}
Solucin
local de la funcin auxiliar (a, n, b, ...)
si n == 0 y luego regresar una
persona de retorno b, ayudante (a, n-1, ...) extremo
final
local de la funcin de agregacin (a, ...)
retorno ayudante (a, seleccione ( '#' , ...), ...)
final

local de la funcin append3 (e, a, b, c) de regreso a, b, c, e final
Problema # 5: Invertir una lista

Problema: Invertir una lista.
Solucin
local de la funcin auxiliar (n, a, ...)
si n> 0 entonces volver append (a, ayudante de (n-1, ...)) final
final
local de la funcin inversa (...)
de retorno auxiliar ( seleccionar ( '# ' , ...), ...)
final

local de la funcin reverse3 (a, b, c) de retorno b, c, a fin
Edicin # 6: El mapa de funciones

Problema: Implementar el mapa [3] funcin sobre una lista.
Solucin
si n> 0 entonces volver f (a), el ayudante (f, n-1, ...) extremo
final
local de la funcin de mapa (f, ...)
de retorno helper (f, seleccione ( '#' , ...), ...)
final
Edicin # 7: La funcin de filtro

Problema: Implementar el filtro [4] la funcin sobre una lista.
Solucin
si n> 0 entonces
si f (a) a continuacin, volver a, helper (f, n-1, ...)
ms retorno helper (f, n-1, ...) extremo
final
terminar
local de la funcin grep (f, ...)
de retorno auxiliar (f, seleccione ( '#' , ...), ...)
final
Edicin # 8: interactuando sobre Varargs

Problema: Iterar sobre todos los elementos de la vararg.
Solucin
para n = 1, seleccione ( '#' , ...) hacer
locales e = selecciona (n, ...)
final
Si usted no necesita elementos nulos, tambin se puede utilizar lo siguiente:
para _, e en ipairs ({...}) hacen
- algo con e
fin
Si desea utilizar una funcin de iterador sin crear una mesa de basura cada vez,
puede utilizar lo siguiente:
hacer
local, i, t, l = 0, {}
local de la funcin iter (...)
i = i + 1 si i> l y luego vuelva finales de retorno i, t [i]
finales funcin vararg (...)
i = 0
l = select ( "#" , ...)
para n = 1, l do
t [n] = seleccionar (n, ...)
final para n = l + 1, #t hacen
t [n] = nil final volver iter
extremo final de i, v en vararg (1, "a" , falsa , nil ) no
impresin (i, v) final - prueba - salida: - 1 1 - 2 "a" - 3 falsa - 4
nil
Otros comentarios
(ninguna)
Tutorial ediscrip
Scripting Tutorial - Leccin 1

Descargar los archivos de apoyo para este tutorial
Descargar esta pgina en formato PDF
Texas Instruments TI-Nspire Scripting pgina de soporte
TI-Nspire 3.0 aade potentes nuevas funcionalidades a la plataforma en

forma de capacidades de scripting Lua. Lua es un lenguaje de
programacin moderno rpido. Scripts escritos en Lua (incluso utilizando
un editor de texto simple) se pueden convertir a los documentos de TI-
Nspire utilizando el Editor de secuencias OS3.2, cuanto mayor es la
herramienta de secuencias de comandos de TI-Nspire o
mediante herramientas de terceros . Estas secuencias de comandos
aaden nuevas e interesantes posibilidades a las capacidades nativas de
TI-Nspire para la creacin de documentos para la enseanza y el
aprendizaje.
La potencia disponible para los programadores experimentados que

utilizan las capacidades de scripting Lua ahora integradas en TI-Nspire
es enorme, y el cielo es el lmite en trminos de lo que ahora es posible,
como lo demuestra la gama de actividades de toma de muestras . Sin
embargo, hay oportunidades para que incluso los que no tienen
conocimientos de programacin para hacer uso de estas caractersticas
con ms limitado, pero todava formas potencialmente tiles y
potentes. Estos tutoriales para principiantes ofrecen algunas formas
prcticas en las que los profesores y estudiantes pueden comenzar a
utilizar Lua para crear sus propios documentos.
El enfoque aqu ser sobre el uso de Lua inicialmente para mostrar el

texto. grficos dinmicos e imgenes vienen despus.
Haga clic en cualquier lugar de esta imagen para un vdeo de

Leccin 1.1: Primeros pasos demostracin
con Lua y TI-Nspire
Para explorar estas primeras

secuencias de comandos, puede
utilizar el Editor de secuencias
de TI-Nspire si est utilizando
el software de TI-Nspire en Mac
o PC (slo tiene que buscar el
men Insertar - abajo de la parte
inferior se encuentran las
opciones para los introdujo una
secuencia de comandos o editar
un script existente).
Tambin puede correr y jugar

con estos primeros guiones de la
derecha en su navegador -
simplemente haga clic en el azul
"Prubalo ya!" botn de abajo
para abrir una nueva pgina,
creada para esta leccin. Haga
clic en el botn que se ve all -
"Ejecutar el cdigo" - y ver
esta leccin a la vida. Pruebe
algunos cambios en la secuencia
de comandos en el cuadro de
texto debajo de la ventana de
Lua y ver los efectos.
Una nueva opcin es utilizar el

entorno de desarrollo integrado
de TI-(TIDE) desarrollado por
Nadrieril Feneanar - Un fcil
opcin para los usuarios de
mano de usar. Va a encontrar el
documento de esta leccin en
los documentos de
apoyo disponibles para su
descarga - o simplemente
utilizar los botones verdes a
continuacin. Solo trata de
algunos cambios en la pgina
guin y ver stos reflejan en la
siguiente pgina Lua.
Tambin puede utilizar la
herramienta de Lua de terceros
llamado Oclua , desarrollado
por Olivier Armand. El
documento Oclua tambin
forma parte de los documentos
de apoyo disponibles para este
tutorial .
NOTA : a lo largo de estas lecciones, los comandos de script Lua se

mostrarn en la fuente negro:
funcin on.paint (GC)
GC: drawString ( "hola mundo", 0, 20 )
fin
La sangra de la segunda lnea es opcional, pero a menudo muy til

cuando se trabaja con guiones largos. El caso del texto no es opcional -
Lua es un lenguaje de maysculas y minsculas y debe escribir todos los
comandos tal y como se muestra aqu. As que todo en este ejemplo es
en minsculas, excepto la "S" en "drawString".
Mientras que la mayora de los scripts Lua que se pueden ver en la

mirada salvaje enormemente complicada (y, de hecho, pueden ser y
generalmente son!) Un exitoso guin Lua puede ser tan simple como
esto!
Qu aprendemos de esto?
La sintaxis para definir una funcin en Lua es la misma, ya

que es en otro sitio:
nombre de la funcin (argumento)
algo de instruccin
fin
En nuestro ejemplo, la funcin es una funcin estndar de
Lua, llamado "on.paint". Usted lo ver en la mayora (si no
todos) los scripts Lua se mire, y se entrega con claridad lo
que promete: "en" ejecutar esta funcin, el contenido se
"pint" a la pantalla.
"GC" es sinnimo de "contexto grfico" y se utiliza cuando se

definen los grficos de cualquier tipo. Que se ve dentro de la
funcin, la nica lnea de instruccin se define en trminos
de este trmino "GC". No se preocupe demasiado acerca de
esto - se acostumbrar a ella muy rpidamente.
La lnea de instruccin de esta funcin tambin es bastante

explicativo: gc: drawString ( "hola mundo", 0,
20) significa que, dentro del contexto grfico definido por
esta funcin, la cadena "hola mundo" ser dibujado en la
posicin (0, 20) en la ventana.
El sistema de coordenadas comienza desde la esquina

superior izquierda como el origen. As que este texto se
iniciar en el lado izquierdo de la ventana y 20 unidades
hacia abajo (s, un sistema de coordenadas XY al igual que
estamos acostumbrados, slo la parte superior de la pantalla
es 0 y que contamos hasta bajar!)
Ahora debera tomar unos momentos y jugar ! Cambie el texto, y

cambiar las coordenadas x e y. Trate de colocar el texto en el centro de
la ventana - Qu te ensea acerca de las dimensiones de la ventana? Si
se encuentra en el software, cambiar entre el ordenador y vistas de
mano - se ver que, centrado para uno no central para el otro!
Hacer una pausa para tomar aliento antes de continuar.
Pero por qu?
Tal vez sea oportuno a parar por un momento y preguntar - Por qu

molestarse? Hay maneras mucho ms fciles para poner texto en una
pantalla.
Dos propiedades muy importantes de una ventana de Lua en TI-Nspire

en lugar de decir, lo mismo que muestran el uso de Notas:
Haga clic en cualquier lugar de esta imagen para ver un breve vdeo
1. Haga clic en cualquier
ventana basada en
Lua. Arrastre alrededor
de - tratar de editarlo. Es
segura. Cualquier texto
se visualiza en una
ventana de este tipo no
puede ser editado o
modificado por el
usuario del
documento. En Notas,
por supuesto, el usuario
puede cambiar
fcilmente - y, de hecho
romper - lo que el autor
ha tomado el tiempo y
cuidado para mostrar
all. Y, del mismo modo
que podamos en las
notas, el texto nos
visualizacin puede ser
esttica o dinmica. As
que podemos crear
fcilmente poderosas
herramientas de
aprendizaje del mismo
modo que podamos con
notas, pero en un
entorno de visualizacin
sea segura.
2. En la segunda parte de
esta leccin, aprender a
controlar el tamao de
letra, color y estilo, y
cmo fcilmente el texto
en una lnea de centro o,
de hecho, en el centro de
la ventana. En Lua
tenemos un control
significativo sobre la
forma de visualizacin
de nuestro texto - mucho
ms que para las
instalaciones de texto
usando las TI-Nspire
nativas. En trminos de
color, usted tiene acceso
inmediato a millones de
colores, y el tamao es
igualmente sin
restricciones. Tmese un
momento para ver el
vdeo de demostracin
corta a la derecha,
"Deducir la frmula
cuadrtica". Se ilustra
algunas de las
posibilidades de
utilizacin de Lua.
Leccin 1.2: un poco ms interesante?
Por lo tanto, de vuelta al trabajo. Ests listo

para un poco ms?
Haga clic en cualquier lugar de esta imagen para
Si no est en la pgina 1.2, volver a esa un vdeo de demostracin
pgina. Vamos a aadir un par de lneas a
nuestro script on.paint.
GC: setFont ( "sansserif", "b", 12)
GC: setColorRGB ( 158, 5, 8 )
GC: drawString ( "Este es mi texto", 20, 20 )
fin
Una vez ms, el estudio de estos nuevos comandos y ver lo que hacen -
tienen un juego y probar diferentes valores. Rpidamente se apreciar
que setFont lleva tres entradas (familia ( "serif" o "sanserif"), estilo ( "b"
para negrita, "r" para regular, "i" para cursiva o "bi" para negrita itlica)
y , por supuesto, el tamao).
setColorRGB es una forma sencilla de acceder a una gran cantidad de

colores: RGB significa rojo, verde, azul, donde el rojo es (255, 0, 0),
Verde es (0, 255, 0) y azul (0, 0, 255). Es evidente que hay muchos
colores en el medio y puede jugar un poco con los nmeros o, como yo,
puede ir listas de acceso en lnea o simplemente descargar el PDF que
yo uso . Mi consultor de color confianza me informa que burdeos (158, 5,
8) y la marina (20, 20, 138) funcionan muy bien juntos! Y es mucho
mejor que simplemente una paleta de 9 a 15 colores disponibles en la
actualidad dentro de TI-Nspire!
Si usted todava est con nosotros, entonces usted est haciendo muy
bien en sus primeros pasos con Lua. Vamos a terminar esta primera
leccin por aprender a centrar ese texto, y al hacerlo, introducir la idea
importante de variables locales y globales. En este caso, nos enteramos
de que Lua suministra todo tipo de comandos tiles, tales
como platform.window: altura () y platform.window: Ancho () . Como el
nombre sugiere, estos comandos se pueden utilizar para entregar a
usted los valores para la ventana actual. Si definimos estos como
variables, como w y h, entonces podemos hacer algunos clculos
simples para determinar el mejor lugar para poner nuestro texto! Vamos
a definir estas variables como local, pero colocndolos fuera de
cualquier funcin, estn a disposicin de todo el guin. Note que incluso
podemos definir un nombre de variable, como "pantalla" para
reemplazar el "platform.window" ms voluminosos? Tiene ms sentido
para m ...
Introducimos dos ms comandos de Lua as: GetStringWidth y

getStringHeight. Estos tambin deben explicarse por s mismo. Volver a
la pgina 1.2 en Notes.
local de la pantalla
= platform.window
local de h = pantalla: altura () Haga clic en cualquier lugar de esta imagen para un vdeo de
demostracin
local de la pantalla w =: Ancho
()
GC: setFont ( "sansserif", "b",

12)
GC: setColorRGB ( 158, 5, 8)
locales sw = gc: GetStringWidth

( "Este es mi texto")
locales sh = gc: getStringHeight

( "Este es mi texto")
GC: drawString ( "Este es mi

texto", w / 2 - sw / 2, h / 2 + sh /
2)
fin
As definimos anchura y la altura como variables locales simples, w y

h. Tambin podemos obtener las dimensiones de cuerda. A continuacin,
para centrar la cadena horizontal, tomar la mitad de la ventana (w / 2) y
luego volver a la mitad de la longitud de la cadena (w / 2 - sw /
2). Verticalmente el mismo, excepto que recordamos contamos hacia
atrs en Lua - hacia abajo es mayor, es decir hasta menos!
Ahora que?
Eso es todo por la leccin 1 - su turno para jugar!
Por qu no tratar de alinear el texto a la derecha? Echar un vistazo a la

cimbra que se acaba de hacer y pensar acerca de cmo este enfoque
podra ser utilizado para la alineacin izquierda y derecha.
Qu hay de colocar el texto en la parte superior de la pgina - o hacia
abajo la parte inferior?
Pruebe algunos colores diferentes - ir salvaje!
En la siguiente leccin , aprendemos cmo hacer este texto a partir de

volver a la vida, y cmo utilizar una tabla para organizar varias lneas de
texto muy bien distribuido en su pgina!
Inicio TI-Nspire Autora TI-Nspire Scripting HQ Scripting Tutorial - Leccin 1
Download supporting files for this tutorial
Download this page in PDF format
Texas Instruments TI-Nspire Scripting Support Page
TI-Nspire 3.0 added powerful new functionality to the platform in the

form of Lua scripting capabilities. Lua is a fast modern scripting
language. Scripts written in Lua (even using a simple text editor) may be
converted to TI-Nspire documents using the OS3.2 Script Editor, the
older TI-Nspire Scripting Tool or by third-party tools. Such scripts add
exciting new possibilities to TI-Nspire's native capabilities for creating
documents for teaching and learning.
The power available to experienced programmers using the Lua scripting

capabilities now built into TI-nspire is enormous, and the sky is the limit
in terms of what is now possible, as exemplified by the range of sampler
activities. However, there are opportunities for even those without a
programming background to make use of these features in more limited
but still potentially useful and powerful ways. These beginners' tutorials
offer some practical ways in which teachers and students may begin to
use Lua to create their own documents.
The focus here will be on using Lua initially to display text. Dynamic
graphs and images will follow later.
Click anywhere on this image for a video demonstration

Lesson 1.1: First Steps with
Lua and TI-Nspire
To explore these early scripts,

you may use the TI-Nspire
Script Editor if you are using the
TI-Nspire software on Mac or
PC (just look for the Insert
menu - down the bottom you
will find the options to either
Insert a Script or Edit an
existing script).
You may also run and play with

these early scripts right in your
browser - just click on the blue
"Try it Now!" button below to
open a new page, set up for this
lesson. Click the button you see
there - "Run your code" - and
you will see this lesson come to
life. Try some changes to the
script in the text box below the
Lua window and see the effects.
A new option is to use the TI-

Integrated Development
Environment (TIDE) developed
by Nadrieril Feneanar - an easy
to use option for handheld users.
You will find the document for
this lesson in the supporting
documents available for
download - or just use the green
buttons below. Just try some
changes on the script page and
see these reflected on the
following Lua page.
You may also use the third-party

Lua tool called Oclua,
developed by Olivier Armand.
The Oclua document is also part
of the supporting documents
available for this tutorial.
NOTE: throughout these lessons, Lua scripting commands will be

displayed in black font:
function on.paint(gc)
gc:drawString("hello world", 0, 20)
end
The indenting of the second line is optional, but often helpful when
working with longer scripts. The case of the text is NOT optional - Lua is
a case-sensitive language and you must enter all commands exactly as
shown here. So everything in this example is in lower case, except the
"S" in "drawString".
While most of the Lua scripts that you will see in the wild look
enormously complicated (and, in fact, they can be and usually are!) a
successful Lua script can be as simple as this!
What do we learn from this?
The syntax for defining a function in Lua is much the same

as it is anywhere else:
function name(argument)
some instruction
end
In our example, the function is a standard Lua function,
called "on.paint". You will see it in most (if not all) Lua scripts
you look at, and it clearly delivers what it promises: "on"
running this function, the contents are "painted" to the
screen.
"gc" stands for "graphics context" and is used when graphics

of any type are defined. You see within the function, the
single line of instruction is defined in terms of this "gc" term.
Don't worry too much about this - you will get used to it very
quickly.
The instruction line of this function is also pretty

explanatory: gc:drawString("hello world", 0, 20) means
that, within the graphics context defined by this function, the
string "hello world" will be drawn at location (0, 20) on the
window.
The coordinate system begins from the top left corner as the
origin. So this text will begin at the left side of the window
and 20 units down (yes, an x-y coordinate system just like
we are used to, only the top of the screen is 0 and you count
up to go down!)
You should now take a few moments and play! Change the text, and
change the x and y coordinates. Try to place the text in the center of the
window - what does this teach you about the window dimensions? If you
are on the software, switch between Computer and HandHeld views -
you will see that, centering for one does NOT center for the other!
Pause for breath before continuing.
But Why?
It is perhaps timely to stop for a moment and ask - Why bother? There
are much easier ways to put text on a screen.
Two very important properties of a Lua window on TI-Nspire as opposed

to say, the same thing displayed using Notes:
Click anywhere on this image to view a short video demonstration
1. Click on any Lua-based
window. Drag around -
try and edit it. It is
secure. Any text you
display in such a
window CANNOT be
edited or changed by the
user of your document.
In Notes, of course, the
user can readily change -
and indeed break -
whatever the author has
taken the time and care
to display there. AND,
just as we can in Notes,
the text we display can
be static or dynamic. So
we can easily create
powerful learning tools
just as we can with
Notes, but in a secure
display environment.
2. In the second part of this

lesson, you will learn
how to control the font
size, color and style, and
how to easily center text
on a line or, indeed, in
the center of the
window. In Lua we have
significant control over
the way our text is
displayed - much moreso
than using the native TI-
Nspire text facilities. In
terms of color, you have
ready access to millions
of colors, and size is
similarly unrestricted.
Take a moment to watch
the short demonstration
video to the right,
"Derive the quadratic
formula". It illustrates
some of the possibilities
for using Lua.
Lesson 1.2: A Little More Interesting?
So, back to work. Are you ready for a little

more?
Click anywhere on this image for a video
If you are not on page 1.2, return to that page. demonstration
We will add a couple of lines to our on.paint
script.
gc:setFont("sansserif", "b", 12)
gc:setColorRGB(158, 5, 8)
gc:drawString("This is my text", 20, 20)
end
Once again, study these new commands and see what they do - have a
play and try different values. You will quickly appreciate
that setFont takes three inputs (family ("serif" or "sanserif"), style ("b"
for bold, "r" for regular, "i" for italic, or "bi" for bold italic) and, of course,
size).
setColorRGB is a simple way to access lots of colors: RGB stands for

Red, Green, Blue, where red is (255, 0, 0), Green is (0, 255, 0) and Blue
(0, 0, 255). Clearly there are many colors in between and you can play
around with numbers or, like me, you can go access lists online or just
download the PDF that I use. My trusted color consultant advises me
that burgundy (158, 5, 8) and navy (20, 20, 138) work very well
together! And so much nicer than just a palette of 9 to 15 colors as
currently available within TI-Nspire!
If you are still with us, then you are doing very well in your first steps
with Lua. We will finish this first lesson by learning how to center that
text, and in doing so introduce the important idea of local and global
variables. In this case, we learn that Lua supplies all sort of useful
commands, such
as platform.window:height() and platform.window:width(). As the names
suggest, these commands may be used to deliver to you the values for
the current window. If we define these as variables, like w and h, then we
can do some simple calculations to determine the best place to put our
text! We will define these variables as local, but by placing them outside
any functions, they are available to the entire script. Notice we can even
define a variable name, like "screen" to replace the more bulky
"platform.window"? Makes more sense to me...
We introduce two more Lua commands as well: getStringWidth and

getStringHeight. These should also be self-explanatory. Return to page
1.2 in Notes.
local screen = platform.window
local h=screen:height()
Click anywhere on this image for a video demonstration
local w=screen:width()
gc:setFont("sansserif", "b", 12)
gc:setColorRGB(158, 5, 8)
local sw
= gc:getStringWidth("This is
my text")
local sh
= gc:getStringHeight("This is
my text")
gc:drawString("This is my text",
w/2 - sw/2, h/2 + sh/2)
end
So we define width and height as simple local variables, w and h. We can

also get the string dimensions. Then to center the string horizontally,
take the middle of the window (w/2) then go back by half the length of
the string (w/2 - sw/2). Vertically the same, except that remember we
count backwards in Lua - down is greater, up is less!
What Now?
That is all for lesson 1 - your turn to play!
Why not try to align your text to the right? Have a look at the centering
that was just done and think about how that approach might be used for
left and right alignment.
How about placing your text at the top of the page - or down the
bottom?
Try some different colors - go wild!
In the next lesson, we learn how to make this text start to come alive,
and how to use a table to organize multiple lines of text nicely laid out
on your page!
Home TI-Nspire Authoring TI-Nspire Scripting HQ Scripting Tutorial - Lesson 1

Scripting Tutorial - Leccin 18: Consejos y trucos III
Aadiendo su propio men
Con gracias a Marc Garneau y Andy Kemp
La opcin de aadir sus propios mens personalizados ofrece una

funcionalidad bastante significativo a los documentos Lua (aunque se
advirti que este tipo de mens no sern visibles en el Reproductor de
Documentos).
En el ejemplo que se muestra aqu (en prstamo sin pudor de Marc y

Andy) hay dos tipos de objetos - positivos y negativos. Las opciones de
men permiten al usuario ajustar los colores para cada uno. Comenzar
por definir una funcin que realmente apoya esta eleccin. A
continuacin, el men de funcin se encarga de las definiciones. Por
ltimo, el toolpalette.register hace que la magia suceda!
choosecolour funcin (tipo, CLR)
Si tipo == "pos", entonces

poscolour = CLR
ms
negcolour = CLR
fin
Reiniciar()
platform.window: invalidar ( )
fin
menu = {
{ "Color positivo:",
{ "Amarillo", la funcin () ( "POS" "amarilla") final choosecolour},
{ "Rojo", la funcin () choosecolour ( "POS", "rojo") end},
{ "Azul", la funcin () choosecolour ( "POS", "azul") end},
{ "Negro", la funcin () choosecolour ( "POS", "negro") end},
{ "Verde", la funcin () choosecolour ( "POS", "verde") end},
{ "Blanca", la funcin () ( "POS" "blanco") final choosecolour},
},
{ "Color Negativo:",
{ "Rojo", la funcin () choosecolour ( "neg", "rojo") end},
{ "Amarillo", la funcin () ( "neg" "amarilla") final choosecolour},
{ "Azul", la funcin () choosecolour ( "neg", "azul") end},
{ "Negro", la funcin () ( "neg" "negro") final choosecolour},
{ "Verde", la funcin () choosecolour ( "neg", "verde") end},
{ "Blanca", la funcin () ( "neg" "blanco") final choosecolour},
},
}
toolpalette.register ( men)
Este fragmento de cdigo se puede colocar al final de la secuencia de

comandos, pero s asume que los diferentes colores se han definido,
probablemente, al principio, el uso de una tabla como la que sigue.
Color = {
rojo = {255, 0, 0},
naranja = {255, 165, 0},
amarillo = {255, 255, 0},
verde = {0, 255, 0},
azul = {0, 0, 255},
blanco = {255, 255, 255},
negro = {0, 0, 0},
paleblue = {200, 200, 240},
marino = {20, 20, 138},
marrn = {150, 50, 50},
gris = {120, 120, 120}
Haga clic en cualquier lugar de esta imagen para un

Este ejemplo de men se ilustra usando el vdeo de demostracin
documento de tejas de lgebra que
acompaa a esta leccin - con base en
ngulo recto a la excelente Entero adicin
de Marc y el documento de la resta.
Gracias a Marc por sealar a m que Andy

Kemp ha utilizado esta rutina de men de
una manera muy diferente en sus
documentos - y, por supuesto, gracias a
Andy por ser un genio. Ver de la
siguiente manera que las variables se
pueden definir muy claramente el uso de
este enfoque. Aqu, si la eleccin es de,
digamos 12 monedas, entonces sern
fijados mediante columnas de 3 y filas de
4. De este modo, los mens pueden ser un
verdadero ahorro de tiempo al variar las
secuencias de comandos.
menu = {
{ "monedas",
{ "1 moneda", la funcin () cols = 1 filas = monedas de 1 = 1 on.create () end},
{ "2 monedas", la funcin () cols = 1 filas = 2 monedas = 2 on.create () end},
{ "6 monedas", la funcin () cols = 3 filas = 3 = 6 monedas on.create () end},
{7 "monedas", la funcin () cols = 3 filas = 3 monedas = 7 on.create () end},
{ "8 monedas", la funcin () cols = 3 filas = 3 = 8 monedas on.create () end},
{ "10 monedas", () la funcin cols = 3 filas = 4 monedas = 10 on.create () end},
},
{"Acerca de",
{ "Acerca de", la funcin () = 1 sobre platform.window: invalidar () end},
},
}
Posiblemente incluso ms ordenado es spinner variaciones de Andy -

ntese el uso del men para llamar al enterkey accin?
menu = {
{"Modo",
{ "(S) Lento" modo, la funcin () = "lento" on.enterKey () end},
{ "Fast (f)", modo de funcin () = on.enterKey () end "rpida"},
{ "(V) muy rpido", la funcin () mode = "veryfast" fin on.enterKey ()},
},
{"Reiniciar",
{ "Reset (R)", la funcin () resetresults () end},
},
{"Acerca de",
{ "Acerca de", la funcin () = 1 sobre platform.window: invalidar () end},
Andy seala que no se puede tener un elemento de "nivel superior"

men - cada elemento del men debe residir en un sub-men, que es un
poco restrictiva, pero no hay problema real. Su otro consejo? Prestar
atencin a cerrar todos los corchetes y llaves, y ver sus comas!
Los siguientes dos clases representan un cambio de ritmo - la

consideracin de algunas pautas tiles para la creacin de documentos
consistentes y utilizables utilizando Lua en la plataforma de TI-Nspire.
Volver arriba
Scripting Tutorial - Leccin 21: Cajas (3.2) de texto y

entrada de texto enriquecido
Cuadros de texto y entrada de texto enriquecido (3.2)
Con el lanzamiento de TI-Nspire sistema operativo 3.2 viene una

seleccin de herramientas muy potentes y de gran utilidad. Lo ms
importante, ahora tenemos un editor de scripts Lua incorporado - mira al
final de la insercin de men. Esto finalmente hace scripting Lua
accesible a todas las personas interesadas para conseguirlo. Utilice
el Insertar men para insertar una secuencia de comandos en una
ventana Nspire, y tambin para editar un script existente. El Editor de
secuencias est disponible en todas las plataformas de software TI-
Nspire, excepto el de mano - para que los estudiantes no sern capaces
de acceder a los scripts en sus computadoras de mano. Pero seguro que
puede en su software de estudiante en el pas! Usted experimentar
este editor en la accin a medida que aprendemos acerca de algunas de
las grandes caractersticas 3.2 ya est disponible.
Con la primera de ellas (un editor 2D funcional) volvemos a los

fundamentos de scripting Lua: las primeras lecciones parecen tan hace
mucho tiempo, y por lo que podran tener problemas para recordar
mucho acerca de ellos. El tema principal en los primeros cinco clases
era el texto . Ponerlo en una pgina, el control de cmo y dnde
apareci, y aprender a aceptar la entrada de teclado para que los
estudiantes podran escribir las respuestas en sus
documentos. Recuerda?
Si bien nuestro entorno Lua en realidad siempre ha posedo un editor de
texto enriquecido 2D, hasta 3,2, lo que realmente no era muy
funcional. Se ha llegado ahora a su propia, y nos presenta una manera
perfecta para que los usuarios incorporen, no slo texto, pero la notacin
matemtica y qumica, as como algunos smbolos de geometra!
En lugar de pintar todo en la pantalla usando la funcin on.paint (y ser

responsable de todos los detalles de la apariencia y el diseo - que hizo
las cosas como fracciones desafiante), ahora podemos crear un cuadro
de texto en cualquier lugar de la pgina que funciona igual que un texto
cuadro que: se le permite escribir y editar texto, y cambiar el tamao y
otras caractersticas. De hecho, al igual que una pgina de Notas, puede
crear una operacin aritmtica (o una caja Chem) y tienen que ordenar a
cabo diseo y formato para usted.
Lo ms importante, podemos tomar cualquier texto que se introduce y

hacer cosas con ella.
Esas cosas incluyen decidir si la respuesta es la respuesta correcta a su

pregunta, o girando la entrada en una salida de matemtica, o incluso
buscar en el texto y cambiar partes de l si lo deseas.
Inicio rpido platform.apilevel = "2.0"
Parte superior de la pgina local de la pantalla = platform.window
Vamos a ver cmo las lneas de unos pocos local de la pantalla w =: anchura ()
que se necesita para obtener un cuadro de
local de h = pantalla: altura ()
texto en la pgina de funcionamiento. Nada
del otro mundo - que vendr un poco ms locales TBox = D2Editor.newRichText ()
tarde. Una cosa que usted notar que parece
bastante extrao en este punto es que en
realidad podemos conseguir cosas en nuestra
pgina - y funcional - sin ningn signo de funcin on.resize ()
una funcin de "on.paint"! Asombroso!
w = pantalla: anchura ()
En la parte superior de nuestro script - y de
todos nuestros scripts de ahora en adelante! - h = pantalla: altura ()
Es la APIlevel. Si la secuencia de comandos
utiliza OS 3.2 funcionalidad (como
on.construction), entonces se define como
TBox: move ( 0.05 * w, 0.05 * h)
platform.apilevel = "2.0". Guiones anteriores
fueron el nivel "1.0". Documentos que
incluyen por ejemplo la nueva
funcionalidad no se abrirn en versiones
anteriores a la 3.2. Nota bien: si el guin es
el nivel 2.0 a continuacin, los estudiantes
con un sistema operativo anterior incluso no
ser capaz de abrir el documento!
Comience por la creacin de las variables de

ventana para un fcil acceso cuando los
necesitamos - notar la tcnica sencilla de
cambiar la voluminosa "platform.window"
para la (para m) el buen "pantalla". Siempre
es una buena prctica para definir nuestras
variables como "local" siempre que sea TBox: cambiar el tamao ( 0,9 * w, 0,9 * h)
posible - mucho ms rpido y ms eficiente.
TBox: setFocus (verdadero)
Ahora la magia: se define un cuadro de texto
denominado "TBox". Esto slo necesita TBox: setText ( "Bienvenido a cuadros de texto!")
hacerse una vez, y as se puede producir
fuera de una funcin, si se desea. fin
El resto de comandos se encuentran dentro

de una funcin de "on.resize" para que las
llaman a la apertura de la pgina, y tambin
cuando se cambia el tamao (si es
compatible). El comando "mover" coloca
inicialmente la esquina superior izquierda de
la caja, "redimensionar" establece las
dimensiones. Podramos parar aqu y
tendramos un cuadro de texto de
funcionar. Ntese que hacerlo con sangra y
ligeramente ms pequea que la pgina de
modo que tenemos un poco de "espacio en
blanco" para facilitar la lectura?
Las dos ltimas lneas situar el cursor

parpadeante y colocar un poco de texto en el
cuadro. Fcil.
1. Configuracin del cuadro de texto platform.apilevel = "2.0"
Parte superior de la pgina

Ahora hacemos un trabajo ms completo. No local de la pantalla = platform.window
hay forma fcil de solucionar esto, as que
slo voy a derramar el cdigo en la pgina y local de la pantalla w =: anchura ()
trabajar desde all.
local de h = pantalla: altura ()
Esta vez yo uso "on.construction" y la vieja locales TextBox1

funcin "on.resize". El primero es nuevo en
3.2 y reemplaza "on.create" que nunca locales fontSize
utilizamos mucho, ya que tiende a ser un
poco fiable acerca de cundo se llamaba en
realidad. No hay tales problemas con
on.construction. Es la primera cosa que funcin on.construction ( )
sucede. Perodo. As que no van poniendo
todas las referencias de tamao de pgina en timer.start ( 0,4)
all, porque en realidad no es una pgina de
medir en este punto! Sin embargo, podemos TextBox1 = D2Editor.newRichText ( )
establecer las cosas que slo hay que hacer
fin
una vez. En este caso, esto es slo para crear
un nuevo cuadro de texto enriquecido (que
yo estoy llamando "TextBox1") y para iniciar
el temporizador, que se utiliza para actualizar funcin on.resize ( )
continuamente la pantalla.
w = pantalla: Ancho ( )
La funcin on.resize habitual se encarga
entonces de trazar las cosas de la pgina - y h = pantalla: altura ( )
la gestin de las cosas, siempre y cuando se
cambia el tamao de esa pgina. Como TextBox1: move ( w * 0,05, 0,5 h *)
siempre, incluso si no mostrar la pgina, esto
TextBox1: cambiar el tamao ( w * 0,9, 0,4 h *)
se llama una vez, antes de que algo est
pintado para la pantalla. As que este es un fontSize = Math.floor ( W / 32)
buen lugar para poner esas cosas que
necesitan refrescarse si los cambios de fontSize = fontSize> 6 y 7 o fontSize
pgina.
TextBox1: setFontSize ( fontSize)
Tambin he descubierto un nuevo favorito -
"on.getFocus". Esto lo hace bastante ms de TextBox1: setBorderColor ( 500)
lo que dice - por lo que cuando regrese a esta
pgina, que va a hacer lo que te pidamos que TextBox1: setBorder ( 1)
- en este caso, para poner el foco en el cuadro
de texto para que el usuario puede comenzar TextBox1: SetTextColor ( 200 * 200 * 200)
a escribir inmediatamente.
TextBox1: setFocus ( verdadera)
Asi que... fin
Copia el cdigo de la derecha, crear un

nuevo documento, insertar una pgina de
guin, pasta y luego Conjunto de secuencias
de comandos (o slo Ctrl-S como si estuviera funcionar on.getFocus ( )
"salvar") para ver lo que est pasando
aqu. Debe obtener una pgina con un cuadro TextBox1: setFocus ( )
de texto activo en la mitad inferior. Escriba
algo en, a continuacin, insertar una nueva fin
pgina Notas. En un MathBox, tipo "entrada"
y pulse Enter - usted debe ver su texto!
En otras palabras, hemos creado un cuadro funcin on.timer ( )

de texto en vivo, que sabe lo que se est cursor.show ( )
escribiendo en l! Y todo ello sin una funcin
on.paint! Entrada = TextBox1: getExpression ( )
Los diversos comandos son bastante explica si la Entrada a continuacin,

por s mismo - al menos si ha trabajado a
travs de las 20 clases anteriores! El cuadro var.store ( "entrada", entrada)
de texto se crea por
la D2Editor.newRichText () de comandos, fin
se posiciona utilizando TextBox1:
Pantalla: invalidar ( )
movimiento (W * 0.05, H * 0,5) y el valor
se expresa por TextBox1: cambiar el
fin
tamao (W * 0,9, H * 0,4) .
Juega un poco con los distintos comandos y

valores para ver sus efectos. Ver que la funcin on.escapeKey ( )
verdadera magia est ocurriendo aqu en
la on.timer funcin donde todo lo que se TextBox1: setExpression ( "")
escribe en el cuadro se agarr y le asigna un
nombre de variable. Esta es la parte ms Pantalla: invalidar ( )
poderosa. He aadido una funcin
ESCAPEKEY que borra el cuadro de texto - fin
estudiarlo y ver cmo se hace eso. Este es un
comando muy importante!
2. Jugando con texto
Parte superior de la pgina
Y ahora un poco de diversin!

Un reto para
empezar. Crear un
segundo cuadro de texto
y organizar los dos
cuadros de la pgina
para que uno se
encuentra por encima de
la otra, como se
muestra. Si tiene
problemas, consulte los
archivos script_tut21.tns
en las Descargas de esta
pgina.
Ahora me gustara que,

en un principio, todo lo
que se teclea en el
cuadro de arriba a
aparecer en la parte
inferior.
Estudiar el cdigo -
especialmente
el on.timer funcin. Pu
edes ver que todo lo que
tenemos que hacer es
aadir la
lnea TextBox2:
setExpression
(entrada) despus de
que nos hemos
asegurado de que
realmente existe de
entrada? (Tenga en
cuenta que los
trminos getText y getE
xpression ,
y setText y setExpressi
on se consideran
intercambiables)
As que ahora
reemplazar esta lnea
con: TextBox2:
setExpression ( "\\
1keyword" ..Input) y
ver qu pasa. El
comando "\\
1keyword" es uno de
los pocos comandos
interesantes disponibles
para jugar aqu - como
se ve, el efecto es tomar
la siguiente palabra y
para que sea negrita .
Una palabra de
precaucin al utilizar
estos comandos estilo
de texto: no hay
ninguna garanta de que
no va a cambiar en
futuras actualizaciones
del sistema
operativo! As que tal
vez evitar el uso de ellos
en nada crtico, ya que
puede no funcionar
como se espera en el
futuro.
El crdito por el
descubrimiento de estos
comandos no
documentados
maravillosos va al
equipo de Inspired-
Lua . Muchas gracias a
Jeremy y Adrien de
todos sus esfuerzos
para ayudar a aquellos
de nosotros aprender a
hacer el mejor uso de
Lua en la TI-Nspire!
La lista de estos comandos de formato

incluye estilos como negrita (palabra clave) funcin bastante (entrada)
y cursiva (subttulo), as como algunos
smbolos agradable de geometra, como entrada = entrada: gsub ( "crculo", "\\ 1circle")
disponibles en la aplicacin Notas.
entrada = entrada: gsub ( "tringulo", "\\ 1tri")
Tales comandos podran ser utilizados en una
variedad de maneras. Por ejemplo, usted entrada = entrada: gsub ( "ngulo", "\\ 1angle")
podra buscar apariciones de la palabra
entrada = entrada: gsub ( "rayo", "\\ 1Ray")
"crculo" y sustituirlos de forma automtica
con el smbolo! entrada = entrada: gsub ( "lnea", "\\ 1Line ')
En el ejemplo que he creado, he tomado de entrada = entrada: gsub ( "segmento", "\\ 1lineseg")
secuencias de comandos HTML, por lo que
este tipo de comandos especiales se definen entrada = entrada: gsub ( "RTRI:", "\\ 1rtri")
de una manera particular (en este caso,
seguido de dos puntos). Cuando descubrieron entrada = entrada: gsub ( "vector", "\\ 1vector")
que llevan a cabo su funcin definida, ya sea
insertando un smbolo (crculo, tringulo) o entrada = entrada: gsub ( "u", "\\ 1title")
la creacin de la notacin especial para
entrada = entrada: gsub ( "b", "\\ 1keyword")
rayos, o lnea, o la mejora de la siguiente
palabra. Copiar y pegar la funcin en su
entrada = entrada: gsub ( "sup", "\\ 1supersc")
pgina, y luego simplemente hacer un
cambio a la lnea que ha introducido entrada = entrada: gsub ( "sub", "\\ 1subscrp")
previamente en la funcin de
temporizador: TextBox2: setText (bastante) entrada = entrada: gsub ( "i", "\\ 1subhead")
(entrada) . Luego probar sus nuevos talentos
de copiar y pegar el siguiente texto en
TextBox 1:
regresar de entrada
u: Subrayado se pueden mezclar con b:
negrita, i: cursiva y sup: superndice con fin
substitucin: subndice. b: los smbolos de
la geometra del tringulo incluyen: ABC,
crculo: P, RTRI: ABC, lnea lnea: AB,
segmento segmento: AB y Ray Ray: AB y
el vector vector: ABC.
Usted se dar cuenta, si usted est en la

mano, que es posible que tenga que ajustar el
tamao de fuente para ver todo el texto se
pega en Cuadro de texto 1. Esto se hace
fcilmente en OS 3.2. Pero no es posible
desplazarse o para ajustar el tamao de
fuente en el segundo cuadro, ya que no es
una caja "en vivo" de la misma manera que la
caja 1 es. Depende de lo que se teclee
anteriormente, y as se debe tener cuidado al
configurar la pgina hacia arriba en cuanto al
tamao de la fuente para una visualizacin
ptima.
Piense en las aplicaciones aqu. El uso de un procedimiento de este tipo,

una tarea de evaluacin podra ser fcilmente creada en el que las
palabras clave se buscan y, si se identifica, puede obtener crdito. De
hecho, el cuadro podra ser configurado de forma que cuando ciertas
palabras clave se escriben, que al instante se resaltan en negrita o
cursiva, dibujo de los ojos y la atencin del alumno.
En nuestra siguiente leccin continuamos explorando las posibilidades

de estos cuadros de texto enriquecido, y aprender cmo crear nuestras
propias cajas de matemticas dinmico y Chem.
Volver arriba
Scripting Tutorial - Leccin 16: Consejos y trucos I
Afterthoughts
Por lo tanto, dnde desde aqu?

Obviamente, el cielo es el lmite. Depende de su propia imaginacin y,
tal vez, necesidad ocasional de sueo?
Hay mucho ms que aprender, y es de esperar la puesta a tierra que ha

recibido aqu puede dotar a buscar respuestas en los lugares ms
formales, mezclndolo con los programadores "reales", tal vez? Por
supuesto que debe visitar (y tal vez incluso contribuir a) la Lua nspired
Wiki , mantenida por todo tipo de personas interesantes e inteligentes.
Usted realmente debe ver algunos de los excelentes tutoriales

en nspired Lua , y encontrar algunos ejemplos preciosos a buenos
viejos archivos TI-Calc.org Lua .
Pero sigue siendo un par de cosas que me gustara cubrir aqu que no
subiese o no fueron adecuadamente cubierto en las lecciones 1 - 15, por
lo que colgar en l slo un poco ms de tiempo.
Las tres primeras notas vienen de mi eminente gur de Lua, John

Powers de TI, que ha sido en gran parte responsable del desarrollo de
Lua para nuestra plataforma.
Encontrar
Si quieres saber si una cadena contiene una subcadena, y donde la
subcadena es, a continuacin, utilizar encontrar . Se devuelve dos
nmeros, de inicio y fin, ndices de inicio y final de la primera
coincidencia. Devuelve nil si la subcadena no est contenida en la
cadena. El mtodo de bsqueda tiene un patrn de capacidad de
adaptacin verstil que es posible que desee comprobar hacia fuera. Por
ejemplo str: encontrar ( "% b ()") devuelve el comienzo y el final de
los ndices del primer conjunto de parntesis equilibrados que
encuentra.
frmula = "2 * (3 + (4 + 5))"
frmula: encontrar ( "% b ()") devuelve 3, 11.
Reemplazar
Si desea reemplazar la subcadena por otra cadena, usar algo como:
= cadena-nueva oldstring: gsub ( "=", "->")
Esto devuelve una nueva cadena con todas las ocurrencias de "="
sustituye con "->". Si desea slo la primera aparicin para ser sustituido,
llame oldstring: gsub ( "=", "->", 1). Si no se encuentra ninguna
ocurrencia de la subcadena, la cadena de entrada original se devuelve
sin cambios. El mtodo gsub utiliza el mismo patrn de coincidencia
instalacin como hallazgo.
Para una buena aplicacin de esto, qu pasa con una funcin de

"impresin bonita" que reemplaza fea "^ 2" y "3 ^" con el mucho ms
agradable " 2 " y " 3 " (y algunos otros) en las expresiones introducidas?
NOTA de que ciertos smbolos comunes, como el "^" y "+" son

parte de definiciones de patrones de Lua. Usando el "%" hace
caso omiso de esto y simplemente usa lo que sigue.
Estudiar la funcin que sigue y ver lo que logra cada lnea - esto sera
convertir una cuadrtica como "-1x ^ 2 + + -0x -4" en "-x 2 -4". (Para
una funcin Bastante ms completa, descargar y estudiar cualquiera de
los documentos adjuntos, pretty.tns o pretty.lua)
funcin bastante (entrada) Haga clic en cualquier lugar de esta imagen para un
vdeo de demostracin
entrada = toString ( entrada)
entrada = entrada: gsub ( "% +% -",

"-")
entrada = entrada: gsub ( "0x% ^ 2%

+", "")
entrada = entrada: gsub ( "0x% ^ 2%

-", "")
entrada = entrada: gsub ( "0x% +",

"")
entrada = entrada: gsub ( "0 x% -",

"")
entrada = entrada: gsub ( "% + 0", "")

entrada = entrada: gsub ( "% -0", "")
entrada = entrada: gsub ( "1x", "x")
entrada = entrada: gsub ( "% ^ 2",

" 2 ")
regresar de entrada
fin
Divisin
Si desea dividir una cadena en las partes antes y despus del signo
igual, usar algo como:
piezas = ecuacin: Split ( "=")
izquierda = partes [1]
derecha = partes [2]
Se poda hacerlo todo en un estado de cuenta con:
izquierda, derecha = desempaquetado ( ecuacin: split ( "="))
Volver arriba
Continuar su exploracin de la funcionalidad Lua an ms potente y til

en la leccin 17 , donde cubrimos el math.eval funcin, que permite
Lua para llegar al otro lado y hacer uso de la funcionalidad de TI-Nspire!
Scripting Tutorial - Leccin 7: Inicio rpido: Trabajar con

imgenes
Muchas, muchas gracias a Adrien Bertrand por su ayuda en la

preparacin de esta leccin - que proporcionan asesoramiento
oportuno para hacer de este un mejor tutorial y me ayud a
encontrar mi fuera de la maraa que me he metido!
Lua tiene comandos muy simples pero poderosas de manipulacin de

imgenes, por lo que es fcil importar imgenes en su documento Lua y
utilizarlas para "jugar" con estos. Mientras TI-Nspire 3.0 es compatible
con la insercin de imgenes en documentos de TI-Nspire, no existen
todava hay opciones para interactuar con stos - hacindolos cambiar el
tamao, o incluso aparecer y desaparecer sobre la marcha. Esta
funcionalidad est disponible mediante Lua.
Leccin 7.1: creacin y visualizacin de su imagen
Antes de APIlevel 2.3, las imgenes se introdujeron directamente en una

secuencia de comandos como una cadena convertida. Estos tienden a
ser largo y la memoria costoso, especialmente si la imagen se utiliza
ms de una vez dentro de un documento.
A partir de APIlevel 2.3, las imgenes se tratan como

documentos recursos - que puede o no puede haber notado que la
seccin inferior del-Nspire TI Script Editor consta de varias fichas: la
consola (donde autores de scripts pasan la mayor parte fo su tiempo),
Globals, pila de llamadas, locales y los recursos. En este momento, los
nicos recursos de los cuales handhels editor de scripts son
imgenes. La mayora de los formatos de imagen comunes son
compatibles (JPG, PNG, TIFF, ...). Basta con hacer clic en el botn "+",
busque la imagen para ser insertado (aqu usamos imgenes llamadas
bridge1, bridge2, Bridge3 - todos son archivos JPEG), y darle un nombre
para esa imagen dentro de la secuencia de comandos - se puede elegir
si desea conservar el original nombrar o darle una nueva.
Una vez insertada la imagen, se debe definir dentro de la secuencia de

comandos, como se muestra. Tenga en cuenta el formato para la gestin
de recursos: el nombre de la imagen es precedido por "_R.IMG.".
bridge1 = image.new (_R.IMG.bridge1)
NOTA: A pesar de que debe volver a introducir imgenes cada vez que
se requieren para un nuevo guin / pgina, slo una nica copia de esa
imagen se almacena dentro del documento! Esto reduce el tamao
general del documento de manera significativa en comparacin con el
mtodo anterior, donde se repitieron las cadenas largas de la imagen en
cada secuencia de comandos. Tan comnmente utilizados repetidas
imgenes (imgenes de los botones, por ejemplo) deben volver a
introducir en la ficha Recursos cada vez que se usan, sino que se
almacenan slo una vez en un documento.
Ahora todo lo que tenemos que hacer es decir la secuencia de comandos

para "pintar" la imagen de la pantalla, utilizando el ya
familiar on.paint funcin, junto con la simple drawImage comando. Si
hemos definido la imagen como una variable llamada bridge1 , a
continuacin, se presentan se consigue utilizando el cdigo que se
muestra aqu:
funcin on.paint ( GC)
GC: drawImage ( bridge1, 0, 0)
fin
Eso es en realidad el trabajo pesado hecho. Todo lo dems se basa en

lecciones anteriores para "ajustar" nuestra visualizacin de la imagen -
para asegurar que se ajusta a la ventana, por ejemplo, para centrarla en
esa ventana, e incluso para controlar la escala y cambiar dinmicamente
las imgenes!
Me gustara sealar que el enfoque utilizado aqu no es el ms eficiente,

pero es slo un punto de partida adecuado. Usted podr observar en las
secuencias de comandos que se sigue que el comando image.copy se
utiliza dentro de una funcin on.paint. Para las grandes imgenes o
varias imgenes, es probable que esto ralentizar el rendimiento, sobre
todo en el dispositivo porttil. Sin embargo, para los casos simples,
como los que se muestran aqu, ser suficiente. El mejor enfoque
consiste en vincular el comando de copia para el caso de que lo activa -
on.resize, o on.arrowKey, o on.varChange. Estos enfoques no se incluyen
en esta etapa.
Leccin 7.2: Montaje de nuestra imagen a la ventana

Nos encontramos con los comandos de la ventana de dimensin camino de vuelta en el tutorial 1: platform.w
imagen en la ventana, junto con los comandos de dimensiones equivalentes para imgenes: image.width ( ima
Nota en particular la forma en que la imagen se centra en la ventana.
Esto es grande si nuestra imagen se ajusta razonablemente bien a la ventana. Pero lo que si es demasiado gran
El mtodo ms simple aqu es obligar a la imagen para que quepa dentro de sus dimensiones de la pantalla: he
fcilmente en este espacio: image = Imagen : copia (w, h) crear una copia de la imagen que se ajuste exacta
Observamos que hacemos esto dentro de la escala on.resize funcin, en lugar de la on.paint funcin. La funci
cambio de tamao se llama una vez cuando la pgina est configurado, y solo cuando cambia de tamao (que
imagen puede tener un impacto en el rendimiento, especialmente en la computadora de mano y de imgenes d
Leccin 7.3: Hacer que nuestro tamao de imagen Dinmico
Hasta aqu todo bien. Usted podra parar aqu y ser capaz de insertar una imagen y jugar con la escala hasta qu
Estudiar el cdigo opuesto.
La definicin de las variables utilizadas en general (variables "globales") como local para el guin es realment
carga el guin.
La funcin de cambio de tamao tambin se denomina generalmente slo una vez, por lo que este es un buen l
como un restablecimiento funcin). Si las dimensiones de la imagen son diferentes de las de la pantalla, esto p
pantalla, y la altura de la imagen como la mitad de la altura de la pantalla.
A continuacin, defina una funcin "Cambiar la escala", que se puede llamar como sea necesario. Se define un
que esta funcin toma como argumentos la imagen que se reajustarn, y el valor actual de la escala. Tambin i
Observe, tambin, que nuestra funcin "reescalar" incluye una pantalla: invalidar () de comandos, as que e
Este script va a funcionar bien en la unidad TI-Nspire, y en el software de escritorio, pero qu pasa con el iPa
Una solucin sencilla es aadir un control deslizante, y utilizar esta variable para cambiar nuestra escala.
Para aadir esta caracterstica, tenemos que hacer dos cambios en nuestra secuencia de comandos:
1. Tenemos que "escuchar" a los cambios en la variable de control deslizante (que llamaremos "escala").
2. Tenemos que enviar nuestras flechas cambios clave para el control deslizante.
Para detectar un cambio en una variable Nspire, utilizamos var.monitor y on.varChange () . La primera de es
vamos a agarrar el nuevo valor de escala utilizando var.recall y utilizarlo para establecer el valor actual de am
Tambin tiene sentido tener arrowkey cambios en nuestro guin reflejan en cambios en la variable fuera (y su
utilizando var.store .
Ahora se puede controlar la escala utilizando las teclas de flecha arriba y

abajo o un deslizador!
Leccin 7.4: Intercambio de imgenes sobre la marcha
Nuestro truco final es definir varias imgenes y utilice las teclas de flecha izquierda y derecha para cambiar en
Como acabamos de hacer de la escala, definimos las teclas de flecha izquierda y derecha para incrementar los
Tambin puede crear una variable de control deslizante, llamado elegir en una ventana de geometra, y estable
Felicitaciones! Ahora tiene todos los ingredientes que necesita para digitalizar, definir, insertar, escala y mani
Leccin 7.5: Adicin de imgenes mltiples - la manera fcil
Si tiene varias imgenes para aadir a su documento, no es una manera rpida y fcil de hacer esto. Supongam
bridge2.jpg y bridge3.jpg en una carpeta llamada, por ejemplo, script7. En mi Mac, coloqu esta carpeta en la
Crear una hoja de clculo de Excel y en la columna A, escriba los nombres de cada imagen (sin el sufijo): por
celda A2 y A3 est en Bridge3.
Columna B tiene el nombre de ruta para cada imagen. En el Mac, esto va a tomar la forma de:
/Users/Steve/Pictures/script7/bridge1.jpg, Y as sucesivamente (como se muestra). El nombre de ruta para los
Guarde este documento en formato CSV (valores separados por comas) y ahora vamos a la pestaa Recursos d
lugar de aadir un archivo de imagen, aadir la hoja de clculo y las tres imgenes se aadirn al instante!
Una hoja de clculo preparada y las imgenes adjuntas para este tutorial se incluye dentro del archivo comprim
Leccin 7.6: El control de la posicin de la imagen
Qu pasa si desea mover la

imagen alrededor de la
pantalla? Mientras que esto
puede hacerse completamente
dentro de Lua usando los
comandos de direccin como se
describe anteriormente, otra
opcin ordenada podra ser la de
dividir la ventana, colocar una
ventana de grficos por debajo,
y el control de la imagen
moviendo un punto alrededor de
la ventana de grficos. Para ello,
almacenar las direcciones x e y
coordenadas del punto
(dicen px y py ) y luego las
utilizan con sus comandos de
flecha en Lua para mover la
imagen.
Esto se demuestra en
la shuttlecock.tns archivo que
se incluye con descargas de esta
leccin. Incluya tambin se
encuentra la imagen que se
utiliza y la secuencia de
comandos Lua para su
estudio. En el problema 2 de
este archivo TNS, el punto P
est vinculada a una parbola de
modo que el movimiento del
volante puede ser modelado e
incluso animado!
A continuacin se aprende cmo utilizar propias capacidades grficas de

Lua para crear nuestras propias imgenes.

Scripting Tutorial - Leccin 9: los nmeros de figura
grficas
Es el momento de tratar de poner juntos todo lo que hemos aprendido

hasta ahora. En esta leccin y leccin 10 vamos a utilizar los comandos
grficos de Lua, junto con muchas de las mejoras que hemos aprendido
para crear documentos que son a la vez til, clara y fcil de usar. Vamos
a empezar con la visualizacin grfica de los nmeros de forma -
cuadrado, rectangular y nmeros triangulares.
Tmese un momento para ver la Haga clic en cualquier lugar de esta imagen para un vdeo de
pelcula de acompaamiento y demostracin
luego tener un juego con este
documento usando el
reproductor para tener una idea
de las posibilidades y de algunas
de las opciones de diseo que se
han hecho. Por ejemplo, si bien
es grande utilizar las teclas de
flecha y entrar, escapar e incluso
teclas de ficha para hacer el
control tanto por equipo y mano
de forma sencilla, si queremos
que nuestros documentos que
puedan utilizar con el jugador
entonces vale la pena salir de las
correderas.
En el ejemplo mostrado,
presionando flechas arriba y
abajo controla el valor de n ,
aumentando y disminuyendo el
nmero en estudio. Las flechas
izquierda y derecha muestran
las tres opciones - cuadrada,
rectangular y nmeros
triangulares. Presionando enter
muestra diferentes puntos de
vista - la forma creada usando
crculos, con un borde, y el uso
de las plazas. Por ltimo,
presionando los pasos clave de
la ficha a travs de la
construccin de ese modelo, por
lo que es fcil de ver las
relaciones implicadas - nmeros
cuadrados son las sumas de los
nmeros impares, nmeros
rectangulares, la suma de los
nmeros pares, y porque cada
rectngulo es el doble de la
correspondiente tringulo , los
nmeros triangulares se
construyen mediante la adicin
de los nmeros
contables. Presionando escape
le lleva de vuelta a travs de
esta progresin.
Leccin 9.1: Creacin de un patrn de cuadrcula
Vamos a empezar por el uso local de la pantalla = platform.window

de drawLine para crear una cuadrcula
correspondiente al valor actual funcin drawArray (nmero, x, y, longitud,
de n . Pero en primer lugar, algunas altura, GC)
consideraciones prcticas - planificar su
diseo y el diseo! Nos gustara que para k = 0, el nmero de hacer
nuestra red para mentir centra en la
pgina. Sabemos cmo hacerlo. Pero para m = 0, el nmero de hacer
tambin nos gustara que si el tamao de
nuestra red se mantuvo dentro de la GC: drawLine (
pgina visible, con un poco de espacio en
blanco alrededor de ella. As podramos x,
dividir el ancho y la altura de la pgina
hacia arriba por el valor de n (y un poco y + m * altura,
ms de espacio en blanco). Tambin se
necesita un control deslizante para n (y x + longitud del nmero *,
ms controles deslizantes para
seguir!). As configurar una pgina de y + m * altura )
separacin con una ventana de geometra
y deslizante en un lado y nuestra ventana
de instrucciones para la ventana
principal. GC: drawLine (
Mirar de cerca el cdigo aqu. Definimos x + k * longitud,

una funcin ( drawArray ) que toma
como sus argumentos el valor actual Y,
de n , la coordenadas X e Y de la
posicin de partida, y la longitud y la x + k * longitud,
anchura de cada celda.
altura y + * Nmero )
Usted ver que el drawLine funcin
toma cuatro argumentos: las coordenadas fin
X e Y de los puntos de inicio y
fin. Vamos a utilizar una variable (m) fin
para definir las lneas horizontales y el
otro (k) para las lneas verticales. Una fin
vez ms, estudiar el cdigo
proporcionado para ver una forma en que
para lograr lo que deseamos.
Una vez que se define la funcin,

tenemos que pintar la pantalla para ver funcin on.paint (GC)
cmo se forma. Aqu elegimos para
definir las variables requeridas dentro de w = pantalla: anchura ()
la funcin on.paint. Por lo tanto
definimos el ancho y la altura de la h = pantalla: altura ()
ventana, recordamos el valor actual
de n y lo usamos para calcular las num = var.recall ( "n") o 1
coordenadas X e Y del punto de partida,
y la anchura y longitud de las xval = Math.floor ( w / (num + 4))
clulas. Para estos ltimos valores,
dividimos las dimensiones de la ventana yval = Math.floor ( h / (num + 4))
por el valor de n (y un poco ms), luego
tomar el valor entero ms bajo. Esto x = w / 2 - num * xval / 2
asegurar que nuestro modelo se
mantiene siempre dentro de las y = h / 2 - num * yval / 2
dimensiones de la pantalla. Por ltimo se
exponen los valores de la pluma y el
color y la llamamos nuestra
funcin, drawArray . GC: setPen ( "delgado", "suave")
Esto produce una rejilla cuadrada

dinmica, como se requiere, controlado
por el valor actual de una
variable n dentro de TI-Nspire.
GC: setColorRGB ( 165,42,42)
drawArray (num, x, y, xval, yval, GC)
fin
Leccin 9.2: Variacin de nuestro patrn de cuadrcula
As que tenemos una cuadrcula - nos funcin drawArray (nmero, x, y, longitud,

gustara tener dos variaciones sobre este altura, GC)
tema: una rejilla rectangular con un lado
(uno ms que el otro) y una malla tipos = (var.recall ( "tipo") o 1)
triangular. Vamos a controlar estos con
una variable de control deslizante que si los tipos == 1 a continuacin,
llamaremos tipo .
... (Como arriba)
En primer lugar, los nmeros
rectangulares: esencialmente la misma elseif tipos == 2 a continuacin,
secuencia de comandos como para los
nmeros de cuadrados, pero con una para k = 0, 1 + nmero de hacerlo
variable uno ms que el otro.
para m = 0, el nmero de hacer
Recuperar el valor de la variable tipo en
el inicio de nuestra drawArray funcin, GC: drawLine (
luego usarlo como la base de una prueba:
si el tipo de == 1 entonces (la rutina x,
cuadrado) elseif tipo == 2 a continuacin
(rectngulos) else (tringulos) final.
y + m * altura,
x + longitud * (nmero + 1),
y + m * altura)
GC: drawLine (
x + k * longitud,
Y,
El tringulo sigue - la variacin principal
x + k * longitud,
de las dos formas anteriores es que, en
lugar de la segunda funcionamiento
altura y + * nmero)
variable de 0 o 1, que comienza en el
valor actual de k, por lo tanto el
fin
sangrado de cada lnea para formar el
tringulo. Con el fin de cerrar la figura,
fin
que era necesario aadir una lnea
adicional en la parte superior y otra en el
fin
lado derecho - de ah las cuatro lneas en
este script donde los dems slo dos
tenan.
ms
GC: drawLine ( x, y, x + longitud * (nmero + 1)

- longitud, y)
GC: drawLine ( x + longitud * nmero, y, x +

longitud * nmero, altura y + * nmero)
Aadir la lnea que define la
variable tipos de tipo y la primera para k = 1, nmero de hacer
condicin (si tipos == 1 entonces) en el
inicio de la definicin de funcin, y este para m = k, el nmero do
guin entregar las tres formas dibujadas
usando una cuadrcula. GC: drawLine ( x + longitud * (m-1), y + altura *
m, x + longitud * nmero, altura y + * m)
GC: drawLine ( x + longitud * (k-1), y, x +
longitud * (k-1), y + k * altura)
fin
En el tutorial final de esta serie esta
secuencia de comandos se mejora an fin
ms el uso de los crculos para crear
dinmicamente cada uno de los patrones, fin
y ser aadido a nuestros controles de
tecla de flecha de costumbre.
Scripting Tutorial - Lesson 9: Graphical Shape Numbers
It is time to try and put together everything that we have learned so far.
In this lesson and lesson 10 we will use Lua's graphic commands along
with many of the enhancements we have learned to create documents
that are both useful, clear and easy to use. We will begin with the
graphical display of shape numbers - square, rectangular and triangular
numbers.
Take a moment to watch the
accompanying movie and then
have a play with this document
using the Player to get a feel for
the possibilities and for some of
the design choices that have
been made. For example, while
it is great to use arrow keys and
enter, escape and even tab keys
to make control by both
computer and handheld easy, if
we want our documents to be Click anywhere on this image for a video demonstration
usable with the Player then it is
worth leaving in the sliders.
In the example shown, pressing

up and down arrows controls the
value of n, increasing and
decreasing the number being
studied. Left and right arrows
show the three options - square,
rectangular and triangular
numbers. Pressing enter shows
different views - the shape
created using circles, with a
border, and using squares.
finally, pressing the tab key
steps through the building up of
that pattern, making it easy to
see the relationships involved -
square numbers are the sums of
odd numbers, rectangular
numbers the sum of even
numbers, and because every
rectangle is double the
corresponding triangle, the
triangular numbers are built by
adding the counting numbers.
Pressing escape takes you back
through this progression.
Lesson 9.1: Building a Grid Pattern
We will begin by using drawLine to local screen = platform.window
create a square grid corresponding to
the current value of n. But first, some function drawArray(number, x, y, length, height, gc)
practical considerations - plan your
design and layout! We would like our for k = 0, number do
grid to lie centered on the page. We
know how to do that. But we would for m = 0, number do
also like it if the size of our grid
gc:drawLine(
remained within the visible page,
with a bit of white space around it.
x,
So we could divide the width and
height of the page up by the value y + height * m,
of n (and a bit more for white space).
Will also need a slider for n (and x + length * number,
more sliders to follow!). So set up a
split page with a Geometry window y + height * m)
and slider on one side and our script
window for the main window.
Look closely at the code here. We gc:drawLine(

define a function (drawArray) that
x + length * k,
takes as its arguments the current
value of n, the x and y coordinates of
y,
the starting position, and the length
and width of each cell. x + length * k,
You will see that y + height * number)

the drawLine function takes four
arguments: the x and y coordinates of end
start and end points. We will use one
variable (m) to define the horizontal end
lines and the other (k) for the vertical
lines. Again, study the code provided end
to see one way in which to achieve
what we desire.
Once the function is defined, we need

to paint the screen to actually see it.
here we choose to define the required
variables within the on.paint function on.paint(gc)
function. Hence we define the
window width and height, recall the w = screen:width()
current value of n and use it to
calculate the x and y coordinates for h = screen:height()
the starting point, and the width and
num = var.recall("n") or 1
length of the cells. For the latter
values, we divide the window
xval = math.floor(w/(num+4))
dimensions by the value of n (and a
little more), then take the lowest yval = math.floor(h/(num+4))
integer value. This will ensure that
our model always remains within the x = w/2 - num * xval / 2
screen dimensions. Finally, we set the
color and the pen values and call our y = h/2 - num * yval / 2
function, drawArray.
This produces a dynamic square grid,

as required, controlled by the current gc:setPen("thin", "smooth")
value of a variable n within TI-
gc:setColorRGB(165,42,42)
Nspire.
drawArray(num, x, y, xval, yval, gc)
end
Lesson 9.2: Varying our Grid Pattern
So we have a square grid - we function drawArray(number, x, y, length, height, gc)
would like to have two variations
on this theme: a rectangular grid types=(var.recall("type") or 1)
(with one side one longer than the
other) and a triangular grid. We if types == 1 then
will control these with a slider
variable we will call type. ... (as above)
First, the rectangular numbers: elseif types == 2 then

essentially the same script as for
for k = 0, number + 1 do
the square numbers, but with one
variable one more than the other.
for m = 0, number do
Recall the value of
gc:drawLine(
variable type at the start of
our drawArray function, then use x,
it as the basis of a test: if type == 1
then (the square routine) elseif y + height * m,
type == 2 then (rectangles) else
(triangles) end. x + length * (number + 1),
y + height * m)
gc:drawLine(
x + length * k,
y,
The triangle follows - the main
variation from the two previous
x + length * k,
forms is that, instead of the second
variable running from 0 or 1, it y + height * number)
begins at the current value for k,
thus indenting each line to form end
the triangle. In order to close the
figure, it was necessary to add an end
additional line at top and another
at the right side - hence the four end
lines in this script where the others
had only two.
else
gc:drawLine(x, y, x + length * (number+1) - length, y )
gc:drawLine(x + length * number, y, x + length *

number, y + height * number)
for k = 1, number do
for m = k, number do
Add the line which defines the
variable types from type and the gc:drawLine(x + length*(m-1), y + height * m, x +
first condition (if types == 1 then) length * number, y + height * m)
at the start of the function
definition, and this script will gc:drawLine(x + length * (k-1), y, x + length * (k-1), y
deliver the three shapes drawn + height * k)
using a grid.
end
In the final tutorial in this
series this script is further end
enhanced using circles to
dynamically build each of the end
patterns, and our usual arrow key
controls will be added.
Scripting Tutorial - Lesson 11: Advanced: Introducing Classes

In lesson 9 and lesson 10 we created a workable document for

visualizing shape numbers. Like many of the documents before this, the
user controls the action using arrow keys, enter, escape and tab keys.
This sort of keyboard control works very well when using the handheld -
it can mean that there is no need for students to have to grab and drag
anything - they just start using arrow keys and the result is immediate.
We have already noted, however, that this approach is useless if the

document is intended for use with the Player. We have retained TI-Nspire
native sliders to support such use, but this writing of variables back and
forth between Lua and Nspire is probably not the most efficient way to
work in terms of performance and ease of use.
In fact, you might have noticed that a pretty important UI component

has been missing in our introduction to Lua to this point - how can we
use Lua to control and respond to mouse actions? Clearly, this is the
preferred way of operating when using a computer (as opposed to the
handheld). Wouldn't it be ideal if documents we developed were
actually able to be optimised for all platforms - supporting keyboard
control for easy handheld access, and also working with mouse
Click to see what
control for use with computers? As something of a bonus, if we no such a document
longer need Nspire sliders, then we probably no longer need to might look like
transfer variables and can work entirely within Lua, which must be a
simpler approach for most problems.
Click on the screen shot shown to view a short video of a document

created in this way. Then try it using the TI-Nspire Player by clicking
on the red button beneath the image.
In order to realize this goal, we need to move into the next level of
Lua scripting and introduce the important and powerful tool
of classes.
Back to Top
Lesson 11.2: A Class of its Own

We will begin with something a
little less ambitious.
Study the video opposite and have

a play with the document using the
Player. You will see that it is
simply two shapes which can be Click to see a short video demonstration
grabbed and dragged around using
the mouse - but these shapes can Click to Play
also be selected using TAB and
moved using the arrow keys.
The shapes, circle and square,

have been defined as classes. For
the moment, think of a class as
more or less a "super-function".
Just as we have used functions
previously to define all sorts of
useful things, that is what we will
do with our square and circle. But
the power of classes lies in the fact
that they bring with them some
useful bonus properties. For
example, an object defined in this
way knows where it is on the
screen, it knows whether it has
been selected or not, and what
color it is meant to be, along with
potentially much more. It can tell
if it contains another object or
coordinate position. Can you begin
to see how this could be useful?
Back to Top
Lesson 11.3: Class: init?
Begin by defining the empty class, Square. Square = class()
Next, the class must be initialized. The function Square:init(x, y, width, height)
various properties that this class is to possess
are defined here. Our class Square has self.x = x
position (x and y coordinates), dimensions
(width and height), color and the knowledge self.y = y
of whether it has been selected or not (this
will become clearer soon.) self.width = width or 20
If we are to control the position of our self.height = height or 20

Square with a mouse, then we need to know
self.color = Color.green
when we click inside the Square. This is
defined by the "contains" function. The
self.selected = false
function "contains" takes as input an ordered
pair (x, y) and returns a Boolean value true or end
false if the ordered pair falls within the
bounds of the Square.
Finally, we need to paint the Square to the

screen.
In the usual way, this will require graphics function Square:contains(x, y)

context commands (gc). The first defines the
color for this object, and an interesting local sw = self.width
approach is used here. At the beginning of
the script, color is defined as a table as local sh = self.height
follows:
return x >= self.x - sw/2 and x <= self.x +
Color = { sw/2 and
red = {0xFF, 0x00, 0x00}, y >= self.y - sh/2 and y <= self.y + sh/2
green = {0x00, 0xFF, 0x00}, end
Since the color of Square has already been

specified (in the init function),
the unpack command simply grabs the RGB
definition for green from the table, color. (In
more detail: The "unpack" function takes as
input a table and returns each table element function Square:paint(gc)
as multiple return values. "gc:setColorRGB"
gc:setColorRGB(unpack(self.color))
expects three parameters for red, green, and
blue, but Color.green is one value, a table of
gc:fillRect(self.x - self.width / 2, self.y -
three elements. "unpack" turns the elements
self.height / 2, self.width, self.height)
of the table into the three parameters
expected by setColorRGB.) if self.selected then
Draw the square in the usual way - notice the gc:setPen("medium","smooth")

"self" references used throughout these
definitions. This is a simple and effective gc:setColorRGB(0, 0, 0)
way for a class object to refer to its own
properties. gc:drawRect(self.x - self.width / 2, self.y -
Finally, a little routine that draws a black
border around the square IF it is selected. end
Neat.
end
Back to Top
So now how do we see this Square that we

have defined?
First, we need to actually call the function

Square along with some parameters.
Remember that the init routine required x
and y coordinates, width and height (even
Sq = Square(80, 80, 40, 40)
though these last will be the same for a
square).
Then all that remains is to use the

old on.paint(gc) function and to call the
paint routine that we have defined for this
class. We now have our square displayed. function on.paint(gc)
NOTE that it will, at present, just sit and look
at you - we have not scripted any instructions Sq:paint(gc)
to make things happen just yet.
end
Next we will learn how to make things
happen with it.
Scripting Tutorial - Leccin 11: Avanzado: Clases Introducing
En la leccin 9 y la leccin 10 creamos un documento viable para la

visualizacin de nmeros de forma. Al igual que muchos de los
documentos antes de esto, el usuario controla la accin usando las
teclas de flecha, entrar, salir y las teclas de tabulacin. Este tipo de
control de teclado funciona muy bien cuando se utiliza el dispositivo de
mano - puede significar que no hay necesidad para que los estudiantes
tienen que agarrar y arrastrar cualquier cosa - que acaba de empezar a
utilizar las teclas de flecha y el resultado es inmediato.
Ya hemos observado, sin embargo, que este enfoque es intil si el

documento est destinado para su uso con el jugador. Hemos
conservado TI-Nspire deslizadores nativos de soporte a dicho uso, pero
esta escritura de variables de ida y vuelta entre Lua y Nspire no es
probablemente la forma ms eficiente de trabajar en trminos de
rendimiento y facilidad de uso.
De hecho, es posible que haya Haga clic para ver qu tal documento podra ser
notado que un componente de similar
interfaz de usuario muy importante

Dele "click" para jugar
se ha perdido en nuestra
introduccin a Lua a este punto -
cmo podemos utilizar Lua para
controlar y responder a las
acciones del ratn? Claramente,
esta es la forma preferida de operar
cuando se utiliza un ordenador (en
oposicin a la computadora de
mano). No sera ideal si los
documentos que hemos
desarrollado eran realmente
capaces de ser optimizado para
todas las plataformas - apoyar el
control del teclado para el acceso
de mano fcil, y tambin trabajar
con el control del ratn para su uso
con ordenadores? Como una
especie de bonificacin, si es que
ya no necesitamos deslizadores
Nspire, entonces es probable que
ya no tenemos que transferir las
variables y pueden trabajar
enteramente dentro de Lua, que
debe ser un mtodo ms sencillo
para la mayora de los problemas.
Haga clic en la captura de pantalla

se muestra para ver un video corto
de un documento creado de esta
manera. A continuacin, intente
utilizar el reproductor de TI-Nspire
haciendo clic en el botn rojo
debajo de la imagen.
A fin de alcanzar este objetivo, es

necesario pasar a la siguiente nivel
de scripting Lua e introducir la
herramienta importante y poderosa
de clases .
Volver arriba
Leccin 11.2: Una clase de su propio

Vamos a empezar con algo un
poco menos ambicioso.
Estudiar el video opuesto y tener

un juego con el documento del uso
del reproductor. Usted ver que es
simplemente dos formas que puede
ser agarrado y arrastrado alrededor
de usar el ratn - pero estas formas Haga clic para ver un breve vdeo
tambin se pueden seleccionar
mediante TAB y moverse con las Dele "click" para jugar
teclas de flecha.
El formas, crculo y el cuadrado,

se han definido como clases . Por
el momento, pensar en una clase
como ms o menos un "super-
funcin". Al igual que hemos
utilizado anteriormente para
definir las funciones de todo tipo
de cosas tiles, eso es lo que
haremos con nuestra cuadrado y el
crculo. Pero el poder de las clases
radica en el hecho de que traen
consigo algunas propiedades tiles
de bonificacin. Por ejemplo, un
objeto definido de esta manera
sabe dnde se encuentra en la
pantalla, se sabe si se ha
seleccionado o no, y de qu color
est destinado a ser, adems de
potencialmente mucho ms. Se
puede decir si contiene otro objeto
o posicin de coordenadas. Se
puede empezar a ver cmo esto
podra ser til?
Volver arriba
Leccin 11.3: Clase: init?

Comenzar por definir la clase vaca, Square. Cuadrado = clase ( )
Despus, la clase debe ser inicializado. Las funcin de la plaza: init ( x, y, ancho, altura)
diversas propiedades que esta clase es poseer
se definen aqu. Nuestra clase Square tiene la self.x = x
posicin (coordenadas X e Y), las
dimensiones (anchura y altura), el color y el self.y = y
conocimiento de si se ha seleccionado o no
(esto quedar ms claro pronto.) self.width = anchura o 20
Si hemos de controlar la posicin de nuestro self.height = altura o 20

cuadrado con un ratn, entonces tenemos que
self.color = Color.green
saber cuando se hace clic en el interior de la
plaza. Esto se define por la funcin de
self.selected = false
"contiene". La funcin "contiene" toma como
entrada un par ordenado (x, y) y devuelve un fin
valor booleano verdadero o falso si el par
ordenado se encuentra dentro de los lmites
de la plaza.
Por ltimo, tenemos que pintar la plaza a la

pantalla.
Plaza de la funcin: contiene ( x, y)
En la forma habitual, esto requerir grficos
comandos de contexto (GC). La primera Local Sw = self.width
define el color para este objeto, y se usa un
enfoque interesante aqu. Al comienzo de la sh locales = self.height
secuencia de comandos, el color se define
como una tabla como sigue: volver x> = self.x - sw / 2 y x <= self.x +
sw / 2 y
Color = {
y> = self.y - sh / 2 ey <= self.y + sh / 2
rojo = {0xFF, 0x00, 0x00},
verde = {0x00, 0xFF, 0x00},
}
fin
Dado que ya se ha especificado el color de la
plaza (en la funcin init),
el desempaquetado de comandos
simplemente agarra la definicin del RGB
para el verde de la mesa, el color. (En ms
detalle: La funcin "desempaquetar" toma funcin de la plaza: pintura ( GC)
como entrada una tabla y devuelve cada
elemento de la tabla como mltiples valores GC: setColorRGB (desempaquetado
de retorno. "GC: setColorRGB" espera tres ( self.color))
parmetros para el rojo, verde y azul, pero
Color.green es un valor, una mesa de tres GC: fillRect ( self.x - self.width / 2, self.y -
elementos. "desempaquetar" convierte los self.height / 2, self.width, self.height)
elementos de la tabla en los tres parmetros
que espera setColorRGB.) si self.selected continuacin,
Dibujar el cuadrado de la forma habitual - GC: setPen ( "medio", "suave")

notar las referencias "propias" usados a lo
largo de estas definiciones. Esta es una GC: setColorRGB ( 0, 0, 0)
manera simple y eficaz para un objeto de
GC: drawRect ( self.x - self.width / 2, self.y -
clase para referirse a sus propias
propiedades.
fin
Por ltimo, una pequea rutina que dibuja un
borde negro alrededor de la plaza, si est
fin
activada. Ordenado.
Volver arriba
As que ahora cmo vemos esta Plaza que

hemos definido?
En primer lugar, tenemos que en realidad

llamar a la funcin Square junto con algunos
parmetros. Hay que recordar que la rutina Sq = cuadrado (80, 80, 40, 40)
de inicializacin requerido coordenadas x e
y, anchura y altura (a pesar de que estos
ltimos sern los mismos para un cuadrado).
Entonces todo lo que queda es usar la
vieja on.paint (GC) funcin y llamar a la
rutina de la pintura que hemos definido para
esta clase. Ahora tenemos nuestra plaza est
representada. NOTA que ser, en la funcin on.paint ( GC)
actualidad, slo sentarse y mirar a usted - no
hemos guin ninguna instruccin para que Sq: pintura ( GC)
las cosas suceden por el momento.
fin
A continuacin vamos a aprender a hacer las
cosas suceden con l.
Scripting Tutorial - Leccin 19: Directrices para Lua

nspired Autora I
TRABAJO travs de plataformas (Crear vez que el juego

en todas partes)
As que ahora va a crear sus propios documentos utilizando Lua y TI-

Nspire?
Ya sea profesionalmente o para sus propios estudiantes, es importante

que los documentos que cree ofrecen una experiencia ptima para el
usuario. Al final, la intencin principal es crear una experiencia de
aprendizaje eficaz, y esto no suceder si los problemas de diseo y
facilidad de uso quedan entre el usuario y el contenido de la leccin.
Las directrices que se describen en este y el siguiente tutorial se
proponen como consideraciones tiles que deben servir para asegurar
que sus documentos va a funcionar bien, donde quiera que se utilizan.
Las dos variables crticas que se describen aqu se refieren a la forma en

que los documentos presentes en las diversas plataformas de TI-Nspire
(diseo y visualizacin Consideraciones - Leccin 19) y problemas de
usabilidad ( Leccin 20 ) - la garanta de que el documento sea lo ms
fcil y eficaz para utilizar en el computadora de mano, ya que es en el
reproductor o en el software de escritorio - o en cualquier otro lugar!
1. Consideraciones de visualizacin: Lo atractivo est en todas

partes!
La consideracin primordial al crear documentos Lua Nspire es asegurar

que, si la visualizacin en modo porttil o un ordenador, ya sea en DVD,
PublishView u otras plataformas, que el documento escalas
correctamente y que la experiencia del usuario es eficaz. Una ventaja
clave en el uso de documentos Lua ms de los creados usando la
funcionalidad nativa de TI-Nspire reside en la garanta de potencial que,
correctamente secuencias de comandos, tales documentos leern y
presentes de manera efectiva en todos los puntos de vista posibles. A
pesar de los esfuerzos considerables en este sentido, las aplicaciones
nativas Nspire (especialmente de Grficos y Geometra) siguen siendo
difciles de controlar a este respecto.
El documento de Matemticas nspired de Arcos y Sectores ofrece una

buena ilustracin de este punto. Las dos primeras imgenes muestran
una pgina del archivo original: en primer lugar, en vista de mano
(agradable!) Y luego a la vista del ordenador (puaj!). Esto es seguido
por una conversin Lua de esta pgina (gracias a John Hanna!), De
nuevo en vista ordenador de mano y, a continuacin. La otra ventaja del
documento Lua es que el punto que se mueve alrededor de la
circunferencia del crculo se puede controlar simplemente pulsando las
teclas de direccin - no hay necesidad de flecha por la pantalla, tratando
de agarrar y mover los puntos en la mano, pero igualmente eficaz
utilizando el ratn del ordenador a la vista. Este ser el tema central de
la discusin adicional en la leccin 20 .
Hay una regla de oro fundamental: Todas las referencias de tamao y
posicin deben estar en relacin con el tamao de la pantalla. NUNCA
utilice los valores absolutos de posicin o tamao, incluso al principio,
ya que stos lo ms probable es excelente trabajo en una vista y mal en
otros.
1.1 relativa no absoluta
Esto se logra ms fcilmente mediante la definicin de las

variables para la anchura y la altura, como por ejemplo
W = platform.window: Ancho ( )
H = platform.window: altura ( )
variables de posicin y luego deben expresarse en trminos

de stos. Por ejemplo, la posicin inicial de un objeto podra
ser W / 2, H / 2 a centro en la pgina. Del mismo modo para
los tamaos (ver 1.3 y 1.4 ms adelante)
1.2 funcin on.resize ( )
Es ms eficaz si estas variables globales se definen dentro

de una funcin de on.resize para que se llaman cuando se
cambian las dimensiones de pgina. Esta rutina tambin se
llama cuando se crea la pgina, y por lo tanto es adecuado
como un lugar para definir los valores iniciales de las
variables y objetos.
La funcin de cambio de tamao se puede llamar fcilmente

en, por ejemplo, en ESCAPEKEY () o como resultado de
mouseDown dentro de un botn.
1.3 Tamaos objeto con respecto
La definicin de las dimensiones de los objetos simtricos,

tales como crculos y cuadrados se logra mejor mediante la
eleccin de cualquiera de W (platform.window: anchura) o H
(platform.window: altura) y ajustarse a este valor. As, por
ejemplo, la anchura y la altura inicial de un crculo o un
cuadrado podran ser ambos un valor relativo como W / 30.
1.4 Tamao de fuente relativa
El tamao de la fuente puede estar vinculado a un valor tal

que el ancho de pgina con el fin de asegurar que las
pantallas ms grandes mostrar el texto ms
grande. Tomando el ancho estndar de la ventana de mano
como 318 pxeles, entonces podramos definir una variable
fontSize = W / 32
y esto resultar en un tamao de fuente cerca de 10 en el
dispositivo porttil. El valor se redondea automticamente a
un nmero entero para su uso en el comando setFont, pero
el uso de la funcin de Math.floor se asegurar de que se
producir un valor entero (y la adicin de 0,5 asegura que el
valor es siempre ms cercano a la original). Hay un valor
mnimo de 6 de tamao de la fuente (y un mximo de
255). Con el fin de protegerse contra el primero, a
continuacin, una mejor definicin podra ser
fontSize = Math.floor ( W / 32 + 0,5)
fontSize = fontSize> = 6 y fontSize o 6
fontSize = fontSize <= 255 y 255 o fontSize
NOTA: Gracias a Andy Kemp por sealar que, si bien el

equipo puede manejar tamaos de fuente entre 6 y 255
puntos, el dispositivo de mano se limita a 7, 9, 10, 11, 12 y
24. El uso de los lmites anteriormente no causa ningn
problema en el dispositivo porttil (leer 6 como 7, y
cualquier cosa por encima de 24 conseguir tope) pero s
quiere decir que habr momentos en los que la pgina
aparecer de forma diferente en el dispositivo porttil de lo
que ser en otras plataformas.
Si desea tratar de garantizar la coherencia tanto como sea

posible, a continuacin, la siguiente sera la opcin ms
segura (pero ms limitado):
fontSize = Math.floor ( W / 32 + 0,5)
Destinado 1.5 Tamao de pgina - Otro enfoque
Con agradecimiento a Alfredo Rodrguez
Los mtodos descritos anteriormente son probablemente la

forma ms sencilla de garantizar que el documento se escala
bien para distintos tamaos de pgina y diferentes
plataformas. Sin embargo, otro enfoque ofrece algunas
ventajas. Consiste en la definicin de un "tamao de pgina
destinada" al principio, y luego escalar a ese tamao.
Comenzar por definir el tamao de pgina deseado. Una

opcin obvia sera el tamao de la ventana de mano de
modo que los documentos creados por lo que sin duda
trabajar en este espacio limitado, pero luego se escala a
partir de ah.
locales iW = 318
locales iH = 212
Inicialmente, tambin, definir un factor de escala:
sf = 1 locales
Una variacin interesante de la funcin de pintura estndar

se muestra a continuacin. Estudiar cuidadosamente y ver si
se puede entender la intencin.
funcin on.paint ( GC)
- Habilitar los controladores
on.paint = OnPaint
on.resize = onResize
- Llame a onResize inicial
onResize ( platform.window: Ancho (), platform.window:

altura () )
- La llamada inicial OnPaint
OnPaint (GC)
fin
Adems de lo que otras variables iniciales u objetos que
necesitan ser definidos desde el principio, una insercin
crtica en esta funcin de cambio de tamao es la definicin
del factor de escala en trminos de las dimensiones de la
ventana plataforma (gracias a Nevil Hopley por el gran
enfoque sugerido se muestra a continuacin ). Yo
probablemente incluir la definicin de la fuente en este
punto tambin. A continuacin, una sencilla funcin de
escala se aplica esto a travs de la secuencia de comandos.
funcin onResize (w, h)
sf = Math.min ( w / iW, h / iH)
fontSize = 10 * sf
fin
funcin s (a)
Math.floor volver ( a * SF + 0,5)
fin
La funcin de la pintura a continuacin, har uso de ellos

para mostrar los objetos escala apropiada. La primera
imagen muestra la vista de mano; el segundo punto de vista
informtico. Incluso la fuente escalar adecuadamente.
funcin
OnPaint (GC)
x = s locales
(IW / 4)
y = s locales
(Ih / 4)
locales w = s
(IW / 2)
Local H = s
(ai / 2)
- Dibujar el
fondo
GC:
setColorRGB
( 200, 200,
250)
GC: fillRect
( x, y, w, h)
-- Dibujar
lneas
GC:
setColorRGB
( 150, 150,
250)
GC:
drawRect ( x,
y, w, h)
GC:
drawLine ( x,
y, x + w, y +
h)
GC:
drawLine ( x,
y + h, x + w,
y)
- Dibujar
Mensajes
GC:
setColorRGB
( 150, 30, 30)
GC: setFont
( "sansserif",
"b", fontSize)
str locales =
"Ponemos la
tecnologa en
sus manos"
Local Sw
= gc:
GetStringWid
th ( str)
GC:
drawString
( str, s (IW /
2) - SW / 2, s
(IH * 0,9),
"inferior")
fin
Observe que todas las posiciones y las dimensiones del

objeto se ejecutan a travs de la funcin de escala y se
expresan en trminos del tamao de la ventana prevista.
Aunque es evidente que un poco ms complicado para

establecer que el mtodo anterior, este enfoque ofrece una
clara ventaja: supongamos que queremos cambiar la escala
de la ventana completa como cambios de variables? Una
simple cuestin de ajustar la variable de factor de escala, y
todo lo dems sigue, mientras que el enfoque anterior
requerira numerosos cambios para lograr este mismo fin.
Scripting Tutorial - Leccin 20: Directrices para Lua nspired Autora II
TRABAJO travs de plataformas (Crear vez que el juego

en todas partes)
2. Consideraciones de control: Trabajar bien en todas partes!
Nuestro contenido digital necesita no slo se ven muy bien , pero

tambin debe ser una experiencia intuitiva y satisfactoria para el
usuario, sin importar la plataforma que se est ejecutando.
Para la mayora de los usuarios de ordenador, el ratn es el medio ms

natural con el cual interactuar con contenido digital. Pulsando y
arrastrando forma rpida y sin problemas y necesita poca o ninguna
instruccin.
En la mano, sin embargo, incluso con la experiencia sumamente

mejorada del ratn / cursor, que es ni de lejos tan rpida y satisfactoria,
ya que est en el equipo. Agarrando y arrastrando siguen siendo puntos
clave de entrada de usuario. Hacer un uso efectivo del teclado de mano
puede ofrecer ventajas significativas en el aumento de la capacidad de
uso de nuestros documentos.
Y esto es solo la punta del iceberg. Se requieren consideraciones de

diseo importantes de carcter prctico para asegurar que el contenido
creado se ejecutar de manera efectiva, no slo en el software de mano
y el equipo, pero en el reproductor, en PublishVew y en otros
lugares. Ciertos principios claros pueden ayudar a garantizar un alto
grado de confianza en este sentido.
En esencia, la clave del xito en este sentido es la duplicacin de toda la

funcionalidad necesaria para el ratn y el teclado, de modo que el
usuario puede elegir fcilmente cualquiera de los mtodos de control,
dependiendo de la plataforma o incluso preferencia personal.
2.1 Control del ratn y Clases
Independientemente de los obstculos

relativamente menores en el uso
efectivo del ratn en la mano, el punto,
haga clic y arrastre la interfaz sigue
siendo comn a todas las plataformas,
y as debe ser la primera prioridad en
el diseo y planificacin de las
interacciones del usuario.
Si bien pueden parecer un poco difcil

de configurar, la forma ms eficaz
para asegurar una buena experiencia
de ratn es definir todos los objetos
seleccionables mediante clases,
aprovechando la ventaja que esto
ofrece en trminos de los poderosos
"contiene" elementos, as como los
muchos parmetros que pueden ser
controlados con facilidad una vez que
una clase se ha definido.
Una cuestin que ha acompaado uso

del ratn / cursor en unidades
porttiles TI-Nspire en el pasado ha
habido una tendencia a "submarino" -
el ratn tiende a desaparecer de forma
automtica y puede tardar unos
segundos en aparecer. Esta ha sido,
posiblemente, an ms notable en los
documentos de Lua. Ahora se
recomienda que los autores deben
incluir el cursor.show () comando en
la secuencia de comandos,
inicialmente dentro de esta funcin:
funcin on.activate ( )
cursor.show ( )
fin
Puede ser til incluir este comando de nuevo (por ejemplo,

en una funcin mouseMove) para asegurar que el cursor
permanece visible a travs de las interacciones con el script.
2.2 Botones y teclados
Si el jugador es ser una posible plataforma para el

contenido, entonces es fundamental que todas las acciones
necesarias se pueden realizar usando los controles del ratn,
y que los botones se puede hacer clic proporcionan acceso a
todas las caractersticas y funcionalidades
necesarias. entrada de teclado e incluso opciones de men
no son una opcin para el jugador.
Plantillas, como la plantilla de teclado esta incluido para su

descarga con esta leccin, ofrecen formas relativamente
fciles de incluir tales caractersticas en los documentos
creados.
Seleccin de objetos 2.3 Control con teclado y
En el corazn de este problema de usabilidad se encuentra

el entorno de mano, donde el ratn, mientras est
disponible, no siempre puede ser el mtodo ms rpido para
seleccionar y arrastrar objetos. Mtodos de teclado pueden
ofrecer una experiencia de usuario ms eficaz, pasando por
alto en muchos casos la necesidad de pasar a agarrar y
puntos
particulares. Los mouse_dragging_v1.2.tns documento
incluido ilustra un ejemplo simple de los principios
recomendados aqu.
Mientras que los objetos se pueden seleccionar fcilmente (y
se clonaron) haciendo clic con el ratn y luego arrastraron,
estas acciones clave tambin pueden conseguirse utilizando
los controles del teclado:
o Al pulsar Haga clic en cualquier lugar de esta imagen para un vdeo de demostracin
el tabKey (o
Shift-Tab)
selecciona cada
objeto a su vez.
o El uso de
las teclas con
flechas en primer
lugar clonar el
objeto
seleccionado y
luego moverla
por la pantalla de
forma rpida y
sencilla.
o Como
alternativa,
utilice el tabKey
para seleccionar
un objeto, y
luego
simplemente
mueva el ratn -
el objeto se
"salta" a donde
est el ratn!
o Para
liberar un objeto
seleccionado,
pulse Escape.
o Para
restablecer, haga
clic en el botn
proporcionado,
Pulse ENTER o
"r" (o "R").
NOTA: Posiblemente el medio ms eficaz de controlar objetos

es utilizar una combinacin de controles de teclado y
ratn! Seleccionar rpida y fcilmente usando el tabKey, y
luego mover ligeramente el ratn para tener el objeto
inmediato tomar esa posicin.
Qu pasa cuando tenemos ms que slo dos o tres objetos

para seleccionar y controlar? Tabulacin a travs de muchos
objetos no es una experiencia de usuario rentable.
El ejemplo de lgebra Haga clic en cualquier lugar de esta imagen para un vdeo de demostracin
Azulejos incluido ofrece
un ejemplar nivel
bastante alto de todos los
principios que hemos
discutido aqu. La
solucin adoptada para
los seis tipos de objetos
diferentes era utilizar el
teclado para seleccionar
un objeto escribiendo una
carta: tipo "x" y y x-placa
est seleccionado, listo
para saltar a donde est el
ratn. Pulse la tecla "s"
para x-cuadrado y "u"
para una unidad de
baldosas. Para los
negativos, pulse "n" y
luego la letra
deseada. Este enfoque ha
demostrado ser al menos
tan eficaz como el uso del
ratn, en general, y sin
duda ms eficaz en el
dispositivo porttil.
Estudio de otras
caractersticas de este
documento. Prensa "?" o
"a" para que aparezca un
multi-pgina "Acerca de"
pantalla con instrucciones
detalladas. nmeros Pulse
para cambiar el valor de
x, o pulse "+" y "-" para
cambiar los valores en
incrementos de 0,1.
Este documento sirve para incorporar los principios

fundamentales establecidos en estas directrices. Sintase
libre de copiar y pegar el cdigo que desee en cualquiera de
los archivos adjuntos, y adaptarse para satisfacer mejor sus
necesidades.
2.4 Flecha control de clave
Ya hemos observado que agarrar y arrastrar objetos en la

mano puede ser una fuente de frustracin. Una de las
oportunidades que me atrajo primero en Lua fue la
capacidad de asignar fcilmente el control del movimiento
de los objetos a las teclas de flecha - si existan esos objetos
dentro de la ventana de Lua, o "fuera" en el "mundo" TI-
Nspire. Si bien esto ha sido implicado en las secciones
anteriores, es lo suficientemente importante como para
evaluar su propio principio rector:
Siempre que sea posible, Haga clic en cualquier lugar de esta imagen para un vdeo de demostracin
los documentos deben
estar diseados de
manera que el
movimiento de los puntos
se puede controlar
utilizando las teclas de
flecha, adems de
agarrar y arrastrar con
el ratn.
Esto se logra fcilmente
utilizando las funciones
arrowkey, sobre todo
cuando hay un solo punto
"conductor". Si hay
varios puntos, a
continuacin, es
necesario considerar que
debe darse a las tcnicas
efectivas para la seleccin
de estos. Una vez ms,
relativamente fcil de
lograr el uso de clases,
pero igualmente posible
sin. En el ejemplo
mostrado (de nuevo, a
partir de Matemticas
nspired con gracias esta
vez a Daniel Ilaria), hay
tres puntos "controlador",
a, b, c, y stos existen
dentro de una ventana
nativa grfico, por lo que
las clases no son una
opcin. El tabKey se
utiliza para saltar de una a
la siguiente (las
coordenadas se
almacenan en una tabla /
lista de Lua y
simplemente pestaa
pasos a travs de esta
tabla). Con el fin de
indicar visualmente el
punto seleccionado en ese
momento, un pequeo
segmento rojo se une a
otro punto, controlados
de manera similar.
Documentos diseados de esta manera estn listos para que

los estudiantes comienzan el control de la accin tan pronto
como entran en la pgina. No es necesario mover a travs
de la pgina a un lugar determinado punto, no hay
necesidad de tratar de agarrar y arrastrar el punto. Esto
puede parecer trivial para un usuario de la computadora,
pero est lejos de ser trivial en el dispositivo porttil. Este
enfoque ofrece un rendimiento significativo y ventajas de
facilidad de uso que deben ser utilizados como una cuestin
de rutina en el diseo de documentos.
Las lecciones que siguen a tomar ventaja de la liberacin OS3.2 2012 y

hacer realidad la promesa de ser los finales previstas para estos
tutoriales. Comienzan con una nueva manera de hacer algo muy simple,
pero muy importante - para aceptar la introduccin de texto por parte
del usuario, y luego a las interesantes posibilidades de la TI-Nspire Lua
Chipmunk motor de fsica.
Volver arriba

Lua Esta Si Es para Hacer Los Zom

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Lua Esta Si Es para Hacer Los Zom

Enviado por

Direitos autorais:

Formatos disponíveis

w

Haciendo variables globales locales

Ver tambin: OptimisationTips

Making global variables local

See also: OptimisationTips

Minimising objects created

function() ... end

Executing a function statement creates a closure (note: not calling the

function(foo, ...) end

Freeing local variables

[*1] strsub exists in Lua 4, not Lua 5.

Minimizar los objetos creados

(ET) Las variables locales No. se mantienen en una pila y no afectarn a la

a..b(slo ejemplo, cualquier cadena de generacin de la construccin, es

Cada vez que un constructor se ejecuta mesa se crea una nueva

function() ... end

La ejecucin de una sentencia de funcin crea un cierre (nota: no llamar a

function(foo, ...) end

Bueno, estos carga / compilar cdigo nuevo y crear cadenas y segmentos

La liberacin de las variables locales

[* 1] strsubexiste en Lua 4, 5 no Lua.

Issue #1: Vararg Saving

Issue #2: Combining Lists

Issue #3: Selecting the First N Elements in List

Issue #4: Appending One Element to a List

Issue #5: Reversing a List

Issue #6: The map Function

Issue #7: The filter Function

Issue #8: Iterating over Varargs

Issue #1: Vararg Saving

(Some comments on that are in LuaList:2007-03/msg00249.html .)

test = trace(function(x,y,z) print("calc", x,y,z); return x+y, z end)

Still, there are ways to achieve this in Lua.

Solution: {...} and unpack

test = trace(function(x,y,z) print("calc", x,y,z); return x+y, z end)

Solution: {...} and unpack with n

The following improvement on the previous solution properly handles nils:

--Wraps a function with trace statements.

test = trace(function(x,y,z) print("calc", x,y,z); return x+y, z end)

A variant noted by Shirik is

Solution: nil Placeholders

function unpack2(t) --caution: modifies t

--Wraps a function with trace statements.

test = trace(function(x,y,z) print("calc", x,y,z); return x+y, z end)

Here are more optimal implementations of pack2 and unpack2:

See also StoringNilsInTables.

Solution: Continuation Passing Style (CPS)

Tables can be avoided if we use the Continuation passing style (CPS)

test = trace(function(x,y,z) print("calc", x,y,z); return x+y, z end)

Solution: Code Generation

Another approach is code generation, which compiles a separate constructor for

To avoid the overhead of code generation on each store, we can memoize

A more complete example of tuples implemented via code generation is

Solution: Functional, Recursive

Another idea is with coroutines:

A similar suggestion was posted in LuaList:2007-02/msg00142.html . That can

Tuples can be implemented in C as a closure containing the tuple elements as

-- Benchmarks function f using chunks of nbase iterations for

local function print_bench(name, duration, nbase, ntrials, func, ...)

-- Test all methods.

-- NOTE: Upvalues in C Closure not benchmarked here.

For a tuple size of 1, we get

For a tuple size of 20, we get