Но вот беда, данные он выдает довольно шумные и чем больше расстояние, тем больше шума.

Чтобы определить подлинную плотность блока, можно просканировать его несколько раз, а результат усреднить. Шум, мешающий сканированию, имеет вероятностную природу. И после нескольких сканирований можно статистически найти, какая вероятней всего плотность у блока.

За один тик мы можем просканировать 64 блока. Чтобы проанализировать всю доступную область (65 x 65 x 64) сотней итераций, нам понадобится 422500 тиков, что равно 21125 секунд или 352 минуты, то есть без малого 6 часов.

Но сколько раз надо сканировать? Сто? Тысячу?

Нам открыто тайное знание и есть точный ответ.
Один. Всего за одно сканирование мы можем найти руду среди любых других блоков. Если хочется абсолютной уверенности, придется сделать пару магических пассов и просканировать повторно.

Начнем с теории.

Для начала откроем код мода и найдем функцию geolyzer.scan, она располагается [здесь] src/main/scala/li/cil/oc/integration/vanilla/EventHandlerVanilla.scala и называется onGeolyzerScan()
Просмотрев код, мы можем понять, что функция принимает параметры, по этим параметрам сканирует блоки в мире. Делает разные проверки вроде world.blockExists(x, y, z) && !world.isAirBlock(x, y, z), чтобы убедится, что блок есть. Потом получает информацию о блоке по координатам, делает еще несколько проверок (опять проверить, что блок все-таки есть block != null, проверяет дополнительные параметры: includeReplaceable, isFluid(block), block.isReplaceable(world, blockPos.x, blockPos.y, blockPos.z))
Потом происходит измерение расстояния до блока. И в конце берется плотность, смешивается с шумом и расстоянием. Результат добавляется к таблице блоков и отправляется игроку.

Вроде-бы ничего необычного. Шум, расстояние, плотность. Нам и так известна зависимость силы шума от расстояния.

И вот тут начинается волшебство.
Рассмотрим поподробнее код вычисления итоговой плотности блока.

e.data(index) = e.data(index) * distance * Settings.get.geolyzerNoise + block.getBlockHardness(world, x, y, z)

Коротко можно это записать в виде формулы: R = G * D * N + H
G - это сгенерированный шум.
D - расстояние до блока.
N - множитель шума из конфига (стандартно - 2).
H - настоящая плотность.
R - результат работы геосканера.

Если мы попробуем в качестве эксперимента отнять от результата предполагаемую плотность, то ничего нового не узнаем. Если обратим все операции с известными значениями, то получим только шум.

А можем ли мы так же разобрать формулу шума? Давайте попробуем.

Несколькими строками выше [ссылка]. Можно наблюдать получение массива случайных байт.

val noise = new Array[Byte](e.data.length)
world.rand.nextBytes(noise)

Далее следует нормализация значений.

noise.map(_ / 128f / 33f).copyToArray(e.data)

Хм. Так-так-так. Если мы это все обьеденим с предыдущей формулой, то получится что-то вроде такого:
R = G(RANDOM_BYTE / 128 / 33) * D * N + H

И что это нам дает?
А то, что исходное псевдослучайное число имеет жесткую дискретность. ГПСЧ дает случайные числа типа byte, а это только 256 значений (-128, +127).
Нам известны все значения, кроме H и RANDOM_BYTE, что нам это дает?
Мы можем предположить значение H и обратить всю формулу.
(R - H) / D / N * 128 * 33
Для стандартного конфига можно сократить до:
2112 * (R - H) / D

А теперь тайное знание для тех, кто не понял самостоятельно.

Мы взяли желаемую плотность блока (например 3 для руды).
Подставили вместо H.
Получили случайное значение.
Можем легко определить, угадали ли плотность или нет.

Из-за дискретности случайных значений генератора, распределение вероятностей для блоков с разной плотностью не одинаковое.

Перейдем к практике.

Вот код простого скрипта, который в заданном радиусе ищет блоки с нужной плотностью. Результат выводится на голопроектор.

local sqrt = math.sqrt
local component = require('component')
local geolyzer = component.geolyzer
local hologram = component.hologram

local function distance(x, y, z)
  return sqrt(x^2 + y^2 + z^2)
end

local function magic(R, H, D)
  return 2112 * (R - H) / D % 1
end

local function visualize(hardness, elevation, size)
  hologram.clear()
  hologram.setScale(9)
  local blocks, result
  for x = -size, size do
    for z = -size, size do
      blocks = geolyzer.scan(x, z, elevation, 1, 1, 32)
      for i_y = 1, 32 do
        result = magic(blocks[i_y], hardness, distance(x, i_y+elevation-1, z))
        if blocks[i_y] ~= 0 and (result > 0.9998 or result < 0.00005) then
          hologram.set(x+24, i_y, z+24, true)
        end
      end
    end
  end
end

local hrd, ele, siz = table.unpack({...})
hrd = hrd or 3
ele = ele or -32
siz = siz or 16
visualize(hrd, ele, siz)

А вот результат:

При сканировании заметны артефакты. Когда разные плотности близки на целочисленных расстояниях, позникают коллизии. 
Это можно частично компенсировать, если есть блок кандидат на ошибку.

На любом расстоянии можно рассчитать абсолютный минимальный и максимальный уровень шума. С расстоянием, у близких плотностей пересечение значений увеличивается, но если плотность блока не в области пересечений, то можно точно определить к какой области он относится.

Пересечение плотностей руды (3) и камня (1.5), точками обозначены три сканирования блока руды.

Результаты обратного вычисления для разных плотностей хорошо это демонстрируют.

Для компенсации артефактов надо ввести дополнительное условие: полученный RANDOM_BYTE должен быть в диапазоне -128:127.
Вот финальный скрипт и результат.

local sqrt = math.sqrt
local component = require('component')
local geolyzer = component.geolyzer
local hologram = component.hologram

local function distance(x, y, z)
  return sqrt(x^2 + y^2 + z^2)
end

local function magic(R, H, D)
  return 2112 * (R - H) / D
end

local function visualize(hardness, elevation, size)
  hologram.clear()
  hologram.setScale(9)
  local blocks, result
  for x = -size, size do
    for z = -size, size do
      blocks = geolyzer.scan(x, z, elevation, 1, 1, 32)
      for i_y = 1, 32 do
        result = magic(blocks[i_y], hardness, distance(x, i_y+elevation-1, z))
        if blocks[i_y] ~= 0 and result > -128 and result < 127 and (result%1 > 0.9998 or result%1 < 0.0002) then
          hologram.set(x+24, i_y, z+24, true)
        end
      end
    end
  end
end

local hrd, ele, siz = table.unpack({...})
hrd = hrd or 3
ele = ele or -32
siz = siz or 16
visualize(hrd, ele, siz)

Для более точного определения плотности можно сделать два сканирования. Одно сместить относительно другого так, чтобы расстояния с артефактами не совпадали.

Чтобы не выполнять тяжелую операцию sqrt, можно создать словарь, где [x^2 + y^2 + z^2] = sqrt(x^2 + y^2 + z^2), всего понадобится 1742 уникальных значений.

P.S. Пост является компиляцией знаний из [этой] темы. Собрал, чтобы перевести и опубликовать на официальном форуме.

Автор идеи хакнуть геосканер - @eu_tomat

Основные возможности очков и периферии:

• Отображение геометрических объектов различной сложности и цветовой гаммы.
• Отображение текста.
• Отображение жидкостей и предметов.
• Взаимодействие с мышью/клавиатурой.
• Чтение сообщений чата.
• Специальные команды чата, не отображающиеся в нем.
• Возможность индивидуальной работы с каждым пользователем терминала.
• Установка очков в любой шлем.

