blas_level_1.c

Go to the documentation of this file.

/*****************************************************************************
 *
 * MODULE:       Grass Gmath Library
 * AUTHOR(S):    Soeren Gebbert, Berlin (GER) Dec 2007
 *              soerengebbert <at> gmx <dot> de
 *               
 * PURPOSE:      blas level 1 like functions   
 *              part of the gmath library
 *               
 * COPYRIGHT:    (C) 2000 by the GRASS Development Team
 *
 *               This program is free software under the GNU General Public
 *               License (>=v2). Read the file COPYING that comes with GRASS
 *               for details.
 *
 *****************************************************************************/

#include <math.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <grass/gmath.h>
#include <grass/gis.h>

/* **************************************************************** */
/* *************** D O U B L E ************************************ */
/* **************************************************************** */

void G_math_d_x_dot_y(double *x, double *y, double *value, int rows)
{
    int i;

    double s = 0.0;

#pragma omp parallel for schedule (static) reduction(+:s)
    for (i = rows - 1; i >= 0; i--) {
        s += x[i] * y[i];
    }
#pragma omp single
    {
        *value = s;
    }
    return;
}

void G_math_d_euclid_norm(double *x, double *value, int rows)
{
    int i;

    double s = 0.0;

#pragma omp parallel for schedule (static) reduction(+:s)
    for (i = rows - 1; i >= 0; i--) {
        s += x[i] * x[i];
    }
#pragma omp single
    {
        *value = sqrt(s);
    }
    return;
}

void G_math_d_asum_norm(double *x, double *value, int rows)
{
    int i = 0;

    double s = 0.0;

#pragma omp parallel for schedule (static) reduction(+:s)
    for (i = rows - 1; i >= 0; i--) {
        s += fabs(x[i]);
    }
#pragma omp single
    {
        *value = s;
    }
    return;
}

void G_math_d_max_norm(double *x, double *value, int rows)
{
    int i;

    double max = 0.0;

    max = fabs(x[rows - 1]);
    for (i = rows - 2; i >= 0; i--) {
        if (max < fabs(x[i]))
            max = fabs(x[i]);
    }

    *value = max;
}

void G_math_d_ax_by(double *x, double *y, double *z, double a, double b,
                    int rows)
{
    int i;

    /*find specific cases */
    if (b == 0.0) {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = a * x[i];
        }
    }
    else if ((a == 1.0) && (b == 1.0)) {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = x[i] + y[i];
        }
    }
    else if ((a == 1.0) && (b == -1.0)) {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = x[i] - y[i];
        }
    }
    else if (a == b) {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = a * (x[i] + y[i]);
        }
    }
    else if (b == -1.0) {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = a * x[i] - y[i];
        }
    }
    else if (b == 1.0) {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = a * x[i] + y[i];
        }
    }
    else {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = a * x[i] + b * y[i];
        }
    }

    return;
}

void G_math_d_copy(double *x, double *y, int rows)
{
    y = memcpy(y, x, rows * sizeof(double));

    return;
}

/* **************************************************************** */
/* *************** F L O A T ************************************** */
/* **************************************************************** */

void G_math_f_x_dot_y(float *x, float *y, float *value, int rows)
{
    int i;

    float s = 0.0;

#pragma omp parallel for schedule (static) reduction(+:s)
    for (i = rows - 1; i >= 0; i--) {
        s += x[i] * y[i];
    }
#pragma omp single
    {
        *value = s;
    }
    return;
}

void G_math_f_euclid_norm(float *x, float *value, int rows)
{
    int i;

    float s = 0.0;

#pragma omp parallel for schedule (static) reduction(+:s)
    for (i = rows - 1; i >= 0; i--) {
        s += x[i] * x[i];
    }
#pragma omp single
    {
        *value = sqrt(s);
    }
    return;
}

