times divide

veclib library version 2.0.0

`RtbRdrb`

void nasvec_RtbRdrb_f(float A, 
                      float B, 
                      float *C, int strideC, 
                      float *D, int strideD, 
                      unsigned int n)

A : real scalar
B : real scalar
C : real vector
D : real vector

D[i*strideD] = A * (B / C[i*strideC]), i = 0,1,2,...,n-1

`RtbrdRb`

void nasvec_RtbrdRb_f(float A, 
                      float *B, int strideB, 
                      float C, 
                      float *D, int strideD, 
                      unsigned int n)

A : real scalar
B : real vector
C : real scalar
D : real vector

D[i*strideD] = A * (B[i*strideB] / C), i = 0,1,2,...,n-1

`Rtbrdrb`

void nasvec_Rtbrdrb_f(float A, 
                      float *B, int strideB, 
                      float *C, int strideC, 
                      float *D, int strideD, 
                      unsigned int n)

A : real scalar
B : real vector
C : real vector
D : real vector

D[i*strideD] = A * (B[i*strideB] / C[i*strideC]), i = 0,1,2,...,n-1

`bRtRbdr`

void nasvec_bRtRbdr_f(float A, 
                      float B, 
                      float *C, int strideC, 
                      float *D, int strideD, 
                      unsigned int n)

A : real scalar
B : real scalar
C : real vector
D : real vector

D[i*strideD] = (A * B) / C[i*strideC], i = 0,1,2,...,n-1

`bRtrbdR`

void nasvec_bRtrbdR_f(float A, 
                      float *B, int strideB, 
                      float C, 
                      float *D, int strideD, 
                      unsigned int n)

A : real scalar
B : real vector
C : real scalar
D : real vector

D[i*strideD] = (A * B[i*strideB]) / C, i = 0,1,2,...,n-1

`bRtrbdr`

void nasvec_bRtrbdr_f(float A, 
                      float *B, int strideB, 
                      float *C, int strideC, 
                      float *D, int strideD, 
                      unsigned int n)

A : real scalar
B : real vector
C : real vector
D : real vector

D[i*strideD] = (A * B[i*strideB]) / C[i*strideC], i = 0,1,2,...,n-1

`brtRbdR`

void nasvec_brtRbdR_f(float *A, int strideA, 
                      float B, 
                      float C, 
                      float *D, int strideD, 
                      unsigned int n)

A : real vector
B : real scalar
C : real scalar
D : real vector

D[i*strideD] = (A[i*strideA] * B) / C, i = 0,1,2,...,n-1

`brtRbdr`

void nasvec_brtRbdr_f(float *A, int strideA, 
                      float B, 
                      float *C, int strideC, 
                      float *D, int strideD, 
                      unsigned int n)

A : real vector
B : real scalar
C : real vector
D : real vector

D[i*strideD] = (A[i*strideA] * B) / C[i*strideC], i = 0,1,2,...,n-1

`brtrbdR`

void nasvec_brtrbdR_f(float *A, int strideA, 
                      float *B, int strideB, 
                      float C, 
                      float *D, int strideD, 
                      unsigned int n)

A : real vector
B : real vector
C : real scalar
D : real vector

D[i*strideD] = (A[i*strideA] * B[i*strideB]) / C, i = 0,1,2,...,n-1

`brtrbdr`

void nasvec_brtrbdr_f(float *A, int strideA, 
                      float *B, int strideB, 
                      float *C, int strideC, 
                      float *D, int strideD, 
                      unsigned int n)

A : real vector
B : real vector
C : real vector
D : real vector

D[i*strideD] = (A[i*strideA] * B[i*strideB]) / C[i*strideC], i = 0,1,2,...,n-1

`rtbRdRb`

void nasvec_rtbRdRb_f(float *A, int strideA, 
                      float B, 
                      float C, 
                      float *D, int strideD, 
                      unsigned int n)

A : real vector
B : real scalar
C : real scalar
D : real vector

D[i*strideD] = A[i*strideA] * (B / C), i = 0,1,2,...,n-1

`rtbRdrb`

void nasvec_rtbRdrb_f(float *A, int strideA, 
                      float B, 
                      float *C, int strideC, 
                      float *D, int strideD, 
                      unsigned int n)

A : real vector
B : real scalar
C : real vector
D : real vector

D[i*strideD] = A[i*strideA] * (B / C[i*strideC]), i = 0,1,2,...,n-1

`rtbrdRb`

void nasvec_rtbrdRb_f(float *A, int strideA, 
                      float *B, int strideB, 
                      float C, 
                      float *D, int strideD, 
                      unsigned int n)

A : real vector
B : real vector
C : real scalar
D : real vector

D[i*strideD] = A[i*strideA] * (B[i*strideB] / C), i = 0,1,2,...,n-1

`rtbrdrb`

void nasvec_rtbrdrb_f(float *A, int strideA, 
                      float *B, int strideB, 
                      float *C, int strideC, 
                      float *D, int strideD, 
                      unsigned int n)

A : real vector
B : real vector
C : real vector
D : real vector

D[i*strideD] = A[i*strideA] * (B[i*strideB] / C[i*strideC]), i = 0,1,2,...,n-1

Ternary - real vector/scalar index