Возможности данных очков я опишу по разделам, в лучших традициях вики 

Для начала, определю некоторые понятия.

Система терминальных очков состоит из трёх предметов: терминала, очков, беспроводной клавиатуры.

Терминал является центром всей системы, через него происходит общение между компьютером и очками. Также он хранит все данные интерфейса и пользователей.

На очки выводится вся графическая информация, а сами очки передают сообщения или команды чата на терминал.

Беспроводная клавиатура позволяет дополнить всю систему, своей возможностью контроля элементов при помощи клавиатуры и мыши.

Как выводить информацию на очки:

local com = require("component")
local opb = com.openperipheral_bridge

-- Построение интерфейса происходит во внутреннем буффере терминала (он же мост).
local text = opb.addText(10, 10, "", 0xffef7f) -- Создаем компонент "Текст".
-- Его нужно создать только один раз, в остальное время можно обращаться по ссылке и изменять любой параметр.

local counter = 0
while true do -- В качестве примера будет выводится счетчик секунд.
  text.setText(tostring(counter)) -- Обновляем текста компонента.
  
  opb.sync() -- Для отображения графики на экране, необходимо отправить буффер на очки.
  
  os.sleep(1) -- Ждем секунду и прибавляем счетчик.
  counter = counter+1
end

API

Перед тем как перейти к API, нужно знать:

Color:number -- Число в формате TrueColor RGB (по умолчанию 0xffffff).
Opacity:number -- Прозрачность, число от 0.0 до 1.0 (по умолчанию 1).
Знак '?' -- Опциональный параметр/функция.

События

componentAddress:string, userName:string, userUUID:string

glasses_key_down(keyCode:number, char:string, isRepeat:boolean)
-- Событие нажатия или удержания(isRepeat = true) кнопки клавиатуры.

glasses_key_up(keyCode:number)
-- Событие отпускания кнопки клавиатуры.

glasses_mouse_scroll(value:number)
-- Событие поворота колесика мыши.

glasses_mouse_down(button:number)
-- Событие нажатия кнопки мыши.

glasses_mouse_up(button:number)
-- Событие отпускания кнопки мыши.

glasses_component_mouse_wheel(id:number, private:boolean, x:number, y:number, value:number) 
-- Событие поворота колесика мыши над интерактивным элементом.
-- Параметр id является идентификатором объекта, над которым сработало событие.
-- Позиции x,y относительно позиции объекта.
-- Поле private устанавливается если элемент находится в интерфейсе отдельного пользователя.

glasses_component_mouse_down(id:number, private:boolean, x:number, y:number, button:number)
-- Событие нажатия кнопки мыши над интерактивным элементом.
-- Параметр id является идентификатором объекта, над которым сработало событие.
-- Позиции x,y относительно позиции объекта.

glasses_component_mouse_up(id:number, private:boolean, x:number, y:number, button:number)
-- Событие отпускания кнопки мыши над интерактивным элементом.
-- Параметр id является идентификатором объекта, над которым сработало событие.
-- Позиции x,y относительно позиции объекта.

glasses_mouse_drag(deltaX:number, deltaY:number)
-- Событие перетаскивания мышью (движение с зажатой клавишей мыши).

glasses_attach
-- Событие экипировки очков.

glasses_detach
-- Событие снятия очков.

glasses_capture
-- Событие входа в режим захвата.

glasses_release
-- Событие выхода из режима захвата.

glasses_chat_message(msg:string)
-- Пользователь отправил сообщение в чат.

glasses_chat_command(command:string)
-- Пользователь отправил команду.
-- Командой является сообщение в чат, начинающееся с символов '$$'

Строковые константы

VerticalAlignment:[TOP, MIDDLE, BOTTOM]
HorizontalAlignment:[LEFT, MIDDLE, RIGHT]
GuiElement:[OVERLAY, PORTAL, HOTBAR, CROSSHAIRS, BOSS_HEALTH, HEALTH, ARMOR, FOOD, MOUNT_HEALTH, AIR, EXPERIENCE, JUMP_BAR, OBJECTIVES]

Структуры данных

SimpleBox, ColoredPoint, Coord, User

SimpleBox -- Содержит информацию о положении и размере области.
  top:number
  left:number
  width:number
  height:number

ColoredPoint -- Содержит информацию о вершине: её положение и цвет.
  x:number
  y:number
  rgb:Color?
  opacity:Opacity?

Coord -- Содержит информацию о координатах объекта.
  x:number
  y:number

User: -- Содержит информацию о пользователе терминала.
  name:string -- Имя игрока.
  uuid:string -- Уникальный идентификатор игрока в терминале.

Абстрактные объекты

Drawable, BoundedShape, Box

Drawable -- Базовый интерфейс всех отображаемых объектов
  getId():number
    -- Получить идентификатор объекта в терминале.
  delete()
    -- Удалить объект из терминала.
  getType():string
    -- Получить тип объекта.
  get/setVisible():boolean
    -- Получить или установить видимость объекта.
  get/setClickable():boolean
    -- Получить или установить интерактивность объекта.
  get/setRotation():number
    -- Получить или установить текущий поворот объекта (в градусах).
  get/setUserdata():object
    -- Получить или установить кастомные данные. Могут быть любого типа,
    -- используются для хранения данных/ссылок и т.п. (при необходимости).
  get/setZ():number
    -- Получить или установить положение объекта по оси 'Z'.
    -- Принимаются значения от -32768 до 32767 (short), но отображаться будут только в пределах [-999, 1000].
    -- Чем больше значение - тем "ближе" объект.
  setScreenAnchor(horizontal:HorizontalAlignment, vertical:VerticalAlignment)
    -- Установить начальную точку отсчета.
    -- Т.е. позицию {x:0,y:0} относительно экрана.
  setObjectAnchor(horizontal:HorizontalAlignment, vertical:VerticalAlignment)
    -- Установить конечную точку отсчета.
    -- Т.е. сдвигает координаты {x:0,y:0} объекта на ширину и/или высоту объекта.
    -- Также является осью поворота объекта.
  setAlignment(horizontal:HorizontalAlignment, vertical:VerticalAlignment)
    -- Устанавливает начальную и конечную точку отсчета одновременно.

BoundedShape:Drawable -- Базовый объект для объектов с произвольным набором вершин(точек).
  getBoundingBox():SimpleBox
    -- Возвращает экранную позицию и размер объекта.

Box:Drawable -- Базовый объект для прямоугольников.
  get/setX():number
  get/setY():number
  get/setWidth():number
  get/setHeight():number

Графические объекты

Point:Drawable -- Точка на экране.
  get/setCoord():Coord
    -- Экранные координаты точки.
  get/setSize():number
    -- Размер точки (по умолчанию 1).
  get/setColor():Color
  get/setOpacity():Opacity

SolidLine:BoundedShape -- Закрашенная линия.
  get/setWidth():number
    -- Ширина линии (по умолчанию 1).
  get/setP1():Coord
    -- Первая точка линии.
  get/setP2():Coord
    -- Вторая точка линии.
  get/setColor():Color
  get/setOpacity():Opacity

GradientLine:BoundedShape -- Линия с градиентным переходом.
  get/setWidth():number
    -- Ширина линии (по умолчанию 1).
  get/setP1():ColoredPoint
    -- Первая точка линии.
  get/setP2():ColoredPoint
    -- Вторая точка линии.

