alpha_calc-suite.c

Go to the documentation of this file.

/*
** alpha_calc-suite.c
** 
** Made by (Johnny Q. Hacker)
** Login   <solarion@borkborkbork>
** 
    Copyright (C) 2009 Joseph Pingenot

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
** Started on  Fri Apr  3 13:56:33 2009 Johnny Q. Hacker
** Last update Sun May 12 01:17:25 2002 Speed Blue
*/

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <CUnit/CUnit.h>
#include "tests/cunit-local.h"
#include <glib.h>
#include "argdefaults.h"
#include "matdb.h"
#include "alpha_calc.h"
#include "alpha_calc-suite.h"
#include "wavefunction.h"

double* average_arrays(double *arrays[], int n_arrays, int array_size);
char* find_left_right_of_iface(double iface, int* prev, int* next, double *x, int N);

void check_iface_indices(void) {
  
}

void check_average_arrays(void) {
  double arr1[] = {0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0};
  double arr2[] = {7.0, 3.0, -4.0, 5.0, 7.0, 12.0, 13.0, 0.0, -5.0};
  double arr3[] = {7.0/2.0, 4.0/2.0, -2.0/2.0, 8.0/2.0, 11.0/2.0, 17.0/2.0, 19.0/2.0, 7.0/2.0, 3.0/2.0};
  double *arrs[] = {arr1, arr2};
  double *avg = average_arrays(arrs, 2, 9);
  CU_ASSERT(avg != NULL);
  if(avg == NULL) return;
  GString *s = g_string_new_len("", 1024);
  for(int i=0; i<9; i++) {
    if(avg[i] == arr3[i]) {
      g_string_printf(s, "OK: avg[%d](%g) == arg3[%d](%g)", i, avg[i], i, arr3[i]);
      CU_PASS_STRING(s->str);
    }else{
      g_string_printf(s, "FAIL: avg[%d](%g) != arg3[%d](%g)", i, avg[i], i, arr3[i]);
      CU_FAIL_STRING(s->str);
      fprintf(stderr, "%s\n", s->str);
    }
  }
  g_string_free(s, TRUE);
  if(avg != NULL) free(avg);
}

#define NUM_POINTS 4096
#define MINX -10.0
#define MAXX 10.0
#define SIGMA 1.0
void avg_discrete_func_gaussian_1(void) {
  struct mstar_wavefunction_1d* wf = mstar_wavefunction_1d_new_gaussian(NUM_POINTS, MINX, MAXX, SIGMA);
  CU_ASSERT(wf != NULL);
  double func[NUM_POINTS];
  double x[NUM_POINTS];
  double err;
  GString *s = g_string_new_len("", 1024);
  for(int i=0; i<NUM_POINTS; i++) {func[i]=1.0, x[i] = (wf->points)[i].x;}
  double result = average_discrete_function(func, x, NUM_POINTS, wf, 0, 1e-8, 1e-8, &err);
  if(fabs(result - 1.0) <= fabs(CLOSE_ENOUGH)) {
    g_string_printf(s, "OK: expectation value of 1.0 with gaussian wavefunc (%g) == 1.0 (err=%g", result, err);
    CU_PASS_STRING(s->str);
  }else{
    g_string_printf(s, "FAIL: expectation value of 1.0 with gaussian wavefunc (%g) == 1.0 (err=%g", result, err);
    CU_FAIL_STRING(s->str);
  }
  g_string_free(s, TRUE);
  mstar_wavefunction_1d_free(wf);
}

void avg_discrete_func_gaussian_x(void) {
  struct mstar_wavefunction_1d* wf = mstar_wavefunction_1d_new_gaussian(NUM_POINTS, MINX, MAXX, SIGMA);
  CU_ASSERT(wf != NULL);
  double func[NUM_POINTS];
  double x[NUM_POINTS];
  double err;
  GString *s = g_string_new_len("", 1024);
  for(int i=0; i<NUM_POINTS; i++) {x[i] = (wf->points)[i].x; func[i] = x[i];}
  double result = average_discrete_function(func, x, NUM_POINTS, wf, 0, 1e-8, 1e-8, &err);
  if(fabs(result - 0.0) <= fabs(CLOSE_ENOUGH)) {
    g_string_printf(s, "OK: expectation value of x with gaussian wavefunc (%g) == 0.0 (err=%g)", result, err);
    CU_PASS_STRING(s->str);
  }else{
    g_string_printf(s, "FAIL: expectation value of x with gaussian wavefunc (%g) != 0.0 (err=%g)", result, err);
    CU_FAIL_STRING(s->str);
  }
  g_string_free(s, TRUE);
  mstar_wavefunction_1d_free(wf);
}

void alpha_calc_suite_add_tests(CU_pSuite suite) {
  CU_add_test(suite, "interface_indices", check_iface_indices);
  CU_add_test(suite, "check average arrays", check_average_arrays);
  CU_add_test(suite, "averaging 1 with gaussian", avg_discrete_func_gaussian_1);
  CU_add_test(suite, "averaging x with gaussian", avg_discrete_func_gaussian_x);
}