Class Dobjects::Function
In: split/Dvector/dvector.c
split/Function/lib/Function_extras.rb
Parent: Object

Function is a class that embeds two Dvectors, one for X data and one for Y data. It provides

And getting bigger everyday…

Methods

bounds   compute_spline   compute_spline_data   distance   each   integrate   interpolate   is_sorted   joint_sort   length   make_interpolant   max   min   new   point   primitive   size   sort   sorted?   split_monotonic   strip_nan   x   y  

Public Class methods


Function.joint_sort(x,y)

Sorts x, while ensuring that the corresponding y values keep matching. Should be pretty fast, as it is derived from glibc’s quicksort. 

 a = Dvector[3,2,1]
 b = a * 2                 -> [6,4,2]
 Function.joint_sort(a,b)  -> [[1,2,3], [2,4,6]]

Function.new(x,y)

Creates a Function object with given x and y values.

Public Instance methods

bounds()

Returns [xmin, ymin, xmax, ymax]

compute_spline(p1)

Interpolates the value of the function at the points given. Returns a brand new Dvector. The X values must be sorted !

compute_spline_data()

Computes spline data and caches it inside the object. Both X and Y vectors are cleared (see Dvector#clear) to make sure the cache is kept up-to-date. If the function is not sorted, sorts it.


f.distance(x,y) → a_number
f.distance(x,y, xscale, yscale) → a_number

Returns the distance of the function to the given point. Optionnal xscale and yscale says by how much we should divide the x and y coordinates before computing the distance. Use it if the distance is not homogeneous.


f.each do |x,y| _code_ end

Iterates over all the points in the Function, yielding X and Y for each point.


f.integrate() → value
f.integrate(start_index, end_index) → value

: Returns the value of the integral of the function between the two indexes given, or over the whole function if no indexes are specified.


interpolate(x_values)
interpolate(a_number)

Computes interpolated values of the data contained in f and returns a Function object holding both x_values and the computed Y values. x_values will be sorted if necessary.

With the second form, specify only the number of points, and the function will construct the appropriate vector with equally spaced points within the function range.

is_sorted()

Alias for sorted?

length()

Alias for size

make_interpolant()

Returns an interpolant that can be fed to Special_Paths#append_interpolant_to_path to make nice splines.

Can be used this way: 

 f = Function.new(x,y)
 t.append_interpolant_to_path(f.make_interpolant)
 t.stroke
max()

Returns the point where Y is the maximum

min()

Returns the point where Y is the minimum

point(p1)

Returns a Dvector with two elements: the X and Y values of the point at the given index.

primitive()

Computes the primitive of the Function and returns it as a new Function. The newly created function shares the X vector with the previous one.

size()

Returns the number of points inside the function.

sort()

Sorts the X values while keeping the matching Y values.

sorted?()

Checks if the X values of the Function are sorted.

split_monotonic()

Splits the function into monotonic sub-functions. Returns the array of the subfunctions. The returned values are necessarily new values.

strip_nan()

Strips all the points containing NaN values from the function, and returns the number of points stripped.

x()

The X vector.

y()

The Y vector.

[Validate]