SolidLineStrip:BoundedShape -- Закрашенная произвольная линия.
  get/setWidth():number
    -- Ширина линии (по умолчанию 1).
  get/setPoints():Coord[]
    -- Получить или установить вершины линии.
  ?getPoints(index:number):Coord
    -- Получить вершину по индексу.
  ?setPoints(point:Coord, index:number)
    -- Установить вершину по индексу.
  get/setColor():Color
  get/setOpacity():Opacity

GradientLineStrip:BoundedShape -- Произвольная линия с градиентным переходом.
  get/setWidth():number
    -- Ширина линии (по умолчанию 1).
  get/setPoints():ColoredPoint[]
    -- Получить или установить вершины линии.
  ?getPoints(index:number):ColoredPoint
    -- Получить вершину по индексу.
  ?setPoints(point:ColoredPoint, index:number)
    -- Установить вершину по индексу.

SolidBox:Box -- Закрашенный прямоугольник.
  get/setColor():Color
  get/setOpacity():Opacity

GradientBox:Box -- Прямоугольник с градиентным переходом.
  get/setColor1():Color
  get/setOpacity1():Opacity
  get/setColor2():Color
  get/setOpacity2():Opacity
  get/setGradient():number
    -- Направление градиента, 1 - снизу/вверх, остальные значения - справа/налево.

SolidTriangle:BoundedShape -- Закрашенный треугольник.
  get/setP1():Coord
  get/setP2():Coord
  get/setP3():Coord
  get/setColor():Color
  get/setOpacity():Opacity

GradientTriangle:BoundedShape -- Треугольник с градиентным переходом.
  get/setP1():ColoredPoint
  get/setP2():ColoredPoint
  get/setP3():ColoredPoint

SolidQuad:BoundedShape -- Закрашенный четырёхугольник.
  get/setP1():Coord
  get/setP2():Coord
  get/setP3():Coord
  get/setP4():Coord
  get/setColor():Color
  get/setOpacity():Opacity

GradientQuad:BoundedShape -- Четырёхугольник с градиентным переходом.
  get/setP1():ColoredPoint
  get/setP2():ColoredPoint
  get/setP3():ColoredPoint
  get/setP4():ColoredPoint

SolidPolygon:BoundedShape -- Закрашенная произвольная фигура.
  get/setPoints():Coord[]
    -- Получить или установить вершины фигуры.
  ?getPoints(index:number):Coord
    -- Получить вершину по индексу.
  ?setPoints(point:Coord, index:number)
    -- Установить вершину по индексу.
  get/setColor():Color
  get/setOpacity():Opacity

GradientPolygon:BoundedShape -- Произвольная фигура с градиентным переходом.
  get/setPoints():ColoredPoint[]
    -- Получить или установить вершины фигуры.
  ?getPoints(index:number):ColoredPoint
    -- Получить вершину по индексу.
  ?setPoints(point:ColoredPoint, index:number)
    -- Установить вершину по индексу.

ItemIcon:Drawable -- Иконка предмета с размерами 16х16
  get/setX():number
  get/setY():number
  get/setScale():number
    -- Размер иконки (по умолчанию 1).
  get/setItemId():string
    -- Полный id предмета.
  get/setMeta():number
    -- Метаданные объекта (поворот и т.п.).
  get/setDamageBar():number
    -- Полоска прочности объекта.
    -- 0.0 - полоса отсутствует, 1.0 - полоса пустая (закончилась прочность).
  get/setLabel():string
    -- Текст с информацией о количестве.
    -- Тем не менее, может принимать и отображать любой текст.

LiquidIcon:Box -- Прямоугольник с текустурой жидкости.
  get/setFluid():string
    -- Имя жидкости (не id блока).
  get/setAlpha():Opacity

Text:Drawable -- Текстовое поле.
  get/setX():number
  get/setY():number
  get/setText():string
    -- Отображаемый текст.
  get/setScale():number
    -- Размер текста (по умолчанию 1).
  get/setColor():Color
  get/setAlpha():Opacity

Управление графическими объектами
DrawableFactory, DrawableContainer

DrawableFactory -- Фабрика отображаемых объектов. Созданный объект автоматически добавляется в контейнер.
  addPoint(coord:Coord, color:Color?, opacity:Opacity?):Point
    -- Создать объект Point - точку.
  addLine(p1:Coord, p2:Coord, color:Color?, opacity:Opacity?):SolidLine
    -- Создать объект SolidLine - цветную линию.
  addGradientLine(p1:ColoredPoint, p2:ColoredPoint):GradientLine
    -- Создать объект GradientLine - линию с градиентным переходом.
  addLineList(color:Color?, opacity:Opacity?, point1:Coord, point2...):SolidLineStrip
    -- Создать объект SolidLineStrip - произвольную цветную линию.
  addGradientLineList(point1:ColoredPoint, point2...):GradientLineStrip
    -- Создать объект GradientLineStrip - произвольную линию с градиентным переходом.
  addBox(x:number, y:number, width:number, height:number, color:Color?, opacity:Opacity?):SolidBox
    -- Создать объект SolidBox - цветной прямоугольник.
  addGradientBox(x:number, y:number, width:number, height:number, color:Color?, opacity:Opacity?,
        color2:Color?, opacity2:Opacity?, gradient:number):GradientBox
    -- Создать объект GradientBox - прямоугольник с градиентным переходом.
    -- Параметр gradient определяет направление градиента, 1 - вертикальный, 2 - горизонтальный.
    -- Если gradient установлен в 0, color2 и opacity2 игнорируются - получается цветной прямоугольник.
  addTriangle(p1:Coord, p2:Coord, p3:Coord, color:Color?, opacity:Opacity?):SolidTriangle
    -- Создать объект SolidTriangle - цветной треугольник.
  addGradientTriangle(p1:ColoredPoint, p2:ColoredPoint, p3:ColoredPoint):GradientTriangle
    -- Создать объект GradientTriangle - треугольник с градиентным переходом.
  addQuad(p1:Coord, p2:Coord, p3:Coord, p4:Coord, color:Color?, opacity:Opacity?):SolidQuad
    -- Создать объект SolidQuad - цветной четырёхугольник.
  addGradientQuad(p1:ColoredPoint, p2:ColoredPoint, p3:ColoredPoint, p4:ColoredPoint):GradientQuad
    -- Создать объект GradientQuad - четырёхугольник с градиентным переходом.
  addPolygon(color:Color?, opacity:Opacity?, point1:Coord, point2...):SolidPolygon
    -- Создать объект SolidPolygon - произвольную цветную фигуру.
  addGradientPolygon(point1:ColoredPoint, point2...):GradientPolygon
    -- Создать объект GradientPolygon - произвольную фигуру с градиентным переходом.
  addIcon(x:number, y:number, id:string, meta:number?):ItemIcon
    -- Создать объект ItemIcon - иконку предмета с размерами 16*16.
  addFluid/addLiquid(x:number, y:number, width:number, height:number, liquid:string):LiquidIcon
    -- Создать объект LiquidIcon - прямоугольник с текстурой жидкости.
  addText(x:number, y:number, text:string, color:Color?):Text
    -- Создать объект Text - цветной текст.

DrawableContainer -- Хранит отображаемые объекты.
  getById/getObjectById(id:number):Drawable
    -- Получить объект по идентификатору.
  getAllIds():number[]
    -- Получить идентификаторы хранящихся объектов.
  getAllObjects():{id:number, obj:Drawable}
    -- Получить таблицу хранящихся объектов.
  clear()
    -- Удалить все объекты.

Управление терминалом

UserSurface:DrawableContainer, DrawableFactory -- Контролирует интерфейс отдельно взятого пользователя.