void G_math_f_asum_norm(float *x, float *value, int rows)
{
    int i;

    int count = 0;

    float s = 0.0;

#pragma omp parallel for schedule (static) private(i) reduction(+:s, count)
    for (i = 0; i < rows; i++) {
        s += fabs(x[i]);
        count++;
    }
#pragma omp single
    {
        *value = s;
    }
    return;
}

void G_math_f_max_norm(float *x, float *value, int rows)
{
    int i;

    float max = 0.0;

    max = fabs(x[rows - 1]);
    for (i = rows - 2; i >= 0; i--) {
        if (max < fabs(x[i]))
            max = fabs(x[i]);
    }
    *value = max;
    return;
}

void G_math_f_ax_by(float *x, float *y, float *z, float a, float b, int rows)
{
    int i;

    /*find specific cases */
    if (b == 0.0) {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = a * x[i];
        }
    }
    else if ((a == 1.0) && (b == 1.0)) {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = x[i] + y[i];
        }
    }
    else if ((a == 1.0) && (b == -1.0)) {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = x[i] - y[i];
        }
    }
    else if (a == b) {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = a * (x[i] + y[i]);
        }
    }
    else if (b == -1.0) {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = a * x[i] - y[i];
        }
    }
    else if (b == 1.0) {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = a * x[i] + y[i];
        }
    }
    else {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = a * x[i] + b * y[i];
        }
    }

    return;
}

void G_math_f_copy(float *x, float *y, int rows)
{
    y = memcpy(y, x, rows * sizeof(float));

    return;
}

/* **************************************************************** */
/* *************** I N T E G E R ********************************** */
/* **************************************************************** */

void G_math_i_x_dot_y(int *x, int *y, double *value, int rows)
{
    int i;

    double s = 0.0;

#pragma omp parallel for schedule (static) reduction(+:s)
    for (i = rows - 1; i >= 0; i--) {
        s += x[i] * y[i];
    }
#pragma omp single
    {
        *value = s;
    }
    return;
}

void G_math_i_euclid_norm(int *x, double *value, int rows)
{
    int i;

    double s = 0.0;

#pragma omp parallel for schedule (static) reduction(+:s)
    for (i = rows - 1; i >= 0; i--) {
        s += x[i] * x[i];
    }
#pragma omp single
    {
        *value = sqrt(s);
    }
    return;
}

void G_math_i_asum_norm(int *x, double *value, int rows)
{
    int i;

    double s = 0.0;

#pragma omp parallel for schedule (static) reduction(+:s)
    for (i = rows - 1; i >= 0; i--) {
        s += fabs(x[i]);
    }
#pragma omp single
    {
        *value = s;
    }
    return;
}

void G_math_i_max_norm(int *x, int *value, int rows)
{
    int i;

    int max = 0.0;

    max = fabs(x[rows - 1]);
    for (i = rows - 2; i >= 0; i--) {
        if (max < fabs(x[i]))
            max = fabs(x[i]);
    }

    *value = max;
}

void G_math_i_ax_by(int *x, int *y, int *z, int a, int b, int rows)
{
    int i;

    /*find specific cases */
    if (b == 0.0) {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = a * x[i];
        }
    }
    else if ((a == 1.0) && (b == 1.0)) {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = x[i] + y[i];
        }
    }
    else if ((a == 1.0) && (b == -1.0)) {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = x[i] - y[i];
        }
    }
    else if (a == b) {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = a * (x[i] + y[i]);
        }
    }
    else if (b == -1.0) {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = a * x[i] - y[i];
        }
    }
    else if (b == 1.0) {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = a * x[i] + y[i];
        }
    }
    else {
#pragma omp for schedule (static)
        for (i = rows - 1; i >= 0; i--) {
            z[i] = a * x[i] + b * y[i];
        }
    }

    return;
}

void G_math_i_copy(int *x, int *y, int rows)
{
    y = memcpy(y, x, rows * sizeof(int));

    return;
}