skewness_samp.c

Go to the documentation of this file.

/* skewness_samp.c (sample moment coefficient of skewness) */

/***********************************************************************
*  This code is part of Statistics for MySQL.
*
*  Copyright (C) 2011 Heinrich Schuchardt (xypron.glpk@gmx.de)
*
*  Licensed under the Apache License, Version 2.0 (the "License");
*  you may not use this file except in compliance with the License.
*  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
***********************************************************************/


#include "sqlstat.h"

struct skewness_samp_storage {
  int     argc;  
  double  count;  
  double  sumX;   
  double  sumXX;  
  double  sumXXX; 
};

my_bool skewness_samp_init(UDF_INIT *initid, UDF_ARGS *args, char *message) {
  struct skewness_samp_storage * data;

  if (args->arg_count < 1 || args->arg_count > 2) {
    strcpy(message,"skewness_coor() requires one or two arguments");
    return 1;
  }
  args->arg_type[0] = REAL_RESULT;
  if (args->arg_count > 1) {
    args->arg_type[1] = REAL_RESULT;
  }

  data = (struct skewness_samp_storage *) malloc( sizeof(struct skewness_samp_storage));
  if (data == NULL) {
    strcpy(message,"Couldn't allocate memory");
    return 1;
  }
  data->argc = args->arg_count;

  initid->maybe_null = 1;
  initid->decimals   = NOT_FIXED_DEC;
  initid->max_length = 13 + initid->decimals;
  initid->ptr        = (char *) data;
  initid->const_item = 0;

  return 0;
}

void skewness_samp_reset(UDF_INIT *initid, UDF_ARGS *args, char *is_null, char *error) {
  skewness_samp_clear(initid, is_null, error);
  skewness_samp_add(initid, args, is_null, error);
}

void skewness_samp_clear(UDF_INIT *initid, char *is_null, char *error) {
  struct skewness_samp_storage *data;
  data = (struct skewness_samp_storage *) initid->ptr;
  data->count = 0;
  data->sumX  = 0;
  data->sumXX = 0;
  data->sumXXX = 0;
}

void skewness_samp_add(UDF_INIT *initid, UDF_ARGS *args, char *is_null, char *error) {
  struct skewness_samp_storage * data;
  double x;
  double w;

  if (!args->args[0]) {
    return;
  }
  data = (struct skewness_samp_storage *) initid->ptr;
  if (data->argc > 1) {
    if (!args->args[1]) {
      return;
    }
    w = *((double*) args->args[1]);
  } else {
    w = 1.;
  }
  x = *((double*) args->args[0]);

  data->count  += w;
  data->sumX   += w * x;
  data->sumXX  += w * x*x;
  data->sumXXX += w * x*x*x;
}

double skewness_samp(UDF_INIT *initid, UDF_ARGS *args, char *is_null, char *error) {
  struct skewness_samp_storage * data;
  double m3;
  double m2;
  double mean;

  double ret;

  data = (struct skewness_samp_storage *) initid->ptr;

  if (data->count <= 2) {
    *is_null = 1;
    return 0;
  }

  mean = data->sumX / data->count;

  m3 = (data->sumXXX - 3 * mean * data->sumXX + 2 * mean * mean * data->sumX) / data->count;
  m2 = (data->sumXX - mean * data->sumX) / data->count;

  if (m2 <= 0) {
    *is_null = 1;
    return 0;
  }

  ret = sqrt(data->count * (data->count - 1) ) / (data->count - 2) * m3 / sqrt(m2 * m2 * m2);

  return ret;
}

void skewness_samp_deinit(UDF_INIT *initid) {
  if (initid->ptr) {
    free(initid->ptr);
  }
}