CaptureControl -- Предоставляет управление "режимом захвата" во время использования "Беспроводной клавиатуры".
  stopCapturing()
  -- Остановить захват.
  setBackground(color:Color, alpha:Opacity?)
  -- Установить цвет и прозрачность фона.
  setKeyRepeat(repeat:boolean)
    -- Включить/отключить периодический повтор события "glasses_key_down" (по умолчанию false).
  setDragParameters(distance:number, delay:number)
    -- Установить минимальную дистанцию для возникновения события "glasses_mouse_drag"
    -- и минимальное время между срабатываниями (в тиках).
    -- По умолчанию distance=5, delay=10, эти значения также являются минимальными.
  toggleGuiElements({element:GuiElement, value:boolean})
    -- Установить видмость стандартных графических элементов.

TerminalGlassesBridge:DrawableContainer, DrawableFactory -- Управляет интерфейсами и хранит данные пользователей.
  getGuid():string
    -- Получить уникальный идентификатор терминала.
  sync()
    -- Отправить графические данные на очки всех пользователей.
  getUsers():User[]
    -- Получить всех пользователей терминала.
  getSurfaceByName(username:string):UserSurface
    -- Получить холст по имени игрока.
  getSurfaceByUUID(uuid:string):UserSurface
    -- Получить холст по уникальному идентификатору игрока.
  getCaptureControl(uuid:string):CaptureControl
    -- Получить контроллер режима захвата.

Вот такая шпаргалка по очкам, надеюсь пригодится 

Lua не относится к объектно-ориентированным языкам, поскольку не содержит стандартных механизмов создания и использования объектов. Но lua-таблица является настолько гибким инструментом, что позволяет реализовать практически любую структуру, присущую другим языкам. В том числе и объекты.

Прежде чем создавать экземпляры объекта, необходимо описать соответствующий ему класс.

ClassA={}
ClassA.__index=ClassA

Как видите, я не описал никаких полей объекта-прототипа т. к. в отличии от таких языков как Delphi и C++, поля таблицы в lua можно описывать когда угодно, а не только при создании таблицы. Поля будем прописывать в конструкторе класса при создании экземпляра объекта. Единственное поле __index содержит указатель на сам класс. Это нужно будет для правильной работы оператора self.

Создадим конструктор:

function ClassA:new(_Name)
  local obj={Name = _Name}
  setmetatable(obj,self)
  print('Constructor ClassA for '..obj.Name)
  return obj
end

Строка 1. Создает экземпляр теперь уже объекта, описывает поля объекта и присваивает полям начальные значения.

Строка 2. Переопределяет метатаблицу вновь созданного объекта, в результате чего объект получает доступ к методам класса. Методов пока нет, но они будут описаны позже.

Строка 3. Это необязательная строка. Я ее сюда вставил для демонстрации работы конструктора.

Строка 4. Возвращает созданный объект.

Теперь создадим парочку методов:

function ClassA:Metod1()
    print('Metod1 of ClassA for '..self.Name)
end

function ClassA:Metod2()
    print('Metod2 of ClassA for '..self.Name)
end

И так, мы создали объект-прототип. Пора создавать экземпляры объекта. Экземпляры будем хранить в таблице objects. Для создания экземпляра вызываем конструктор

objects={}

for i = 1,2 do
    objects[i] = ClassA:new('Object#'..i)
end

Смотрим что получилось

for i=1,2 do

    objects[i]:Metod1()
    objects[i]:Metod2()
end

Вот программа в полном сборе.

ClassA={}
ClassA.__index=ClassA

function ClassA:new(_Name)
    local obj={Name = _Name}
    setmetatable(obj,self)
    print('Constructor ClassA for '..obj.Name)
    return obj
end

function ClassA:Metod1()
    print('Metod1 of ClassA for '..self.Name)
end

function ClassA:Metod2()
    print('Metod2 of ClassA for '..self.Name)
end

objects={}
for i = 1,2 do
    objects[i] = ClassA:new('Object#'..i)
end

for i=1,2 do
    objects[i]:Metod1()
    objects[i]:Metod2()
end

Если все сделано правильно, после запуска программы Вы должны наблюдать вот такие сообщения:

[ATTACH]115[/ATTACH]

В следующий раз я расскажу о наследовании методов объекта и их полиморфизме.

# Место в памяти

Вот таблица, где есть, сколько что занимает в памяти:
boolean, number и string занимают 9 байт.
Указатель на функцию, или на таблицу, тоже 9 байт.
Пустая функция (function() end) занимает 93 байт, пустая функция с return (function() return true end) занимает 102 байт.
Пустая таблица занимает 36 байт, плюс за каждую степень двойки (2^n) еще дополнительно:

• 9 байт для 0-1 элементов в таблице
• 18 байт для 2 элементов в таблице
• 36 байт для 3-4 элементов в таблице
• 71 байт для 5-8 элементов в таблице
• 142 байт для 9-16 элементов в таблице
• 284 байт для 17-32 элементов в таблице
• 569 байт для 33-64 элементов в таблице

и т.д.
И, кстати, таблицы не сжимаются, то есть если туда запихать 1000 элементов, а потом удалить их, то весить она будет, как будто в ней все еще 1000 элементов
 

# Сборка мусора

Автоматический сборщик мусора в опенкомпах вроде бы отключен, и вызывается только через os.sleep(0), и то не гарантированно, так что разработчик мода советует его вызывать 10 раз подряд, чтоб уж точно
И еще, автоматический сборщик чистит ТОЛЬКО локальные переменные

# Советы сомнительной эффективности (от них я не засек прироста)

Убрать из кода деление, потому что оно, якобы, медленнее, чем умножение (условно:)

local a = n / 4
-->
local a = n * 0.25

Заменить все условные операторы, на логические тернарные операторы, где это возможно (условно:)

if (a > b) then
    c = a
else
    c = b
end
-->
c = (a > b) and a or b

(Если вы не поняли, что сейчас вообще было, то в этой теме все расписано)

Менять переменные местами, без буфера (Lua 5.3+)

local a = 174
local b = 3
a = a ~ b
b = a ~ b
a = a ~ b
print(a)
--> 3
print(b)
--> 174

(Если вы не поняли, что сейчас вообще было, то ищите битовую операцию XOR)
Этот совет дает хотя бы небольшой прирост, из-за того, что нет лишний переменной, но этот плюс нивелируется, если ее удалить

# В итоге

Не используйте рекурсию функций, а если совсем приспичило, то почаще вставляйте сбор мусора
Не используйте замыкания (это когда функция возвращает другую функцию)
Старайтесь не использовать таблицы, вместо них лучше делать так:

local coords = {x = 10, y = 20, z = 370} -- (72 байта)
-->
local x = 10
local y = 20
local z = 370 -- (27 байт)
-- или вообще
local xyz = 010020370 -- (9 байт)
print("z = ", xyz // 1000000, "\ny = " , xyz // 1000 % 1000, "\nz = ", xyz % 1000)
-- (Если вы не поняли, что сейчас вообще было, то ищите деление с остатком)

Старайтесь не использовать не-локальные переменные, так как они бьют по архитектуре программы, и их не собирает гарбадж коллектор

# P.S

В данной заметке рассматривалась только сторона оптимизации кода, определенный код может отвратительно выглядеть, но работать быстро, и наоборот, в реальных программах лучше соблюдать баланс, между красотой, и быстродействием, в какой-нибудь программе для EEPROM'a, допустим, вообще о красоте кода не идет и речи
Ну это в целом все, что я хотел рассказать, если есть исправления/уточнения/дополнения/свои_идеи, то милости прошу в комментарии

- А я умею читать чужие регулярные выражения!

- Ты победил

Люди, которые программируют приложения, связанные с обменом по сети rednet или сохранением на диск, часто сталкиваются с необходимостью преобразования массива данных различных типов в строку и последующим его восстановлением. Под массивом я подразумеваю не отдельно взятую таблицу, а несколько переменных, которые нужно упаковать в одну строку. Самый простой но не самый лучший способ решить эту задачу - поместить все необходимые данные в таблицу и воспользоваться функциями serialize, unserialize из библиотеки textutilse. О недостатках такого способа я уже когда-то говорил и сегодня повторяться не буду. А расскажу о том, как эту проблему решаю я. Предположим нам необходимо упаковать в одну строку значения нескольких переменных (x, y, z). Причем строка должна содержать не только значения переменных, но и информацию о том, что это за переменные. Думаю с упаковкой ни у кого больших проблем не возникнет. Сделать это можно, к примеру, так: s='x='..x..' y='..y..' z='..z В результате мы получим строку, которая содержит имена наших переменных и их значения, отделенные от имен знаками равенства. 'x=10 y=11 z=12' Вроде просто. Но как из этой строки извлечь заложенную в нее информацию, а именно имена и значения? Конечно, можно написать большой и сложный алгоритм посимвольного разбора строки. К счастью, вся скучная работа уже сделана за нас и поставленную задачу мы можем выполнить буквально в одно действие. Я говорю о функциях match и gmatch из библиотеки string. Назначение этих функций - поиск шаблона в строке. К примеру, в строке s, которую я привел выше, я хочу найти подстроку 'y=11'. Для этого я вызываю функцию s:match('y=11') которая и вернет мне искомую подстроку, если она там есть. Параметр 'y=11' будем называть шаблоном. Если шаблон в строке не найден, функция вернет nil. Правда здорово?

Но есть два нюанса:

1) Код библиотеки явно избыточен.

2) При чтении кода библиотеки создаётся впечатление, что она работает на неведомой магии тёмных сил, что демотивирует новичков, изучающих OpenComputers.

Я намерен восполнить данный недостаток.

Прочтение этого гайда поможет любому желающему написать кусочек кода под нужды конкретной программы, не подтягивая библиотечный код.

Благодарю @Totoro за предоставленную информацию:

1) Текстура блока имеет размер 16 px, а ширина рамки монитора – 2 px;

2) Высота символа на экране в два раза больше его ширины.

Данной информации достаточно для получения всех необходимых формул. Приступим:

Первый шаг: получить соотношение сторон экрана, выраженное в символах

В мире Майнкрафта текстура блока имеет размер в 16 пикселей. На рамку с каждой стороны тратится по 2 пикселя независимо от размера монитора.

Очевидно, что размер монитора в пикселях кратен 16 и пропорционален количеству использованных блоков, а размер полезной части экрана всегда меньше размера монитора на 4 пикселя как по вертикали, так и по горизонтали. Поэтому разрешение нескольких мониторов, выставленных в ряд, всегда составит 16*n-4 пикселей по соответствующей координатной оси.

Это подтверждает и формула от @ECS, реализованная в функции calculateAspect(screens), но имеющая более сложный вид. Я предлагаю и вовсе отказаться от отдельной функции, т. к. в текущих условиях это будет напрасной тратой ресурсов.

Немного поясняющего кода:

-- размер монитора в блоках
sw,sh = component.screen.getAspectRatio()
-- размер экрана монитора с учётом затрат на рамку:
sw_ = sw*16-4
sh_ = sh*16-4
-- соотношение сторон экрана, выраженное в пикселях текстуры блока
sa = sw_/sh_
-- соотношение сторон экрана, выраженное в символах
sa = 2*sw_/sh_
-- оно же без промежуточных присваиваний:
sa = 2*(sw*16-4)/(sh*16-4)
-- оно же после упрощения формулы и сокращения количества операций
sa = (sw*2-0.5)/(sh-0.25)

Второй шаг: скорректировать разрешение графической карты под соотношение сторон экрана

Теперь требуется получить максимально доступное разрешение GPU и соответствующее ему соотношение сторон:

-- максимально возможное разрешение графической карты в символах
gw, gh = gpu.maxResolution()
-- соотношение сторон при максимальном разрешении в символах
ga = gw/gh
-- формулы, полученные из предыдущей, и которые пригодятся чуть позже
gw = gh*ga
gh = gw/ga

Для определения дальнейших действий следует вспомнить о физическом смысле соотношения сторон. Исходя из приведённых выше формул, sa и ga можно назвать коэффициентами горизонтальности. Сравнивая их, можно определить, что по горизонтали более вытянуто разрешение либо видеокарты, либо монитора. Понятно, что если монитор имеет больший коэффициент горизонтальности, то для приведения к нему коэффициента горизонтальности видеокарты следует уменьшить её разрешение по вертикали. В ином случае следует уменьшать разрешение GPU по горизонтали:

-- код в понятной форме, использованы формулы из предыдущего фрагмента
if sa>ga then -- недостаточная горизонтальность GPU
  ga=sa -- привести горизонтальность в соответствии с экраном
  gh = gw/ga -- за счёт уменьшения высоты
else -- избыточная горизонтальность GPU
  ga=sa -- привести горизонтальность в соответствии с экраном
  gw = gh*ga -- за счёт уменьшения ширины
end
-- код после сокращения лишних операций
if sa > gw/gh then
  gh = gw/sa
else
  gw = gh*sa
end

Третий шаг: скорректировать разрешение графической карты под нужны программы

Вычисленное на предыдущем шаге разрешение может оказаться дробным, и перед использованием его следует округлить. Возможно, что перед этим разрешение должно быть приведено к желаемому масштабу, как это сделано в библиотеке @ECS. Эта часть, скорее всего, не требует пояснений, и готовый код будет, например, таким:

-- код для автоматической подстройки разрешения графической карты под размер монитора
--  почти не оставляет чёрных полос по краям экрана
--  полное исключение полос возможно только при отсутствии округления разрешения

local component = require"component"
local gpu, screen = component.gpu, component.screen

function set_proportional_resolution( scale )
  -- коррекция допустимых пределов масштаба
  if not scale or scale > 1 then
    scale = 1
  elseif scale < 0.1 then
    scale = 0.1
  end
  -- соотношение сторон монитора в символах:
  local sw,sh = screen.getAspectRatio()
  local sa = (sw*2-0.5)/(sh-0.25)
  -- запрос и коррекция максимального разрешения GPU
  local gw, gh = gpu.maxResolution()
  if sa > gw/gh then
    gh = gw/sa
  else
    gw = gh*sa
  end
  -- установка нового разрешения GPU с учётом заданного масштаба
  gpu.setResolution( math.floor(gw*scale), math.floor(gh*scale) )
end

-- тест работоспособности на нескольких вариантах масштаба
-- в процессе можно видеть, что на некоторых масштабах чёрные полосы имеют больший размер, чем на других
local w,h
local unicode = require"unicode"

for i=0.1, 1, 0.1 do
  set_proportional_resolution(i)
  w,h = gpu.getResolution()
  gpu.fill(1,1,w,h, unicode.char(0x2592))
  os.sleep(2)
end

Приведённый код можно сократить ещё сильнее, например, избавившись от масштабирования, которое может отвлекать читателя от подгонки соотношения сторон.

Полное исключение чёрных полос

При выполнении этого кода можно видеть, что чёрные полосы не исчезают полностью, и на одних масштабах проявляются сильнее, чем на других. Предположим, требуется полностью избавиться от чёрных полос. Можно было бы написать код и для этого случая, но эта задача не всегда решаема. Кроме того, количество решений сильно ограничено, и не любой интерфейс можно будет подогнать под найденные решения.

Пример №1:

