Low-Level Evaluation

[panic-at-the-disko]

When considering an expression in libfive such as min(self, other) where self and other are non-constant, passing individual values to evaluate the expression at specific points is straight-forward. However, my understanding is that evaluation in libfive returns continuous output/more than a collection sampled points.

How is this type of evaluation actually performed by libfive/its tree structures and the CPU? If continuity isn't actually present, is there a sampling resolution at which all of the points "collapse" into a continuous field due to roundoff or some other effect?

[mkeeter]

Evaluation works by converting a math tree into a "tape", which is a series of individual math operations with input and output locations. For example, cos(X + 1) could become

$1 = X
$2 = 1.0
$3 = $1 + $2
$4 = cos($3)

This tape is then evaluated by one or more interpreters, which are specialized for a particular kind of evaluation. For example, the ArrayEvaluator evaluates an array of single points; the DerivArrayEvaluator performs both value and partial derivatives.

Here's an actual example of the evaluation loop.

This means evaluation can take place at any float x, y, z position. We're eventually limited by floating-point resolution, and the exact limits will depend on the structure of the math equation (e.g. order could matter in rare cases).

[panic-at-the-disko]

Thank you! I suppose what I don't grasp is while single point evaluation can happen at any float x, y, z position, how is the number and location of points determined when performing binary operations?

For example, in $3 = $1 + $2 in the ArrayEvaluator :

To perform the addition, it appears that some sampling has to happen, since an operation a+b amonts to matrix/vector addition considering
#define a v.row(a_).head(count_simd)
#define b v.row(b_).head(count_simd)

With $2 = 2.0 being a constant in this case, the sampling question seems to fall upon $1. With X() initially defined as a free variable, how the is conversion from a free variable to a vector/sampled values handled? A libfive interval or region could be defined that provides bounds, but is single point evaluation performed in between?

[mkeeter]

Okay, I think I see the issue here – the code that you pasted allows us to evaluate multiple XYZ points in a single pass, which is an optimization, but is misleading if you're just trying to understand the basic evaluation procedure for a single XYZ point.

Before the evaluation loop, XYZ positions are loaded into an array v with the set function.

If you're evaluating a single point, you would call ArrayEvaluator::value({x, y, z}). This would call set to load that point into the 0th slot in the data array, then ask for only one sample when evaluating here.

If you want to sample, then you could load multiple values by calling

ArrayEvaluator a = ...;
a.set({x0, y0, z0}, 0);
a.set({x1, y1, x1}, 1);
...

Then you'd call a.values(NUMBER_OF_VALUES) and it would return the array of results for all of your values.

In other words, the ArrayEvaluator is very dumb and will only run on XYZ point data that you've already loaded; if you want to do any sampling, you have to handle it yourself.

[panic-at-the-disko]

Thank you!!