Plan to support Asteroids and spawn_definitions?

[PennyJim]

I'm wondering if some asteroid utilities would suit this library.

I've got a rewrite of asteroid-spawn-definitions from Space Age with the intent of supporting arbitrary asteroids instead of just the Space Age ones. I'll admit that I haven't actually tested it, but I'm asking if it would fit this library to figure out if it's worth the effort to actually test the code I wrote offhandedly a while back.

It's got the chunk -> small -> medium -> big -> huge baked in just like the original, which is why I'm also imagining a way of bulk defining the asteroids. Though I don't really know much of how asteroids are defined so that's a later idea.

[danielmartin0]

PRs regarding asteroid-spawn-definitions are definitely of interest. Modded asteroids and route definitions using the existing asteroids are awkward for modders to set up. Note I'd want to be reducing complexity for modders rather than increasing it.

[PennyJim]

Yeah so I'll probably leave AsteroidPrototype functions to someone else. My asteroid-spawn-definitions rewrite is functionally the same thing as Space Age's, but with the ratios a dictionary instead of 4 element array.

[nicholasgower]

If there was a way to express asteroid spawn rates as a combination of heaviside functions and integrals of heaviside functions, that would be very interesting and make asteroid spawn definitions, especially ones with more complex spawn defintions, easier to define.

https://en.wikipedia.org/wiki/Heaviside_step_function

[nicholasgower]

Perhaps there's demand for a math lib that can generate more complex equations by replacing functions within a math expression string with mathematical functions that Factorio math expressions can understand.

https://lua-api.factorio.com/latest/concepts/MathExpression.html

abs(value): Returns absolute value of the given argument; i.e. if the argument is negative, it is inverted.

log2(value): Returns a binary logarithm of the given value.

sign(value): Returns -1 for negative numbers, 0 for zero (regardless of sign), 1 for positive numbers

max(value1, value2, ...): Returns the greater of the given values. Supports between 2 and 255 arguments.

min(value1, value2, ...): Returns the smaller of the given values. Supports between 2 and 255 arguments.

Some possible useful expressions:

log10(x): log2(x)/log2(x)
factorial(x): x*(x-1)(x-2)...1 (assert x is integer)
cos(x): Taylor series for cos(x), not going to copy it here.
pi: 3.141592653
sin(x): cos(x-pi)
tan(x): sin(x)/cos(x)
sing(x,n): Singularity function : x^n*(min(0,x))/x*min(n,0)/n

I don't know if anything like this exists or not. If this exists, please link it here.

[nicholasgower]

Perhaps there's demand for a math lib that can generate more complex equations by replacing functions within a math expression string with mathematical functions that Factorio math expressions can understand.

https://lua-api.factorio.com/latest/concepts/MathExpression.html

abs(value): Returns absolute value of the given argument; i.e. if the argument is negative, it is inverted.

log2(value): Returns a binary logarithm of the given value.

sign(value): Returns -1 for negative numbers, 0 for zero (regardless of sign), 1 for positive numbers

max(value1, value2, ...): Returns the greater of the given values. Supports between 2 and 255 arguments.

min(value1, value2, ...): Returns the smaller of the given values. Supports between 2 and 255 arguments.

Some possible useful expressions:

log10(x): log2(x)/log2(x) factorial(x): x*(x-1)(x-2)...1 (assert x is integer) cos(x): Taylor series for cos(x), not going to copy it here. pi: 3.141592653 sin(x): cos(x-pi) tan(x): sin(x)/cos(x) sing(x,n): Singularity function : x^n*(min(0,x))/x*min(n,0)/n

I don't know if anything like this exists or not. If this exists, please link it here.

After giving this problem to ChatGPT, I have come to this solution to my problem.

local math_lib = {}

-- Constants
local constants = {
    pi = "3.141592653"
}

-- Helper function for factorial (recursive implementation as a string-based equation)
local function factorial_recursive(x)
    if x == 1 then
        return "1"
    else
        return x .. "*" .. factorial_recursive(x - 1)
    end
end

-- Function map for extended math expressions
local function_map = {
    -- log10(x): log2(x)/log2(10)
    log10 = function(x)
        return "log2(" .. x .. ")/log2(10)"
    end,

    -- factorial(x): x*(x-1)*(x-2)...*1
    factorial = function(x)
        return factorial_recursive(tonumber(x))
    end,

    -- cos(x): Taylor series expansion (simplified for a few terms)
    cos = function(x)
        return "1 - (" .. x .. "^2)/2 + (" .. x .. "^4)/24 - (" .. x .. "^6)/720"
    end,

    -- sin(x): cos(x - pi/2)
    sin = function(x)
        return "1 - ((" .. x .. "-" .. constants.pi .. "/2)^2)/2 + ((" .. x .. "-" .. constants.pi .. "/2)^4)/24 - ((" .. x .. "-" .. constants.pi .. "/2)^6)/720"
    end,

    

    -- Singularity function: x^n * min(0, x) / x * min(n, 0) / n
    sing = function(x, n)
        return "(" .. x .. "^" .. n .. ")*(min(0," .. x .. "))/(" .. x .. "*min(" .. n .. ",0)/" .. n .. ")"
    end
}

function_map["tan"] = function(x)
  -- tan(x): sin(x)/cos(x), expanded with their internal representations
    
        local sin_x = function_map.sin(x)
        local cos_x = function_map.cos(x)
        return "(" .. sin_x .. ")/(" .. cos_x .. ")"
    end


-- Function to replace extended math functions with Factorio-compatible math expressions
function math_lib.replace_functions(expression)
    for func_name, func_impl in pairs(function_map) do
        -- Match the function pattern and replace with implementation
        expression = expression:gsub(func_name .. "%(([^)]+)%)", function(args)
            local arg_list = {}
            for arg in args:gmatch("[^,]+") do
                table.insert(arg_list, arg)
            end
            return func_impl(table.unpack(arg_list))
        end)
    end

    -- Replace constants in the expression
    for const_name, const_value in pairs(constants) do
        expression = expression:gsub(const_name, const_value)
    end

    return expression
end

-- Example Usage
local example_expression = "tan(z)"
local replaced_expression = math_lib.replace_functions(example_expression)
print("Original Expression: " .. example_expression)
print("Replaced Expression: " .. replaced_expression)

return math_lib