Монитор максимального допустимого размера 8x6; GPU Tier3 обеспечивает максимальное разрешение 160x50.

Условное разрешение монитора в целых символах:

sw = 8*8-2 = 62

sh = 6*4-1 = 23

Допустимые разрешения GPU, которые обеспечат отсутствие полос: 62x23 и 124x46.

Пример №2:

Монитор 6x5; GPU Tier1 обеспечивает максимальное разрешение 50x16.

Условное разрешение монитора в целых символах:

sw = 6*8-2 = 46

sh = 5*4-1 = 19

Нет разрешений GPU, обеспечивающих полное отсутствие полос.

Пример №3:

Монитор 5x5; GPU Tier1 обеспечивает максимальное разрешение 50x16.

Условное разрешение монитора в целых символах:

sw = 5*8-2 = 38

sh = 5*4-1 = 19

Разрешения GPU 50x16 недостаточно для размещения поля символов 38x19. Но если присмотреться внимательно, и вспомнить, что нам важно соотношение, то поле символов можно сократить до 2x1, избавившись от общего делителя 19. В этом случае допустимых разрешений GPU предостаточно, начиная от 2x1 и заканчивая 32x16. Во всех этих случаях пустых чёрных полос на мониторе не будет.

Автоматизация этих вычислений вряд ли целесообразна. Скорее всего, имеет смысл примерно прикинуть необходимое разрешение для конкретного интерфейса, выбрать желаемый размер экрана, графическую плату, и выполнив приведённые выше вычисления, уже окончательно определить рабочее разрешение и затем подогнать интерфейс под него.

Вот, и вся магия. То, что выглядит сложным, не всегда является таковым на самом деле.

Upd: Дополняющий гайд от @ECS:

https://computercraft.ru/topic/2501-kak-ubrat-chyornye-polosy-po-krayam-ekrana-v30/

• Результирующее разрешение по числу пикселей не должно превышать результат умножения чисел, возвращаемых maxResolution. То есть для T3 GPU не более 160 * 50 = 8000.
• Каждый параметр разрешения, будь то ширина или высота, не должен численно превышать значение возвращаемой ширины. То есть для T3 GPU не более 160.

Не знаю, баг это или фича, однако подобное грех не использовать в своих целях. К примеру, старая версия программы при вертикально-удлиненном расположении мониторов позволяла выставить разрешение лишь в 30х50 (1500 пикселей в итоге), заполняя тем самым "черные полосы". В то же время обновленная софтина, учитывающая описанные выше особенности, выдает 69x114 (7866 пикселей), максимально приближаясь к предельной отметке в 8000:

Согласитесь, лишние пиксели на дороге не валяются, и, думаю, кому-то будет интересно узнать про реализацию подобного софта.

Прежде всего нам требуется определить точную пропорцию мультиблочного монитора: то, как относится его ширина к высоте. Взглянем на текстуру блока: она явно состоит из мелких "квадратиков" в количестве 16 штук, причем лицевая часть монитора имеет рамку толщиной в 2 "квадратика" с каждой стороны:

Эти "квадратики" мы и будем использовать для расчета пропорции,  так как они позволяют идеально точно получить размеры отображающей части монитора в игровом мире. А размеры "в квадратиках" можно посчитать по формуле:

число_блоков_монитора * 16 - 4

Следовательно, пропорция монитора будет считается следующим образом:

local gpu = component.gpu
local screen = component.proxy(gpu.getScreen())

local blockCountByWidth, blockCountByHeight = component.screen.getAspectRatio()
local proportion = (blockCountByWidth * 16 - 4) / (blockCountByHeight * 16 - 4)

Также не забываем, что высота каждого псевдографического пикселя при отображении в 2 раза больше его ширины, поэтому формула пропорции слегка меняется. Заодно произведем некоторые сокращения, чтобы избавиться от лишних математических операций. Все три варианта эквивалентны:

local proportion = 2 * (blockCountByWidth * 16 - 4) / (blockCountByHeight * 16 - 4)
local proportion = (blockCountByWidth * 16 - 4) / (blockCountByHeight * 8 - 2)
local proportion = (blockCountByWidth * 2 - 0.5) / (blockCountByHeight - 0.25)

После вычисления пропорции монитора можно приступить к написанию программной логики. Для начала получим максимальное разрешение видеокарты:

local maxWidth, maxHeight = gpu.maxResolution()

Обладая этими данными, а также взглянув на условия, описанные в начале поста, мы можем составить систему неравенств для получения итогового идеального разрешения:

Помним также, что ширину мы вполне можем выразить через высоту и пропорцию монитора:

width = proportion * height

Подставим этот вариант в систему:

Оставим высоту в левой части неравенств:

Подставляем имеющиеся переменные в каждое неравенство, рисуем числовую прямую и выбираем высоту, удовлетворяющую условиям неравенства для конкретного случая. Разумеется, в программировании никаких числовых прямых нет, зато есть любимые math.min() и math.max():

local height = math.min(
  maxWidth / proportion,
  maxWidth,
  math.sqrt(maxWidth * maxHeight / proportion)
)

-- Выражаем ширину через пропорцию
local width = height * proportion

Все. Разумеется, полученные значения ширины и высоты нужно округлить в меньшую сторону, дабы не кормить видеокарту дробями. Заодно добавим поддержку масштабирования, чтобы выставлять половинное или, скажем, четвертичное от идеального разрешение. Сократив код, избавившись от лишних переменных, мы получаем следующее:

local component = require("component")

-- Получаем масштаб в качестве первого аргумента скрипта и корректируем его значение
local scale = tonumber(select(1, ...) or 1)
if not scale or scale > 1 then
  scale = 1
elseif scale < 0.1 then
  scale = 0.1
end

local gpu = component.gpu
local blockCountByWidth, blockCountByHeight = component.proxy(gpu.getScreen()).getAspectRatio()
local maxWidth, maxHeight = gpu.maxResolution()
local proportion = (blockCountByWidth * 2 - 0.5) / (blockCountByHeight - 0.25)
 
local height = scale * math.min(
  maxWidth / proportion,
  maxWidth,
  math.sqrt(maxWidth * maxHeight / proportion)
)

-- Выставляем полученное разрешение
gpu.setResolution(math.floor(height * proportion), math.floor(height))

Надеюсь, это микро-знание кому-то было полезно. Лично я очень доволен, что могу наконец запилить графонистый интерфейс для контроля реакторов на вертикальных мониках без осваивания профессии "глиномес", да и соответствующая либа для автопобора разрешения в оське пригодится.

• setmetatable(table: table, metatable: table):table — это основная функция, которая позволяет установить таблице метатаблицу. Такая функция работает только с таблицами.
• getmetatable(value: value):table or value — возвращает метатаблицу, если есть или значение поля __metatable в метатаблице, если есть. Работает со всеми значениями.
• debug.setmetatable(value: value):boolean or table — устанавливает метатаблицу любому значению и обходит метаполе __metatable. Действительно мощная штука, вот почему её убрали в Open Computers .
• debug.getmetatable(value: value):table or value — возвращает метатаблицу, обходя поле __metatable.​ Также отсутствует в OC.

Теперь, я думаю, можно приступить к самим метаметодам. Для своего, а может быть и вашего удобства я их разделю на четыре категории:

Разное

Начну сразу с этой категории, т.к. здесь всё самое вкусное.

 
1) __index(self: value, key: value) — метаметод, который вызывается при попытке индексирования значения с этим метаметодом. В качестве аргументов функция получает само значение, как первый аргумент, и индекс как второй, возвращать должна любое значение под заданным индексом. Если значение-таблица, то вызывается только тогда, когда нет поля с искомым индексом в самой таблице. Если вам необходимо проигнорировать этот метаметод, используйте rawget(table: table, key: value):value, эта простая функция вернёт значение в самой таблице и не притронется к метаметоду. Пример:

 

