Vector Operations Extension to SV

Sun Jun 19 08:03:34 2022 · ignored

x[1] * y[2] - y[1] * x[2]
x[2] * y[0] - y[2] * x[0]
x[0] * y[1] - y[0] * x[1]

vec3 a, b; // elements in order a.x, a.y, a.z
// compute a cross b:
vec3 t1 = a.yzx; // produce vector [a.y, a.z, a.x]
vec3 t2 = b.zxy;
vec3 t3 = a.zxy;
vec3 t4 = b.yzx;
vec3 p = t3 * t4;
vec3 cross = t1 * t2 - p;

fswizzlei,2130 F4, F1
fswizzlei,1320 F5, F1
fswizzlei,2130 F6, F2
fswizzlei,1320 F7, F2
fmul F8, F5, F6
fmulsub F3, F4, F7, F8

from operator import mul
sum(map(mul, A, B))

double dot_product(float v[], float u[], int n)
{
    double result = 0.0;
    for (int i = 0; i < n; i++)
        result += v[i] * u[i];
    return result;
}

fdot F3, F1, F1 # vector dot with self
rcpsqrta F3, F3
fscale,0 F2, F3, F1

sqrt(x[0]^2 + x[1]^2 + ...).

length(v0 - v1)

// Imprecise method, which does not guarantee v = v1 when t = 1,
// due to floating-point arithmetic error.
// This form may be used when the hardware has a native fused 
// multiply-add instruction.
float lerp(float v0, float v1, float t) {
  return v0 + t * (v1 - v0);
}

// Precise method, which guarantees v = v1 when t = 1.
float lerp(float v0, float v1, float t) {
  return (1 - t) * v0 + t * v1;
}

Quaternion slerp(Quaternion v0, Quaternion v1, double t) {
    // Only unit quaternions are valid rotations.
    // Normalize to avoid undefined behavior.
    v0.normalize();
    v1.normalize();

    // Compute the cosine of the angle between the two vectors.
    double dot = dot_product(v0, v1);

    // If the dot product is negative, slerp won't take
    // the shorter path. Note that v1 and -v1 are equivalent when
    // the negation is applied to all four components. Fix by
    // reversing one quaternion.
    if (dot < 0.0f) {
        v1 = -v1;
        dot = -dot;
    }

    const double DOT_THRESHOLD = 0.9995;
    if (dot > DOT_THRESHOLD) {
        // If the inputs are too close for comfort, linearly interpolate
        // and normalize the result.

        Quaternion result = v0 + t*(v1 - v0);
        result.normalize();
        return result;
    }

    // Since dot is in range [0, DOT_THRESHOLD], acos is safe
    double theta_0 = acos(dot);        // theta_0 = angle between input vectors
    double theta = theta_0*t;          // theta = angle between v0 and result
    double sin_theta = sin(theta);     // compute this value only once
    double sin_theta_0 = sin(theta_0); // compute this value only once

    double s0 = cos(theta) - dot * sin_theta / sin_theta_0;  // == sin(theta_0 - theta) / sin(theta_0)
    double s1 = sin_theta / sin_theta_0;

    return (s0 * v0) + (s1 * v1);
}

function v = cordic(beta,n)
    % This function computes v = [cos(beta), sin(beta)] (beta in radians)
    % using n iterations. Increasing n will increase the precision.

    if beta < -pi/2 || beta > pi/2
        if beta < 0
            v = cordic(beta + pi, n);
        else
            v = cordic(beta - pi, n);
        end
        v = -v; % flip the sign for second or third quadrant
        return
    end

    % Initialization of tables of constants used by CORDIC
    % need a table of arctangents of negative powers of two, in radians:
    % angles = atan(2.^-(0:27));
    angles =  [  ...
        0.78539816339745   0.46364760900081   
        0.24497866312686   0.12435499454676 ...
        0.06241880999596   0.03123983343027   
        0.01562372862048   0.00781234106010 ...
        0.00390623013197   0.00195312251648   
        0.00097656218956   0.00048828121119 ...
        0.00024414062015   0.00012207031189   
        0.00006103515617   0.00003051757812 ...
        0.00001525878906   0.00000762939453   
        0.00000381469727   0.00000190734863 ...
        0.00000095367432   0.00000047683716   
        0.00000023841858   0.00000011920929 ...
        0.00000005960464   0.00000002980232   
        0.00000001490116   0.00000000745058 ];
    % and a table of products of reciprocal lengths of vectors [1, 2^-2j]:
    % Kvalues = cumprod(1./abs(1 + 1j*2.^(-(0:23))))
    Kvalues = [ ...
        0.70710678118655   0.63245553203368   
        0.61357199107790   0.60883391251775 ...
        0.60764825625617   0.60735177014130   
        0.60727764409353   0.60725911229889 ...
        0.60725447933256   0.60725332108988   
        0.60725303152913   0.60725295913894 ...
        0.60725294104140   0.60725293651701   
        0.60725293538591   0.60725293510314 ...
        0.60725293503245   0.60725293501477   
        0.60725293501035   0.60725293500925 ...
        0.60725293500897   0.60725293500890   
        0.60725293500889   0.60725293500888 ];
    Kn = Kvalues(min(n, length(Kvalues)));

    % Initialize loop variables:
    v = [1;0]; % start with 2-vector cosine and sine of zero
    poweroftwo = 1;
    angle = angles(1);

    % Iterations
    for j = 0:n-1;
        if beta < 0
            sigma = -1;
        else
            sigma = 1;
        end
        factor = sigma * poweroftwo;
        % Note the matrix multiplication can be done using scaling by 
        % powers of two and addition subtraction
        R = [1, -factor; factor, 1];
        v = R * v; % 2-by-2 matrix multiply
        beta = beta - sigma * angle; % update the remaining angle
        poweroftwo = poweroftwo / 2;
        % update the angle from table, or eventually by just dividing by two
        if j+2 > length(angles)
            angle = angle / 2;
        else
            angle = angles(j+2);
        end
    end

    % Adjust length of output vector to be [cos(beta), sin(beta)]:
    v = v * Kn;
    return

endfunction

x = v[0] - sigma * (v[1] * 2^(-j));
y = sigma * (v[0] * 2^(-j)) + v[1];
v = [x; y];

Instr	result	src1	src2	SUBVL	VL
VDOT rd, vs1, vs2	scal	vec	vec	2-4	any
VDOT rd, vs1, vs2	scal	vec	vec	1	any

Vector Operations Extension to SV

CORDIC

Vector cross product

Vector dot product

Vector Normalisation (not included)

Vector length

Vector distance

Vector LERP

Vector SLERP

Expensive 3-operand OP32 operations

Opcode Table

Links