local t = { }
setmetatable(t, { __index = _G })
t:print()

--то же самое с помощью функции
t = setmetatable(t, {
    __index = function(self, key)
        return _G[key]
    end
})
t:print()

 

 
2) __newindex(self: value, key: value, value: value) — делает то же что и __index, только наоборот. Этот метаметод вызывается, когда значению, присваивают что-нибудь под каким-нибудь индексом. Также можно установить вместо функции таблицу, куда будут уходить все новые значения под новыми индексами. Если ваше значение с метатаблицей — таблица, то вы можете вставить поле прямо в неё, избегая метометод, с помощью rawset(table: table, key: value, value: value):nil. Пример:

 

--Давайте сделаем таблицу, которую нельзя обойти стандартными итераторами
local t = { }
local private = { }
setmetatable(t, {
    __index = private;
    __newindex = private;
})
t.var = 23
t.var2 = 42

for key, value in pairs(t) do --По сути ничего неделает
    print(key, value)
end

print(t.var)
--> 23

print(t.var2)
--> 42 

 

 
3) __call(self: value, args: ... ) — превращает любое значение с метатаблицей в типа функцию. С ним вы можете вызвать ваше значение, как функцию. Первым аргументом всегда будет само значение, остальные — это те которые были указаны при вызове функции. Пример:

 

local t = { }
setmetatable(t, {
    __call = function(self, String)
        table.insert(self, String)
        return true
    end
})

print(t("Hello!"))
--> true

print(t[1])
--> Hello! 

 

 
4) __metatable: value — это не метаметод, это просто поле, которое содержит информацию, которая будет возвращаться функцией getmetatable(value: value):value. Также при наличии этого поля не удастся сменить метатаблицу с помощью setmetatable(value: value, metatable: table):table на другую: выскочит ошибка. Чтобы проигнорировать этот параметр можно использовать функции из библиотеки debug.
 
5) __tostring(self: value) — при попытке перевести значение в строку будет вызван этот метаметод, использован же будет его результат. Пример:

 

local t = { }
setmetatable(t, {
    __tostring = function(self)
        return "Я - таблица!"
    end
})

print(tostring(t))
--> Я - таблица!

print(t) --Да, да. Это также работает.
--> Я - таблица! 

 

 
6) __len(self: value) — взаимодействует с оператором #. Если вы хотите проигнорировать этот метаметод в значении таблица, просто используйте table.getn(table: table):number. Не знаю, что добавить, смотрите пример. Пример:

 

local t = { }
setmetatable(t, {
    __len = function(self)
        return 3 --Размер этого "массива" теперь всегда 3
    end
})

for i = 1, 8 do
    table.insert(t, i)
end
-- В массиве теперь 8 элементов,

print(#t) -- но результат всё равно 3
--> 3 

 

 
7) __pairs(self: value) — заменяет собой функцию pairs(table: table), должен возвращать итератор, как минимум. Проигнорировать можно, подставив стандартный итератор next(level: number, table: table):value, value.
 
8) __ipairs(self: value) — то же самое, но для ipairs(table: table). Стандартный итератор — __inext(level: number, table: table):value, value (не удивляйтесь двойному подчёркиванию, это не метаметод, а стандартная функция глобального окружения).

 

9) __name: string — метаполе, которое используется при возникновении ошибки. Это поле в метатаблице наверняка существует для типа userdata, но также успешно работает с таблицами. Когда срабатывает ошибка несоответствия типов данных, то Lua заменяет слово, обозначающее этот тип данных, на то, что хранится в __name (при условии, что __name — строка). Для понимания того, что вы сейчас прочитали, пример:

 

t = setmetatable({}, { __name = "qwerty" }) -- Переименовываем table в qwerty
print(type(t)) -- Никак не влияет на type
--> table

math.sqrt(t) -- t - не число, а из таблицы корень не получишь
--[[
    Этот код выдаст примерно следующую ошибку:
stdin:2: bad argument #1 to 'sqrt' (number expected, got qwerty)
]]

 

 

---

 
Следующие два метаметода взаимодействуют со сборщиком мусора в Lua. На разных версиях lua они немного отличаются по возможностям. Я опишу, как они работают на lua 5.3.
 
10) __gc(self: value) — вызывается, когда сборщик мусора хочет удалить объект из памяти. По некоторым данным не работает с таблицами, но я протестировал в Lua интерпритаторе, и всё вроде как функционирует  . Я думаю, что этот метаметод может заменить собой деструктор "класса" в Lua. Пример:

 

setmetatable({ }, {
    __gc = function(self)
        print(self, " был удалён с ОЗУ")
    end
})

--[[ Через какое-то время ленивый сборщик мусора удалит вашу таблицу, и вы увидите этот знаменательный момент]] 

 

 
11) __mode: string — параметр, указывающий на то, что таблица не может защитить ключи или значения от безжалостного сборщика мусора. Если __mode == "k", то при не нахождении переменной содержащей, значение равное этому ключу, сборщик мусора спокойно удалит это поле и из таблицы тоже, если же __mode == "v", то тоже самое он будет делать для значений в таблице. Полностью правильно это будет работать только если удаляемые ключи и значения не являются: строкой, boolean или числом (это связано с особенностью работы сборщика). Пример:

 

local t = setmetatable({ }, { __mode = "v" })

do
    local var = {}
    t.var = var
end

print(t.var)
--> table: XXXXXXXXXXX

-- После очередного сбора мусора
print(t.var)
--> nil 

 

 
Математические

1) __unm(self: value) — унарный минус, это, когда var = -value. В качестве аргумента получает само значение. Думаю, примеры здесь не нужны.

---

 

Следующие метаметоды однотипны, поэтому я опишу принцип действия для всех, а потом с какими операторами они взаимодействуют.

Принцип действия: сначала Lua смотрит на первое значение в действии, если оно содержит метатаблицу с метаметодом этого действия, то он вызывается, и решением этого действия становится результат метаметода (то, что он вернёт). Если не находит смотрит во втором значении и проделывает тоже самое, если ненаходит ни там ни там, то действует по стандартному алгоритму. При постановке аргументов в метаметоде использует их изначальный порядок (то есть 2 + 3 будет вызывать __add(2, 3))  Надеюсь объяснил понятно.

 

2) __add(op1: value, op2: value) — операция сложения. Оператор +.

 

3) __sub(op1: value, op2: value) — операция вычитания. Оператор -.

 

4) __mul(op1: value, op2: value) — операция умножения. Оператор *.

 

5) __div(op1: value, op2: value) — операция деления. Оператор /.

 

6) __mod(op1: value, op2: value) — операция получения остатка от деления. Оператор %.

 

7) __pow(op1: value, op2: value) — операция возведения в степень. Оператор ^. Игнорируется функцией math.pow(op1: number, op2: number):number.

 

8) __concat(op1: value, op2: value) — операция конкатенации (склейки). Оператор ... Игнорируется функцией table.concat(table: table[, insert_string: string, begin: number, end: number]):string.

 

9) __idiv(op1: value, op2: value) — операция целочисленного деления. Оператор //. Появился в Lua 5.3.

 

Пример один на всех, но только с операцией сложения:

local _42 = { }
setmetatable(_42, {
    __add = function(op1, op2)
        op1 = type(op1) == "table" and 42 or op1 --Если первый аргумент - таблица, то присваиваем ему значение 42, иначе его изначальное значение
        op2 = type(op2) == "table" and 42 or op2 --Проделываем то же самое
        return op1 + op2 --Складываем и возвращаем результат
    end
})

print(_42 + 8)
--> 50

print(8 + _42)
--> 50
print(_42 + _42)
--> 84
print({} + _42)
--> 84

Немного странный результат у последнего примера, правда?   Попробуйте это объяснить.

 

Сравнение

local t1 = {}
local t2 = {}
local __eq = function(op1, op2)
    print "Работает"
    return op1
end
setmetatable(t1, { __eq = __eq })
setmetatable(t2, {
    __eq = function(op1, op2)
        print "Работает"
        return op1
    end
})

print(t1 == t2) --__eq не вызвался, т.к. методы в метатаблицах разные.
--> false

setmetatable(t2, { __eq = __eq })
print(t1 == t2) --Метод успешно вызван
--> Работает
--> true

print(t1 == t1) --Не вызван, т.к. одинаковы
--> true 

local meta = getmetatable(io.stdout)

function meta.__shl(ostream, data)
    return ostream:write(tostring(data))
end

local cout = io.stdout
local endl = "\n"

cout = cout << "Я люблю C++!" << endl
            << "Число: " << math.pi << endl
            << cout;

local a = "Hi"
local b = "World"
return {
  a = a,
  b = b
}

Вполне себе нормальный, имеющий право на жизнь, код. Не то, что бы он делал что-то полезное, но как пример нашей дискусси вполне сгодится.

Итак, этот небольшой файлик будет возвращает таблицу с двумя ключами. Подключим его (./test.lua):

local test = require("test")
print(test.a, test.b)

Выведет это "Hi      World" и успокоится. Вроде всё нормально.

Допишем в этот файл ещё немного кода:

test.a = "Goodbye"
b = "Cruel World"
test2 = require("lib")
print(test2.a, test2.b)

Выведет это, однако, Goodbye Cruel World. Упс.

Если в таблице будет реализация бомбёжки ракетами по союзникам (а как же), изменять что-то не хотелось бы совсем. Вот об неизменяемости речь и пойдёт.

Заметим, что в таблице либы ключам значение присваивается не напрямую, а через переменную. Локальную. Доступа к ним (проигнорим debug) ни у кого другого нет. С другой стороны, у Луа есть метатаблицы с метаметодом __index. Воспользуемся этим, прямолинейно:

local a = "Hi"
local b = "World"
return setmetatable({}, {
  __index = function(self, k)
    if k == "a" then
      return a
    elseif k == "b" then
      return b
    end
  end
})

Код ./test.lua можно даже не менять. Результат всё равно будет тот же. Ибо __index вызывается только для несуществующих значений основной таблицы. Когда мы присвоим какое-то значение, вызываться не будет уже метаметод. Ага, значит, давайте запретим заменять таблицу. При tbl.keyname = value вызывается метаметод __newindex. Окей:

local a = "Hi"
local b = "World"
return setmetatable({}, {
  __index = function(self, k)
    if k == "a" then
      return a
    else
      return b
    end
  end,
  __newindex = function(self, k, v)
    print("No way!")
  end
})

Теперь, если мы запустим код тот же, получим что-то вроде этого:

Hi      World
No way!
No way!
Hi      World

Воооот, вроде бы цель достигнута. Как бы не так. Заменим файл ./test.lua этим:

local test = require("test")
print(test.a, test.b)
rawset(test, "a", "Goodbye")
rawset(test, "b", "Cruel World")
test2 = require("lib")
print(test2.a, test2.b)

Угадайте, что получится. Конечно же, большой и длинный "ууупс".

Hi      World
Goodbye Cruel World

Более того, теперь эти значения сидят в обычной таблице и больше не вызывают __newindex. Вот печаль-то.

Но тем не менее, именно такой код мы и оставим. Для решения проблемы нам потребуется переопределить rawget и rawset, добавив проверку на наши любимые таблицы и не давая ничего изменить. Получится это сделать только для систем с доступом к контролю над _G.

Есть ещё вариант докопаться до сути: getmetatable и setmetatable. Их, как можно догадаться, тоже требуется переопределить. Туда же debug.getmetatable и debug.setmetatable.

После этого можно будет, наконец, сказать. что мы полностью уверены, что наши таблицы константны.

Как видно, Луа всеми силами пытается забрать право на забирание динамичности структур. Позволяя стандартно переопределять внутри VM стандартные функции для своих нужд, И просто так отплясаться не получится. Шмактус, однако.

OR

var = znach1 or znach2

local znach1 = true
local znach2 = false
local var

var = znach1 or znach2 -- Вернёт znach1, то-есть true
var = znach2 or znach1 -- Вернёт znach1, то-есть true
var = false or nil -- Вернёт nil

AND

var = znach1 or znach2

var = true and false -- Вернёт второе, то-есть false
var = false and true -- Вернёт znach1, то-есть true
var = true and 42 -- Вернёт второе, то-есть 42
var = nil and 42 -- Вернёт первое, то-есть nil
var = false and nil -- Вернёт false

NOT

var = not znach

var = true and false -- Вернёт второе, то-есть false
var = not false -- Вернёт true
var = not true -- Вернёт false
var = not nil -- Вернёт true
var = not 42 -- Вернёт false
var = not not 42 -- Вернёт true

Теперь можно показать самые используемые выражения.

Наверняка у вас был случай, когда нужно, чтобы переменная приравнялась одному значению, а если его нет, то другому. Многие записали бы так:

if var == nil then
    var = 23
end

Это конечно работает, но не лучше ли записать так:

var = var or 23

Кратко и красиво, да к тому же нет лишнего логического блока. Вы также можете продолжить эту цепочку:

var = var or var2 or var3 or 23

В такой цепочке выражение вернёт первое истинное значение, при этом не трогая все те что за ним. Это значит, что вы спокойно можете сделать так:

var = var or error("Переменная var содержит ложное значение!")

И радовались бы дальше, но ведь иногда нам нужно, придать значение переменной в зависимости от истинности выражения. Не зная удобного способа, вы бы сделали так:

if var then
    var2 = 23
else
    var2 = 42
end

Но это можно записать без логического блока:

var2 = var and 23 or 42

Вы можете заменить переменную var любым выражением, но если вы плохо разбираетесь в приоритетах операторов рекомендую выделять скобками:

var2 = (var > 0) and 23 or 42 -- В данном примере скобки не обязательны

Теперь давайте основываясь на узнанном, напишем функцию с проверкой аргумента:

function func(var)
    var = type(var) == "number" and var == math.floor(var) and var or error("bad argument: celoe number expected, got "..var, 2)
end

И заметьте ни одного логического блока. В результате наша функция проверит является ли аргумент целым числом, иначе вернёт ошибку.

Бывает случай, когда необходимо проверить существует ли поле в таблице и выполнять действия в зависимости от этого, но ведь значение может быть не таблицей, из-за этого ошибка будет не пользователя а ваша. Я не буду приводить всякие отдельные случаи просто напишу само выражение:

if not (type(table) == "table" and table.field and ...) then -- ... - ваши логические выражения
    -- Какие-то действия
end

Ещё один важный момент, когда аргумент вашей функции может быть не указан, но потом внутри самой функции обретает значение типа boolean (true либо false) через оператор or это не выполнить, т.к. false - ложное значение, но можно воспользоваться следующими выражениями, в зависимости от того, что вам нужно:

var = var ~= false -- Если var = nil, то вернёт true, если переменная типа boolean не изменит её значения
var = not not var -- То же, что и первое, но при значении nil вернёт false

Думаю, что наиболее используемые моменты осветил, но если что-то не понятно, спрашивайте.

[ok=Ни один смайлик не использован][/ok]